A calm, transparent process. No theatre, no surprises.
After 20 years of doing this, we’ve found that the best software projects feel almost boring from the outside. Steady progress, decisions backed by data, working software in your hands every fortnight.
Discovery
1–2 weeks
We come in fresh and shine a torch on how the work actually flows. We measure where time goes, where errors land, which “we’ve always done it this way” habits are quietly costing you. Then we tell you what we found — sometimes including “don’t build the thing you asked for”.
What you get
- On-site time with the people who’ll use the software
- Data on where time is currently being spent (and lost)
- Map of current systems, workarounds and pain points
- A right-sized requirements document — including what we recommend not building
- A realistic estimate, broken down by phase
Design
2–3 weeks
A working prototype in days, not months. You click through it before we build it — which means the awkward conversations happen now, when changes cost nothing.
What you get
- Interactive prototype of the core flows
- Data model agreed with your team
- Visual design that fits your brand, not ours
- A delivery plan you’ve actually read and signed off
Build
Typically 8–20 weeks
Iterative releases every two weeks. Real software in your hands the whole way — so if a decision needs revisiting, we can revisit it on Tuesday, not in six months.
What you get
- A staging environment updated daily
- Demo every fortnight — show, not tell
- Automated tests for the things that matter
- Honest weekly notes: progress, blockers, decisions
Launch
2–4 weeks
Migration, training, hand-holding. We don’t disappear at go-live — we sit with the team for the first few days, when the questions are sharpest.
What you get
- Data migration from your legacy system, dry-run first
- Tailored training for each role that uses it
- Go-live support — we’re there in the room (or on the call)
- A 30-day stabilisation period, free of charge
Ongoing
Years
Software is never really done. Most clients stay with us for years — which means we keep learning more about your business, and the software keeps getting more useful.
What you get
- Predictable monthly capacity for new features
- Proactive monitoring, backups, security patches
- Quarterly reviews to revisit priorities together
- A direct line to the senior dev who built it
What we do differently and what we won’t do.
Senior people on the work
No bait-and-switch. The person who pitched you is the person writing the code. After 20 years, we’ve found that’s the only way it stays good.
We challenge what you’ve always done
Even when it’s awkward. Especially when it’s awkward. Then we earn the right to do it again on the next project.
Fixed scope, not fixed software
We agree what we’re building this phase. Then we ship it. Mid-build “oh, can we also…” turns into the next phase, with its own honest estimate.
Your data, your code
Source code in your repository, hosted in your accounts, deployable without us. We earn the next contract by being good, not by holding things hostage.
Working software, every fortnight
No big-bang reveals six months in. You see what we’re building as we’re building it, and steer the direction along the way.
Honest about what software can't fix
Sometimes the answer isn’t a new system — it’s a process change, or a tweak to the one you already have. We’ll tell you that, even when it costs us the project.
Sound like the way you want to work?
Start with a 30-minute discovery call. We’ll talk through what you’re trying to do and what a sensible first phase might look like.