How a project runs.
Five stages and two sign-off gates. You see working software every week, you approve every change in writing, and you own everything at the end.
Five stages. Two gates.
- Stage 1
Discover
We sit with the people who do the work and map the process as it really runs, including the workarounds.
- You provide
- An hour or two with the people who do the job, and a look at the spreadsheets and tools they use today.
- You get
- A problem map: what happens now, where time goes, and what is worth fixing first.
- Stage 2
Scope
GateWe turn the map into a written spec with a fixed price and a timeline. Nothing starts until you sign it.
- You provide
- Answers to our questions, and one person who can say yes.
- You get
- A spec and a fixed quote. You approve them, or we stop here and you keep the map.
- Stage 3
Build
We build in short cycles. Every week you click through the latest version on a staging site.
- You provide
- Thirty minutes a week for the demo, and quick answers when we ask.
- You get
- A weekly demo, a short written update, and a build you can try at any time.
- Stage 4
Launch
GateWe deploy to your accounts, move your data across, and train the team. You sign off when it works.
- You provide
- Access to your accounts, and the people who will use the tool for a short training.
- You get
- The live system, plus the handover package: code, documentation and a runbook.
- Stage 5
Care
Optional. We watch the system, fix what breaks and make small changes as the business moves.
- You provide
- A note when something needs to change.
- You get
- Monitoring, fixes, small changes and a monthly note on what we did.
No surprises.
A demo every week
One short call a week to show what changed. Between calls, updates come in writing, so nothing depends on memory.
Changes in writing
New ideas are welcome. Each one gets a short note with its cost and its effect on the date. You approve it before we build it.
One person, start to finish
The person on the discovery call is the person who writes the code. No hand-off to a junior team.
A full handover
At launch you get the code repository, the documentation, a runbook, and every credential in your own accounts.
You own the code
The code and the data are yours from the first deploy. You can run it yourself, hire someone else, or keep us on.
Built to keep running.
The habits we learned building software that moves real money. They are part of every build, not extras.
- Automated testsEvery important path has a test that runs on each change, so a fix in one place does not break another.
- Code reviewEvery change is reviewed before it ships, with automated checks for security issues and leaked secrets.
- Staging environmentA private copy of the system where every change runs first. You try it there before it reaches your team.
- Monitoring and alertsErrors and slowdowns raise an alert. We usually know about a problem before you do.
- Backups you can restoreDaily backups, and restores we have tested. A backup nobody has restored is only a hope.
- Security basicsRoles and permissions, an audit trail of who changed what, and secrets kept out of the code.
Start with a call.
Thirty minutes. Show us the process that hurts, and we will tell you which stage to start at.