We settle what should be built before we build it.
Whether it is a site that makes your company findable, or software your members sign into every week from a phone, the work starts the same way — with what should exist and why, settled and written down. It is slower to start with, and considerably cheaper to finish.
The expensive mistake is building the wrong thing well.
Software rarely fails because the code was poor. It fails because the wrong system was built carefully — the wrong data model, the wrong assumptions about who does what, the wrong guess about scale. Every one of those is cheap to change on paper and ruinous to change in production.
So we do the thinking first, in the open, and write it down. You see the reasoning before you pay for the implementation.
Three phases, and what you hold at the end of each.
Understand the problem. Decide the architecture. Commit to it. Each phase ends with something written that you can read and disagree with, which is the only reason any of it is worth doing.
Phase 1Understand the problem
Before anything is designed, we work out what is actually being asked. Most software that fails does so by solving a problem nobody had.
Talk us through how the work is done today — who does what, where it goes wrong, and what that costs you. No specification needed; the brief is what we are trying to arrive at, not what you have to bring.
A written statement of the problem, the constraints and the two or three journeys the organisation actually runs on — in your words, checked back with you.
What we are doing in this phase · 4 steps
Clarify the problem
Separate what you asked for from what you need. We ask what happens today, who it fails, and what that failure costs you — because a brief is already a proposed solution, not the problem itself.
Name the constraints
Budget, deadline, team, devices, network, regulation. In this market that usually means mobile-first, intermittent connectivity and local payment rails. Constraints decide architecture, so they go on the table before any architecture does.
Model the domain
Name the entities and the rules that bind them before choosing a database. A cooperative's membership and contribution rules are the product; the schema only records them.
Map the critical flows
Walk the two or three journeys the business actually runs on, end to end. An architecture that serves real paths beats one that serves an imagined feature list.
Phase 2Decide the architecture
Only once the problem is pinned down do we choose a shape. Every decision here is written down together with the reason it was made, so it can be argued with later.
Read the decisions and push back on them. This is the cheapest moment in the whole project to disagree, and the one place where an hour of your time is worth a fortnight of ours.
A shape you can see: what your members will use, what your staff will use, who can see what, and what happens when the network drops mid-transaction.
What we are doing in this phase · 4 steps
Choose the shape
Where state lives, what talks to what, what must happen now and what can wait. We pick the simplest arrangement that satisfies the constraints from step 02 — not the most impressive one.
Design the data layer
Schema, relationships, indexes and access rules together, in one pass. Row-level security and role claims are part of the data design, not a layer bolted on once the tables already exist.
Draw the trust boundaries
Decide what each kind of user can see and do, and where that is enforced. A permission checked only in the interface is decoration — it belongs where the data lives.
Plan for failure
Assume the payment webhook never arrives and the connection dies mid-transaction. What the system does when things go wrong is designed here, deliberately, rather than discovered in production.
Phase 3Commit to it
The last three steps turn a design into something you can hold us to — and something we can be measured against once the building starts.
Approve the design and the cost, or send it back. Nothing gets built against a document you have not agreed to.
A design document and a cost grounded in it — and, once building starts, a written note whenever reality forces a change, rather than a system quietly drifting away from what you signed off.
What we are doing in this phase · 3 steps
Cost it honestly
Estimate infrastructure and effort before committing to either. We optimise for the least cost that meets the requirement, because a modest system you will never outgrow is worth more than a clever one you cannot afford to run.
Write the design document
The design becomes an artifact you can read, question and disagree with — while disagreeing is still cheap. It is also the thing the finished build gets checked against.
Build to it, and revise out loud
Implementation follows the document. When reality contradicts it — and occasionally it does — we change the document and say why, rather than letting the system quietly drift away from its own design.
Not every project needs all of them. A brochure site for a company that wants to be found does not need a data layer designed around member roles. Software your members sign into every week does, and skipping it there is what produces the rebuild two years later. We tell you which of these a job is before you pay for any of it.
Have something to build?
Tell us the problem rather than the solution. The first steps above are a conversation, and they cost you nothing.
Start a projectThis is what the school teaches.
Understand the model before the syntax — the pedagogy on every course is the process on this page, at a smaller scale.
See the courses