Seven steps, no theatre.
A structured delivery process that keeps scope, cost and quality visible to you at every stage, from the first conversation to the version still earning its keep three years later.
- 01
Discover
1–2 weeksWe sit with the people doing the actual work. Read the tickets. Watch the workflow. Ask the questions that make the problem smaller and the truth larger. By the end we have an opinion, and the receipts to back it.
What you get out of it- Problem framing with named owners
- Constraints and non-goals in writing
- First draft of success criteria
- 02
Define
1 weekWe write down what we're building and, just as important, what we're not. Architecture sketch, data model, service boundaries, the API surface. Nothing shiny, everything reviewable.
What you get out of it- Scoped brief signed off by both sides
- Reference architecture and data model
- Risk log with mitigations
- 03
Design
2–3 weeksInterface, information architecture, and the wording of the error states. Design is not decoration, it's the shape of the product. We prototype the paths that carry real weight, and we test them with real users.
What you get out of it- Interactive prototype for the critical flows
- Component library seed
- Copy and error-state review
- 04
Build
OngoingSmall, senior teams. Two-week cycles. Working software at the end of every cycle, not a Jira status. Client engineers pair with ours from day one, because the code has to belong to the client at the end.
What you get out of it- Two-week release cadence
- Instrumentation from the first deploy
- Live changelog, no surprises
- 05
Test
ContinuousAutomated tests earn a place at the table only if they catch things humans miss. We add contract tests at every seam, staging that mirrors production, and a small feedback loop with real users we trust. Functional, performance and security testing all run before release.
What you get out of it- Contract tests across service boundaries
- Staging mirror of production
- Named feedback panel for early releases
- 06
Launch
1–2 weeksLaunch is a step in the plan, not a moment of drama. Feature flags, staged rollout, dashboards that tell us the truth in the first hour. Deployment, data migration, training and handover are all part of this step, not afterthoughts. If something goes sideways, we roll back cleanly and try again.
What you get out of it- Rollout plan with rollback criteria
- First-hour observability board
- Post-launch review, in writing
- 07
Support
The long runThe release is the beginning. Monitoring, maintenance and continuous improvement, for the second, third and fourth versions. We transfer knowledge deliberately so the client team owns the system, and we are happy to work ourselves into a smaller role. That's the point.
What you get out of it- Roadmap grounded in usage data
- Playbooks for on-call, incidents, upgrades
- Handover milestones with named owners
Four things that do not depend on the step.
The seven steps describe the shape of a project. These four apply at every one of them, and they are the part clients tell us they notice most.
Visibility
Regular progress updates and demos, so scope, cost and quality stay visible at every stage rather than at the end.
Documentation
Architecture and handover documents produced as part of the work, not written up afterwards from memory.
Ownership
Source code and IP transferred to the client. What we create for you belongs to you.
Continuity
Post-launch support and improvement options, so there is no cliff edge the week after go-live.
The commercial shape is separate from the delivery shape. See the four ways to engage us.
Four defaults we do not negotiate.
Two-week cycles, always.
Every fortnight there is running software and a written decision log. No quarterly reveals, no big-bang releases.
One team, one payroll.
The engineer in your standup is the one shipping the code. No agencies-behind-agencies.
Write down the non-obvious.
If a decision took an argument to reach, it goes in the decision log, searchable, dated, credited.
We plan for the second release.
First-version decisions get judged on how well they survive the second, third and fourth releases.
It starts with
discovery.
One to two weeks, and no proposal until we understand the problem, the constraints and what shipped actually looks like. Tell us what you are working on.