Skip to content

Jacobs · 2025–present

Engineering mission software across teams and programs

Hands-on engineering and cross-program technical leadership across aerospace mission software, shared engineering systems, integration, and internal and partner teams.

Staff Aerospace Software Engineer — implementation, cross-program technical direction, platform practices, and engineer development.

  • Python
  • AWS
  • Kubernetes
  • DevSecOps

Impact & evidence

Core program: ~12 repositories · 4 environments · ~6 engineers

Cross-team SAFe Agile. Core-program scale; broader influence is shared practices and coordination across additional aerospace efforts.

On this page

Problem

  • Independently developed services need compatible interfaces and repeatable integration.
  • Delivery conventions varied by repository, which made reviews, testing, and releases harder to trust.
  • Core-program integration spans roughly 12 Python repositories and four environments; shared interfaces, technical coordination, and cross-team SAFe Agile also cross program boundaries.

Decisions

  • Put CI/CD, two-approval review, testing, type-checking, security, coverage, and release practices on a shared baseline.
  • Separate application messaging from the broker behind a common interface and adapters.
  • Treat tests that do not exercise behavior, and late integration, as defects in the engineering system.

Engineering delivery system

Validation feedback

  1. Local development

    Code

    Pre-commit

    format · lint · imports · types · secrets

    Commit / push

  2. Repository validation

    Pull request

    Review

    2+ approvals

    CI pipeline

    unit tests · coverage · SAST

    dependency audit · build

    Merge gate

    review + CI pass

  3. Change intelligence

    Change detection

    Delta tagging

    Cross-repo impact

  4. System validation

    Integration tests E2E tests Environment validation Release

Local checks run on the workstation; CI provides the authoritative repository gate. Downstream validation covers cross-repository and environment-level behavior. Simplified, unclassified delivery view—not a program architecture.

Evidence

Core-program engineers
~6
Core-program repositories
~12
Repository test coverage
≥80%
Adopted Delivery gates
Shared CI/CD, two-approval review, testing, type-checking, security, coverage, and release baseline in use across the repositories in scope.
In use Portable messaging
Common interface and broker adapters supporting configurable broker choice.
In progress Unit-test standard
Written and used in review; continuing improvements to isolation, representative data, and failure cases.
Ongoing Cross-team delivery
Integration strategy, dependency sequencing, and technical coordination across internal and partner teams.
Shipped Coaching
Approximately six engineers onboarded and coached through technical feedback, engineering standards, and structured growth plans.

Outcome

  • Established at least 80% repository test coverage, two-approval pull-request governance, and automated quality gates across the repositories in scope. Releases are safer and more predictable.
  • Shared delivery gates are the adopted baseline across those repositories.
  • A portable messaging layer is in use so broker choice can stay in configuration.
  • Stronger unit-test expectations are defined and applied in review; behavior-focused improvements continue on changed code.
  • Six engineers onboarded and coached while the same practices were reinforced in review.

Scope

My scope
Hands-on implementation, technical execution, engineering standards, and engineer development. Core-program scope: about 6 engineers across roughly 12 Python repositories and four deployment environments.
Broader influence
Cross-program integration strategy, shared interfaces and engineering practices, partner-team dependencies, architecture decisions, and release readiness across aerospace mission-software efforts.

Team & contribution

Contribution
Hands-on cross-program technical leadership
Team & partners
Core team of about 6 engineers, with collaboration across additional internal and partner teams
What I improved
Onboarding, technical feedback, and turning integration problems into tickets while the change is still cheap.
Key decision
Treat weak tests and integration risk as engineering work, not process leftovers.

A concrete defect: some tests reported coverage without failing when the behavior was wrong, including filters whose no-op path never triggered a failure. Remaining test work is quality — isolation, representative data, and failure cases on changed code — not another coverage number.

Delivery practices

A change is ready when another engineer can review it, rebuild it, and see the evidence. These expectations live in tests, CI, review, and coaching, not in a separate process checklist.

Definition of Done

  • Purpose, scope, and ownership are clear.
  • Tests cover changed behavior, including relevant failure cases.
  • Required quality, packaging, dependency, and security checks pass.
  • Interfaces and deployment assumptions have been checked, with remaining risks recorded.
  • Versioning, release notes, and supporting documentation are ready for the next person.

Pull request rubric

Review for correctness at boundaries and failure cases, evidence that tests check meaningful behavior, maintainability of interfaces and error handling, and context for important decisions. Reviews should improve the change and help the author understand why.

Make integration risk visible

A working component is not a working release. Identify dependencies and interface assumptions before they block implementation, exercise integration paths throughout development, and record blockers, ownership, and the evidence needed to move forward. Keep changes small enough to test, explain, and recover.

Make the practices shared

Put repeatable checks into tooling rather than reminders. Explain the reasoning in reviews, include release expectations in onboarding, and adjust practices when they add work without improving delivery.