Implementation Sprint
2–4 weeks typical start
- Idea to production
- End-to-end delivery of one use case
week 1week 7week 12
How to hire us
Idea to production · built for real users
The model is
the easy part.
Production is data, integrations, permissions, monitoring and an owner. We build all of it, inside your systems.
One system travels through seven gates on its way to production: demo, data, integrations, guardrails, evals, monitoring, production.
01 · Why demos die
The unglamorous
80 percent.
AI projects rarely fail on the model. They fail on everything around it.
Why demos die
A demo runs on twelve hand-picked examples, a laptop and someone who knows which questions to ask. Production runs on thousands of real inputs, in systems with permissions, on a Tuesday when the person who built it is on holiday.
What production actually needs
Real data flowing in, including the ugly cases. Integrations into the systems where the work happens. Guardrails and fallbacks for when the model is wrong or unsure. Evals on every change. Monitoring that someone looks at, and an owner who gets the call when it breaks. Legal and security involved at the start, not at launch.
How we work
We start with constraints: data, systems, rules, people. Then architecture and model choice, tested against your data rather than benchmarks. We build in sprints inside your stack, with your engineers where possible, and stay for the first weeks after launch until the system is boring.
Boring is the goal.
- Typical start
- Implementation Sprint, 2–4 weeks
- After launch
- Launch & Stabilize, 30 days
- You keep
- Code, evals, dashboards, runbooks
02 · The gap
Demo versus
production.
The same model on both sides. Everything else is different, and everything else is the work.
| Aspect | Production | |
|---|---|---|
| Inputs | Twelve hand-picked examples | Thousands of real inputs, including the ugly ones |
| Runs on | A laptop | Your systems, with their permissions |
| Operated by | The person who built it | Your team, on a Tuesday, while the builder is on holiday |
| When the model is wrong | Someone reruns it | Guardrails, fallbacks, and a person for consequential steps |
| Quality | Looks good in the meeting | Evals on every change, with a gate |
| When it breaks | Nobody notices | Monitoring, alerts and an owner |
| Legal & security | Show up at launch | Involved from the start |
| Cost | Nobody asked | Cost per transaction, visible, with alerts |
- DataIt died on real data.
It worked in the demo, then fell over on the inputs production actually gets.
- OwnershipNobody owns it.
No owner, no monitoring, no feedback loop, so nobody knows it is broken.
- LegalBlocked at the finish.
Legal and security see it for the first time at launch, and stop it.
- CostThe bill came first.
Usage was never measured. Costs exploded before value showed up.
- IntegrationThe model works, the plumbing doesn’t.
Good answers, poor integrations. The work still happens by hand.
- SafetyUnguarded hallucinations.
Wrong answers reach users, with no guardrail and no fallback.
03 · Process
Five steps
to real users.
Constraints first, code second. Safety before launch, not after the first incident.
- 01Discovery & constraints
Data, systems, rules and people. What exists, who owns it, what must not happen.
- Output
- Technical assessment and a constraint map
- We need
- Access to systems and people
- 02Architecture & models
System design and model choice, tested against your data rather than benchmarks.
- Output
- System design and model recommendations
- We need
- An architecture review
- 03Build & integration
Sprints inside your stack, wired into the systems where the work happens.
- Output
- Working system and integration code
- We need
- Test data and feedback
- 04Safety & controls
Guardrails, fallbacks and an evaluation suite that gates every change.
- Output
- Guardrails and an evaluation suite
- We need
- Security sign-off
- 05Launch & iteration
Go-live with monitoring, then iteration until the system is boring.
- Output
- Monitoring dashboards and an iteration plan
- We need
- An owner
04 · Outcomes & formats
What you have
at the end.
Three things, whichever format you choose. The format decides how much of the knowledge stays inside your team.
- A system in production.
Live users, real transactions, measurable impact.
- Clear ownership.
Your team can debug and iterate without us.
- Controlled costs.
Cost per transaction, visible, with alerting.
Build With Your Team
4–8 weeks
- Embedded with your engineers
- Learning and knowledge transfer
week 1week 7week 12
Launch & Stabilize
first 30 days after go-live
- Optimisation and support
- Until it is boring
week 1go-liveweek 12
Solid: the minimum. Hatched: the range, depending on scope. The strips are illustrative.
05 · Self-check
How far are you
from production?
Four questions that decide what the first sprint looks like.
result0 / 4 answered
- Scope first.
The idea needs a sharper problem and a data check before code. A strategy sprint saves you a failed build.
- Implementation Sprint.
Two to four weeks from pilot to production for one use case.
- Build With Your Team.
Four to eight weeks embedded with your engineers, so the knowledge stays.
01What exists today?
Where you start decides the first sprint.
02Is the data accessible?
Most delays are data access, not modelling.
03Are security and legal involved?
Late involvement is the most common launch blocker.
04Do you have engineers to build with?
Building together keeps the knowledge in-house.
06 · Fit
Build it if.
Wait if.
Implementation starts with a use case worth building. Without one, other work comes first.
A good fit
- You have a validated use case that needs a proper production build.
- Your product team lacks production AI experience.
- An earlier AI demo never made it to production.
- It has to work with your existing systems.
- Security and compliance matter.
- You want to ship in weeks.
Look elsewhere
- You need a demo to impress investors. We build for real users.
- You want to explore AI without a specific use case. Start with a Workshop.
- A live system needs fixing first. That is Consulting.
07 · Questions
Before
we build.
Which models do you use?
Whatever fits your constraints: hosted models through EU endpoints, open models in your own cloud, or a mix. We choose per task, test against your eval set rather than benchmarks, and keep the model swappable.
Does our data leave the company?
Only where your contract and policy allow it. We design for EU processing by default, and for tenant-internal setups where the data demands it.
Do you build with our engineers?
Where possible, yes. Build With Your Team puts us inside your team for four to eight weeks, so the knowledge stays when we leave.
What happens after go-live?
Launch & Stabilize covers the first 30 days, until the system is boring. Then your team owns it: code, evals, dashboards and runbooks.
Can you build a demo for our investors?
No. We build systems for real users. A demo built to impress is exactly the thing that dies in production.
We don’t have a use case yet.
Start with a Workshop or AI Strategy. Implementation starts with a validated use case.
08 · How to hire us
Three ways in.
Pick by where you are: deciding, stuck with a live system, or ready to build.
01 / 03Workshop02 / 03Consulting
Half or full day. Ends with decisions, owners and next steps.
When you need to decide
Retainer, fix-it sprints, embedded help. For systems that are live and hurting.
When a live system hurts
03 / 03you are hereImplementation
Two- to eight-week builds. From validated idea to real users.
When you are ready to build
What’s stuck between demo and production?
Make it
boring.
Tell us what exists today: an idea, a demo, a pilot with real users. We come back with the first sprint.