The RAPID model
For the working definition of each phase — entry/exit criteria, handoffs, gates and scaled variants — see The RAPID process.
A pipeline, then a loop
RAPID is a one-time pipeline feeding a permanent loop. Five phases run once, each with a deliverable; the last two become a loop that runs forever.
| # | Phase | Focus | Deliverable |
|---|---|---|---|
| 1 | Definition | research → PFD | A PFD — research synthesised into a plan |
| 2 | Design | flows · data · screens | UX flows, a data model and key screens |
| 3 | Tech selection | stack + tools | A stack chosen + a reusable playbook |
| 4 | Build | everything + docs/tests | Working software, to standard, with docs & tests |
| 5 | Refinement | acceptable → good | A tighter build — acceptable raised to good |
| 6 | Flow-state | friction → flow | A polished build — friction removed |
| 7 | Production | secure · shipped · operable | A live release — secure and operable |
Why every phase now earns its keep
A rigorous lifecycle used to be affordable only for big bets — so the careful parts (capture, polish, hardening) got cut first. When an agent does the execution, every phase gets cheap. So you run the full lifecycle at any scale — a feature, or a one-hour bugfix — and still capture what you learn.
The human stops typing, not deciding: taste, trade-offs and authorisation move up; execution moves to the agent.
Enterprise quality is embedded automatically
Two core things run through everything:
Documentation + tests
- Created in Build — alongside the features, not after them.
- Updated forever in Flow-state — as the product evolves and friction is removed.
- They're the artifacts that compound: docs, tests, runbooks, memory.
Security
- Not a final gate bolted on before launch.
- "Production-ready" means production-ready and secure.
- Guardrails are enforced throughout — you never blast production to find out.
Flow-state: innovation = evolution
Many methods stop at "it works." True innovation begins at "let's make it better." Flow-state is the phase that makes building itself faster — remove friction, add polish — and it's the one almost everyone leaves out:
- Runbooks — never re-derive a fix.
- Memory — gotchas captured once.
- Tests & docs — kept current, always.
Every loop deposits capital — updated docs, tests, playbooks, memory — so the next turn starts faster than the last. Velocity compounds.
How the process connects
Insight flows in, delivery flows out:
- Inputs (e.g. an insurance specialist): domain expertise frames the problem, the rules and the edge cases; client and market signals decide what gets built first; existing systems and data set the real-world constraints.
- The engine: turns raw insight into working software through rapid, AI-driven build cycles; specialists validate every iteration; governance, testing and review are built in — not bolted on.
- Outputs: go to market — a production-ready product plus the collateral to sell it; support — documentation, monitoring and a rapid-fix loop. Live feedback returns as new input, so the cycle keeps improving.