We can solve almost anything. The hard part is working out what to solve.
What we sell is a way of working, not a product you log into. We deconstruct the problem before we touch a tool, prototype to find out what holds, and run the result with you afterwards. The sections below go in order: the method, the engagement, what it costs, what we own and what you keep, and who’s doing the work.
The big diamond is the problem
Most software fails long before anyone writes code. It fails in the framing — building the wrong thing well. So we spend the front of every engagement on the problem itself: pulling it apart, finding where it actually lives, ruling out the solutions that only look right. The problem diamond is the wide one. The solution diamond, once you’ve earned it, is narrow by comparison.
Through both diamonds we build to find out, not to finish. We get something in front of real people early, watch what it does, and are happy to throw a prototype away when it tells us something. The draw on your team is light — messy notes and a few sharp conversations are enough. Our tooling does the lifting.
Discovery, pilot, operate
Ambiguity isn’t a reason to wait — it’s a reason to start small. Every engagement enters at Discovery and earns its way forward. Nobody commits to a build before discovery has shown it’s real.
- Step 1Two to four weeks · low commitment on your side
Discovery
Low cost, high ambiguity. We work out what actually needs solving, model the system underneath it, and prototype far enough to know it can be done. Most of the value is here — and most of where software goes wrong.
From US$5k per problem. You leave with a real artefact and a no-regrets decision, whichever way it goes.
- Step 2Scoped together
Pilot
We configure the chosen solution for your context and stand it up in front of real users. A configuration fee for the working pilot, plus the start of the ongoing subscription. Build, measure, learn: get it in real hands, watch what holds, change what doesn't.
- Step 3Rolling, short minimum
Operate
Running it with you after go-live. Measurement, content refresh, integration drift, the steady stream of small changes real use generates. The change budget tapers as your team picks up more. The next thing gets added when it earns its place, not before.
A private, secure mini-site — not a slide deck — that holds five things:
- Our reading of the problem — what actually needs solving, and what doesn't.
- A recommended solution, with the system modelled underneath it.
- An interactive prototype or proof of concept you can put in front of people.
- A business case: the way it works now against the proposed way, and what the change is worth.
- A proposal — cost and plan for the pilot.
Enough to make a confident go or no-go call on the pilot. If the answer is no, you’ve spent little and learned a lot.
A fraction of what it’s worth
We pursue problems that deliver at least US$100k a year in value — and the fee is always a fraction of that. Roughly: if solving it is worth six figures, the engagement costs a fifth of what it returns. We’d rather walk away from a problem that’s too small than dress up a minor time-saving as transformation.
That’s why there are no day rates anywhere on this site. Days measure our effort; you care about the result. Discovery is priced low so the first step carries almost no risk for you. What you pay after that is tied to the value in front of you, not the hours behind it.
Take a process costing a team a few hundred thousand a year in duplicated effort and missed work. Discovery from US$5k tells you whether it’s solvable and how. The pilot carries a configuration fee and starts the subscription. Operate runs as an ongoing monthly fee against value that recurs every year it’s live.
Our method is ours. Your configuration is yours.
The thing we’ve spent years building is the method itself — how we take a problem apart and how we assemble a solution from primitives we’ve made before. That stays ours, and it’s what lets discovery be cheap and the build be fast.
The layer configured for you — the part that knows your domain, your data, the way your team actually works — is yours. You pay to use what we’ve built around your problem; you don’t buy the engine underneath. That’s the difference between a subscription and a one-off bespoke bill, and it’s the reason you’re not carrying the cost of a from-scratch build.
Every handoff is a translation, and every translation loses something
The usual setup hands strategy to a product manager, to engineers, to designers — and back. Specs drift. Intent flattens into tickets. Most of the cost and most of the failure live in the seams between roles, not in the roles themselves. With us, those roles are one team.The person who understood the problem is the one building the fix — no re-briefing, no queue between functions. Remove the handoffs and you don’t patch the failure modes; you never have them.
We model the system before we reach for a tool
We’re systems thinkers. Faced with a problem, we don’t start from the fashionable default — we decompose it, map how the parts actually relate, and only then pick the approach that fits. Where another firm reaches for whatever pattern is in vogue, we choose the one the structure asks for: a knowledge graph over naïve retrieval when the relationships are the problem. Not the convenient tool. The matched one.
Agents do the heavy lifting, so the team stays small
Background research across dozens of sources, a synthesis of how others have solved the same thing, the first cut of the problem map: those run overnight in parallel across AI agents. A small team gets through the work of a much larger one, the cadence inside a pilot stays fast, and the demand on your people lands at decision points instead of in standing review meetings.
Start with a conversation.
We can usually tell within an hour whether discovery is the right first move, or whether we’re the wrong partner for this one. Neither answer costs you anything.