One pipeline. Seven phases.
Every program starts with engagement — then moves through the same disciplined seven-phase lifecycle, run on an Agile/Scrum cadence with DevSecOps practices the whole way down.
The Lifecycle
Seven phases from discovery to maintenance — the iterative backbone every project moves through.
Agile / Scrum
The cadence the lifecycle runs on: sprints sized to the program, a visible backlog, a demonstrable result every iteration.
UX & Human Factors
The human side of the system — task models, operator workflows, and validation with real users, from discovery on.
DevSecOps
Security and automation built into every phase — not bolted on at the end.
The lifecycle reads as a sequence — it doesn’t run as one. Within a sprint, or a group of sprints, several phases run in parallel against the same unit of work, and each phase is revisited again and again along the program timeline.
Engagement
Contract type, fees and initial costs, and scope agreed up front — everything required to move forward officially, contract in hand. Engagement typically happens once per program.
Discovery
Requirements, domain research, and early prototypes to retire technical risk before the build starts.
Design
Architecture and technical design — plus UX and art direction where the work calls for it — built for the target hardware from day one.
Development
Sprint-based build against a prioritized backlog. Every sprint ends with working, demonstrable software.
Verification
Unit, integration, and performance testing; formal V&V against source data for simulation work.
Deployment
Release candidates run in a production-like staging environment for acceptance testing, then roll out as a versioned, repeatable release — storefront, customer network, or air-gapped installation.
Monitoring
Telemetry, crash reporting, and performance metrics from the live system, feeding back into the backlog.
Maintenance
Patches, updates, and long-term support on an agreed cadence. Twenty-five years in, we still support what we ship.
The lifecycle isn’t a waterfall. From discovery through maintenance, work runs in sprints sized to the program — planned against a backlog you can see, ending in something you can evaluate, and re-prioritized as the program learns.
Have a formal, nailed-down requirements baseline? We also run traditional waterfall programs when the contract or the mission calls for it.
A demonstrable result, every sprint
Sprints end in something you can evaluate — working software once the build is underway; prototypes, designs, or findings in early and design sprints. Demos are the status report.
A backlog you own
Priorities live in a backlog you can see and reorder. When the mission changes, the plan changes with it — without a change-order fight.
Retros that change the process
Every sprint closes with a retrospective, and what we learn adjusts how the next one runs. The process itself is iterated.
Whether the user is a player or an operator, the interface is where the software succeeds or fails. UX runs through the lifecycle — heaviest in discovery and design, validated continuously through development.
For simulation and defense work that means human-factors engineering: task models, operator workflows, and interfaces built for high-workload, high-consequence environments. For games, the same discipline shows up as playtesting and feel.
Security isn’t a phase at the end — it’s a property of the pipeline. Every commit is built, tested, and scanned automatically; every environment is versioned and reproducible.
The depth is scaled to the program: a defense system with compliance requirements gets the full pipeline below; a commercial title gets the automation that earns its keep — CI, testing, reproducible builds — without the ceremony it doesn’t need.