Is the prototype an extra?

No, it's included in the fee. Most people assume anything that actually runs costs more, and with a lot of agencies it does: a paid discovery that produces a document, then a separate quote to build something you can click. Ours is one price for both, because a recommendation you can't try isn't much of a recommendation.

Does it come off the price of the build?

No. It's a separate piece of work with its own deliverable. If it credited against a build, we'd have a quiet interest in there being a build, and the whole value of the exercise is that we don't.

What if you tell us not to build anything?

Then you've saved considerably more than the fee, and you keep the map and the roadmap. It's happened. We'd rather say it in week one than take the money and build something we don't believe in.

How is this different from a consultancy?

A consultancy delivers a report. We deliver a working prototype with your data in it, a fixed price, and the ability to build the thing ourselves. The analysis is the same discipline; what's on the table at the end isn't.

Our team are nervous about this. What do we tell them?

The truth, and early. There are two fears and they're different: whether someone loses their job, and whether they're left with the boring half of it. We don't sell headcount savings — that's a rule, not a preference — and on the second one we'd rather design around it than reassure people about it. Some work genuinely is better done by a machine, and a person doing it is being wasted. What we protect is the judgement, the customer contact and the difficult conversations. We'll say all of that to your team directly if it helps.

How much of our time does it take?

An hour or two each with three or four of your team, and someone available to answer questions. That gets us further than a month of meetings with management. The rest of the work is ours.

We're smaller than six people. Can we still get one?

Probably not usefully. Below that size the problems are real but the analysis is disproportionate: you'd be paying us to tell you things you already know. Talk to us anyway and we'll point you somewhere sensible.

Analysis and Prototype

See it running before you decide.

A short paid look at how your business actually runs: the workflows, the software, the culture, and where all three cost you. You come away with a map, a roadmap and a proposal, judged against a working prototype.

Take the 5-minute assessment Book a 30-minute call

Price: From £3,000, by business size
Timeframe: Days of our time, spread across weeks of yours
You get: A map, a roadmap and a fixed-price proposal, judged against a working prototype
Best for: Businesses of 6 to 200 people that don't yet know what to build

Most software agencies take a brief and execute it. The trouble is that the brief is usually a guess, and a guess built well is still a guess. We start a step earlier.

We spend time inside the business with the teams that run it: how work actually moves, what software you're already paying for, where things break, what that costs, and the culture around all of it, because a system nobody wants to use is a system nobody uses.

You come away with a workflow map, a roadmap and a proposal that sets out plainly what we'd solve and what you'd gain, judged against a working prototype running on your own data. It's a separate piece of work with its own price. It isn't a deposit and it doesn't come off a later build, which is precisely what lets us tell you the answer is to build nothing, when that's the answer.

What's actually involved.

Shaped around your work rather than a fixed package. This is the shape of the conversation, not a product spec.

The teams, not the org chart: We work with each team that touches the work, not just the person who owns the problem. The estimator, the supervisor, the admin who holds it together, whoever is actually filling in the sheets. They know where it's broken, and they'll usually tell you if you ask properly.
The whole workflow, mapped: One job followed from enquiry to invoice, and every handover between teams marked: every point where something gets re-typed, printed, photographed or chased. That map is a deliverable, not a working note. Most clients have never seen their own business drawn end to end.
The software you already have: What you're paying for, what's actually used, and what's quietly been replaced by a spreadsheet. If a tool you've already bought could do the job properly, that's a cheaper answer than ours and we'll say so. It happens more often than you'd expect.
How the job is actually done: Not the version in the process document: the version people follow. Most businesses have both, and they diverged years ago. Writing down the real one is half of what makes a system usable, and it's usually the first time anyone has seen the whole procedure in one place.
The culture around it: The part most analyses skip. Who trusts which system, where the workarounds came from, which change failed last time and why people still talk about it. A system nobody wants to use is a system nobody uses, and that's a cultural fact, not a technical one.
What people should be doing instead: Some work is better done by a machine, and putting a person on it wastes them: re-typing, chasing, checking a thing twice because nobody trusts the first check. What people are good at is judgement and difficult conversations. We look for where that's being squeezed out, and occasionally we'll tell you not to automate something because the judgement in it is the reason the job is worth doing.
The argument about why: Putting a broken process into a nice interface gets you a nicer broken process. So we work through why things are done the way they are: whether that form needs six fields, which step exists because of a problem that got solved in 2019.
The prototype: A working version of what we're proposing, with your data in it. Not a slide deck of screens. It's the difference between agreeing to a description and agreeing to a thing, and it's where most of the good arguments happen.

Stages one and two of the method, in detail

How it runs.

Four stages, and only the first two need much of anyone's time. You'll know who we need and when before we start.

Days of our time, spread across weeks of yours. Department leaders have day jobs and the sessions fit around them, so your part is a few hours, the calendar is weeks, and most of the work happens in between, where you don't see it. We'd rather say that now than have the calendar surprise you.

The shape of it
You, or whoever holds the whole picture
One session, high level. What the business does, how work moves from first contact to paid, where it hurts, and how you'd know if it got better. Plus what software and written procedure you already have. No detail yet. We're after the outline.
The detail
Team and department leaders
The long part. One job followed end to end and every handover between teams marked, then the same conversation with each team that touches it, including the people actually filling in the sheets, who know exactly where it breaks. This is where the weeks go.
The plan
Just us
We go away and argue with what we found. Out of it comes a phased plan: the process changes worth making, what to build and in what order, and what can safely wait. Some of what changes isn't software at all.
The demo
Back with you and whoever signs it off
A working prototype with your own data in it, not a slide deck of screens, presented alongside the plan and a fixed price. It's the difference between agreeing to a description and agreeing to a thing.

Then it's a decision. If it's a yes, we build. If it isn't, the map, the plan and the proposal are still yours: it's a record of your business, not ours.

A typical analysis, stage by stage.

A ten-person contractor: four in the office, six engineers on the road. Installs and servicing. £3,000. About five hours of the owner's time, and a good deal more of ours. Here's what happened in both.

A composite, assembled from analyses we've run rather than a single client's. Every example below happened; they didn't all happen to the same company.

The first session
Two hours, with you
The outline. What the business does, how a job moves from first enquiry to money in, what hurts most, and how you'd know if it got better. Then what you already pay for — every subscription, every tool — and what procedure exists in writing.
They paid monthly for a scheduling system. Two of six engineers opened it. The other four ran off WhatsApp, so the schedule on screen was accurate for a third of the team and the office had quietly stopped trusting it.
The long stretch
An hour each from five or six of your people
The part that spreads out, because sessions fit around people's actual jobs. We follow one real job end to end and mark every handover, then sit with each team that touches it: the estimator, whoever raises invoices, two engineers on the phone from site.
One job number, written down four times in three places. Two of the four disagreed, and the office had a convention about which to trust that nobody had ever said out loud.
Away from you
None of yours. Most of ours.
The bulk of the work, and none of it in your diary. Every session transcribed and reconciled against the others, because two people described the same job differently and one of them is right. Every tool you pay for read properly, and every workaround costed. Then the argument: which steps exist because of a problem solved years ago, what's worth changing, what to leave alone. Then working software, built with your own jobs in it, so what you're shown at the end is your business running the new way rather than a description of it.
The invoice went out seven weeks after the job finished. Not because anyone was slow: the signed sheet spent six of them in a van. Their cash flow problem was a paperwork problem wearing a disguise.
The last session
Two hours, with you and whoever signs it off
The map, the roadmap and the proposal with a fixed price against it, presented alongside a working prototype you can click through rather than a document you have to imagine.
They came in wanting a new CRM. Sales was the one part of that business working properly. The cost was all in the handover between the office and the vans. We said so, and it made the job smaller.

None of that was on the brief they came in with. At fifty people it's the same stages over a longer calendar and more of your team's hours than yours: more departments, more handovers between them, and that's still where the cost turns out to be hiding.

What the map looks like.

One job, three departments, and the two places it stopped. Every handover between teams is marked, because that's where the time and the mistakes collect — not inside any one department.

Those two crossings cost that business six weeks and an argument with a customer. Neither was on the brief they came to us with.

How it's scoped and what it costs.

What the fee buys is the answer to the expensive question. The smallest operating system we build starts at £12,000, and the most common way that money gets wasted is building the right thing for the wrong problem. The contractor above came in asking for a CRM. Finding out what a business needs before the first line is written is the smallest number in the whole thing, and it's the one that decides whether the rest is worth spending.

Priced by the size of your business, because that's the one number you know before we start: £3,000 for six to twenty people, £5,000 up to fifty, from £8,000 above that.

The working prototype is included at no extra cost. Most people expect to pay separately for something that runs, and plenty of agencies do charge for a paid discovery and then charge again to build anything you can click. Here it's part of the same fee. It stays with us rather than being handed over: it's the first working piece of the build, and what you take away is the map, the roadmap and the proposal.

Days on site, not months of meetings. Exactly how long is agreed in the proposal, once we know what we're walking into: a twelve-person firm with four departments' worth of tangle isn't the same job as a twelve-person firm doing one thing well.

It doesn't come off the cost of a build. It's a separate piece of work with its own deliverable, and pricing it that way is what keeps the recommendation honest.

Both of the systems we've been running for over a decade started this way, with the time taken to work out what the business actually needed, rather than building what was first asked for. See the work

Not sure what's right for you?

Take the 5-minute assessment. 12 quick questions, and we'll tell you honestly whether you need a partnership, a one-off build, or nothing from us at all.

Take the 5-minute assessment

Sound like the right size of job? Half an hour, no charge, and you'll know.

Book a 30-minute call

The questions this usually raises.

Because a free proposal is a sales document, and it recommends what the person writing it sells. We charge for the analysis so the recommendation isn't buying anything, including the occasional recommendation to spend nothing. What you get back for the fee is a map of your own business, a roadmap and a fixed price, all of which you keep whatever you decide, plus a working prototype to judge them against.

Sound like what you need?

Half an hour, no charge. Tell us what the job is and we'll tell you what we'd do, what it'd cost, and whether it's worth doing at all.