How we work

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.

Why it works this way

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.

What that buys you
A written design you can read and disagree with
A cost estimate grounded in decisions, not optimism
Fewer surprises once the building has started
A system whose shape someone can still explain in a year
The process

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.

What you do

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.

What you have at the end

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
01

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.

02

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.

03

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.

04

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.

What you do

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.

What you have at the end

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
05

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.

06

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.

07

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.

08

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.

What you do

Approve the design and the cost, or send it back. Nothing gets built against a document you have not agreed to.

What you have at the end

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
09

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.

10

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.

11

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.

Does every job get all of this?

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.

For businesses

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 project
The same idea, taught

This 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