How we work
Every project follows the same six stages, with working software shown early and often so that direction is validated before the budget is spent.
Six stages, what happens and what you get
- 01
Discovery
Usually 1 to 4 weeks
We map your processes, users, data and the systems around the project, and agree what success looks like.
What we need from you: Access to the people who run the process today, sample data and any existing documents.
You receive
- Written scope with assumptions
- Prioritised module list
- Risk list and integration inventory
- Estimate and phased plan
- 02
Design
Overlaps with discovery and early build
Architecture, data model and interface flows are drawn up and prototyped, then reviewed with the people who will use them.
What we need from you: Feedback on prototypes within a few days, and one decision maker for scope questions.
You receive
- Architecture and data model
- Clickable prototype of the core flows
- Security and role model
- Release plan
- 03
Build
Iterative, in releases of 1 to 3 weeks
Working software is delivered in small releases with demos, code review and automated tests, so direction is validated early.
What we need from you: Attend short weekly demos and accept or challenge each release against the agreed criteria.
You receive
- Weekly demos on a staging site
- Source code in your repository
- Automated tests and a CI pipeline
- Progress report against the plan
- 04
QA
Continuous, with a hardening phase before each launch
Functional, regression and security testing, plus performance checks on realistic data volumes.
What we need from you: User acceptance testing with real scenarios.
You receive
- Test plan and results
- Defect log with severity
- Security review notes
- Go-live checklist
- 05
Launch
Planned and rehearsed
Deployment, data migration, training and a monitored go-live, with a rollback plan.
What we need from you: Sign-off on migrated data and nominated users for training.
You receive
- Production environment and backups
- Migrated data with reconciliation
- Role-based training
- Hypercare period
- 06
Support
Ongoing
Bug fixes, upgrades, monitoring and enhancements, including for systems we did not originally build.
What we need from you: A named contact for requests and a monthly priorities call.
You receive
- Response times agreed in writing
- Framework and dependency upgrades
- Monitoring and incident response
- Monthly report
Engagement models
Pick the model that fits how certain the scope is.
| Model | Best when | How it works | Watch out for |
|---|---|---|---|
| Fixed price | Scope is clear and unlikely to change much | Defined deliverables, milestones and a written estimate after discovery. | Changes go through a change request, so leave room for learning in the first phase. |
| Time and material | Scope will evolve as you learn | You pay for effort with transparent weekly reporting and an optional budget cap. | Needs a product owner who prioritises the backlog every week. |
| Dedicated team | A long-lived product or ongoing roadmap | Engineers work as an extension of your team on your tools and rituals, with a monthly commitment. | Works best with clear ownership on your side and a stable backlog. |
Process questions
›Do you work in sprints?
We deliver in short iterations with a demo at the end of each, whichever name you give them. Release length is agreed in discovery.
›Who owns the code and data?
You do. Code lives in a repository you control, and we hand over documentation and environment access at the end of each phase.
›How do you communicate during a project?
A shared channel, a weekly demo and a written weekly report. You always know who is accountable for what.
›What happens if requirements change?
Changes are logged with their effect on cost and timeline before they are approved, so nothing is a surprise.
›Can you start with a small paid discovery?
Yes, and we recommend it. It turns unknowns into written assumptions before you commit to a build budget.
›How do you handle security?
Least-privilege access, encrypted connections, code review, dependency scanning and secrets kept out of code. Requirements specific to your sector are agreed in discovery.
Start with a discovery call
We will help you pick the model that fits.