Methodology
Six phases. Real software. Modular by design.
The six phases
Phase 1
Discovery
We listen, and we ask a lot of questions. We want to understand three things:
- what you have today
- where you want to get to
- the key bottlenecks stopping you from getting there
Step by step, not big bang. We identify the first bottleneck — the one whose removal will deliver visible benefit fastest — and build a plan to solve it.
The point of starting small is confidence. When you and your team see the first benefit land, the friction comes off every step after it. Every step is anchored to your overall objective.
Result: a clear picture of where you are, where you’re going, and exactly which problem to tackle first.
Phase 2
Specification
Before we build, we write down exactly what this step will do, in plain language. You review it. We discuss it. We sort out the questions. Once it’s agreed, it becomes the spec we’ll build against.
What we don’t do: hand you a 47-page report trying to pin down the whole system up front. We’ve seen them. They’re overwhelming, nobody reads them, and they pretend nobody is going to change their mind. As the work progresses, you’ll see opportunities and use-cases you couldn’t have envisaged at the start — that’s normal, and it’s a good thing.
So we spec the current step, sharply. The next step gets its own spec when its turn comes.
No surprises later. No “well, that’s not what I asked for”.
The process is split into milestones. Each milestone is invoiced when it’s delivered — not before.
Result: a written agreement of exactly what you’re getting in this step — and payment tied to delivery against it.
Phase 3
Data Foundation
Scattered data is a liability.
Time and money are wasted as the same data gets entered more than once.
Input mistakes get made. Some get caught. The rest sit in the data, poisoning every report that touches them.
Versions drift. Reports disagree.
Hours get spent reconciling spreadsheets that differ.
Decisions get made on whichever copy was opened first.
None of it is anyone’s fault — it is what happens when systems grow organically.
A single source of truth
A single source of truth means:
- data entered once
- one consistent version, used by everyone
- the current data, available to whoever needs it (subject to permissions)
- reports and analysis on any aspect of the data — on demand or automated
Without it, even the best automation or AI is deeply flawed.
We convert what you have today — spreadsheets, legacy databases, mixed-format documents — into that foundation: clean integration points, instrumentation for measurement. This is the unsexy phase that makes everything that follows work.
Result: one trustworthy version of your data, available to the right people, ready for everything that comes next.
Phase 4
Working Prototype
The spec from Phase 2 is the contract. Phase 4 is us building the smallest working version that proves the spec.
Rough around the edges, yes. Not the polished production system — that comes next. But running on real data, in your environment, doing what the spec said it would. The point is for you to see it working before we invest in the full build.
Once you’re satisfied it does what we agreed, you sign that milestone off. Then we move to the proper implementation.
Result: a working version of the solution, running on your real data, ready for you to sign off before we build it properly.
Phase 5
Full Implementation
With the prototype signed off, we build the real thing. Production-grade, properly engineered, integrated with the rest of your operation. The rough edges from the prototype get smoothed; the corners that were good enough for sign-off get done properly.
What the system does is settled by now — that’s what the spec and the prototype were for. Phase 5 is the final milestone: execution against an agreed brief, with no scope surprises.
Result: the solution in production, doing the job day in, day out.
Phase 6
Long-term Solutions
A system that is not measured is not improving. We instrument what we build, run ongoing evaluation, and stay engaged for the long term — through model changes, supplier changes, staff changes, and business changes.
The whole point of building something is that it keeps working.
Result: a system that keeps working as the world around it changes — and us beside you, making sure it does.
LLM-agnostic, modular architecture
We build in modules. Each module does one thing. The interfaces are clean. Nothing is locked to one model or one vendor.
- Swap any LLM. The model that is best today will not be the best in twelve months. Our architecture lets you change models without rebuilding.
- Swap any integration. If your CRM changes, the connector changes. The rest of the system continues.
- Survive vendor change. If a supplier disappears or changes terms, the affected component swaps out — the system keeps working.
- Swap any sub-system. As you learn what actually works, each module is replaceable on its own — the system evolves one piece at a time, not in a big-bang rebuild.
This is what we mean by long-term. Not a marketing claim. An architectural choice.
Automation first. AI only where it earns its place.
We use deterministic automation wherever the rules are stable. AI is reserved for tasks that genuinely require judgment, exception handling, or context.
Every AI module sits inside an evaluation regime — we measure what it does, we know when it drifts, and a human is in the loop where it matters.
Want to talk about your first bottleneck?
A short call. No deck, no pitch.