Custom software is only unboundedif nobody bounds it.
Four phases. Each one ends with something that works, and you can stop after any of them without losing what you have paid for.
What actually happens first.
In order, though not on a schedule — we would rather not publish a timetable we have not yet had to keep.
You send us something real
A spreadsheet, a description in your own words, or the thing you tried that did not work. Not a specification — if you had a specification you would not need us.
We come back with what we think it is
In writing, before any call. What we think you are actually trying to fix, which parts of it are software problems and which are not, and what we would want to look at first.
Ninety minutes with the people who do the work
Not with whoever owns the budget — with whoever runs the process. The gap between how a business believes it operates and how it operates is where the cost is, and it is only visible from the second group.
You get the map, whether or not we continue
Written up as a document you can circulate. Several people will want to argue with it. That argument is the most valuable thing in the whole process and it costs you nothing.
Nothing above is billed, and none of it commits you to the phase after it.
Four phases. You can stop after any of them.
Each one ends with something that exists and works. Nothing here requires the phase after it, and nothing you have paid for stops being yours if there is no phase after it.
Map
We sit with the people who actually do the work and write down how the process really runs — including the parts that only exist in somebody's head, and the parts nobody has admitted to yet.
- What exists at the end
- A map of your operation as it is, and a build plan against it: what to build, in what order, and what we would leave alone.
- If you stop here
- Most engagements could stop here and still be worth what they cost. The map is the thing you were missing; several people will want to argue with it, and that argument is the point.
- What is yours
- The map and the plan. Yours to take to anyone, including someone else.
First working slice
We build the smallest part of the plan that is useful on its own, and put it in front of real people doing real work. Not a prototype and not a pilot — the actual thing, in production, with your data in it.
- What exists at the end
- Working software that a real person uses to do a real job, and the first honest read on whether the plan was right.
- If you stop here
- You keep running it. It is in your accounts, on your infrastructure, with the repository in your name — so stopping here leaves you with software, not with a bill for a discovery exercise.
- What is yours
- Everything above, plus the software and the repository. From commit one, not from final invoice.
Build, in slices
The rest of the plan, the same way: one slice at a time, each with its scope fixed before it starts and each ending with something in production. What we learn in one slice changes the next — which is the whole reason not to fix the scope of all of them up front.
- What exists at the end
- The system, arriving in usable pieces rather than in one delivery at the end.
- If you stop here
- After any slice. There is no phase you are locked into finishing, and no slice whose value depends on the one after it — that is a constraint on how we cut them, not a promise about how they will feel.
- What is yours
- Everything shipped so far, running, in your accounts.
Run
Monitoring, security and dependency updates, backups that are restored and verified, and the changes the business needs as it changes. This is where every other timeline ends and where the actual cost begins.
- What exists at the end
- A system that is still correct in three years, and someone whose job it is to keep it that way.
- If you stop here
- Any month. Notice period is in the contract and it is short. Leaving does not mean losing the system, because it was never held anywhere you could not reach.
- What is yours
- All of it, plus the documentation, the credentials and the runbook needed to hand it to someone else.
You are never more than one phase committed. That is the only structural difference between this and a fixed-price project, and it is the one that matters when something turns out to be harder than anyone thought.
What is fixed at each gate, and what is deliberately left open
| Fixed | Open |
|---|---|
| The price of the phase you are in. | The price of the phase after it, until the phase you are in has told us what it costs. |
| The scope of the phase you are in, written down before it starts. | The scope of later slices, deliberately — what one slice teaches us changes the next. |
| That the phase ends with something that works. | Which slice comes next. That is a decision you make each time, not one you made at the start. |
A fixed price for the whole thing, quoted before anyone has looked properly, is not certainty. It is a guess with a penalty attached — and the penalty is usually paid in scope rather than in money.
We do not publish how long a phase takes, and we will not quote you one on a first call. We have not run this enough times to give you a number that would still be true afterwards, and a timetable invented to sound confident is the thing that goes wrong on every project you have already been on.
There are no prices on this page. The bands exist, and they are draft — the build fails if a draft number renders on a public page, which is deliberate. You will get a real one in writing after the map, for the phase after it, and never for a phase nobody has looked at yet.
Three ways to start
- One file, and nothing else — no pitch, no call. You keep a real teardown of it, within two working days.
- Four minutes and one description, in your own words. You keep a scoped project brief, whether or not we ever speak.
- Ninety minutes, and we map how your operations actually run. You keep the map either way.