Services · Implementation
Production systems in your own infrastructure.
I scope, build, test and launch AI systems inside your own cloud or on-premises environment. Then I train your people on their own work and hand over everything needed to run it.
At a glance
- milestones and acceptance checks
- Written scope
- or your on-premises environment
- Your cloud
- in writing, before production
- Your approval
- code, documentation and training
- Handover
- Written scope, fixed quote
- Least-privilege access
- Your written approval before production
- Logged, versioned, reversible
- Training on your own work
- Documented for your team
- Onsite when it helps
Scope
Every build starts with a written scope.
Implementation can start straight away when the work is already defined. I run a short scoping phase first to confirm the requirements, the integration points and the success measures before the build begins.
I watch the work first, on a screen share or on your floor, following the task from start to finish. Then I write the scope: the work in order, milestones and acceptance checks for each part, and a fixed quote for each part before it starts. After that, we change the scope only through a written change order signed by both of us.
In the written scope
- Requirements and integration points
- The success measure
- Milestones and acceptance checks
- A fixed quote for each part
Access and security
How I handle access to your systems.
Each deployment is designed to pass security and compliance review, with audit trails and a conservative operating posture.
Least privilege
I access your systems with the least privilege required, and only through access you approve. The access is removed at the end.
Written approval before production
I don't write directly to your production databases or move anything into production without your written approval.
Drafts until approved
Records the AI creates are drafts, and they're posted only after someone on your team approves them.
Logged and reversible
Every action is logged, access is scoped by role, and prompts, models and tools are versioned so any change can be rolled back.
How a build goes live
From written scope to go-live.
You approve at each milestone, and I don't launch anything without your decision.
- 01
Scope
I watch the work, confirm the requirements and integration points, and write milestones and acceptance checks into the scope.
A fixed quote for each part
- 02
Build and test
I build inside your environment and test against the agreed examples, including the awkward ones, with the people who will use it.
A working version you review
- 03
Go live
With your written approval, I move it into production. Records the AI creates are drafts until your team approves them, and any record can be reversed.
Live, logged and reversible
- 04
Train and hand over
I train the people who use it on their own tasks, then hand over the code, the documentation and the runbook.
Your team running it
The record
How I build, from one real project.
- recorded changes across seventeen codebases
- 1,973
- unit tests, plus 10 browser suites in real Chromium
- 2,177
- written requirements, 150 enforced by tests
- 166
- production deploys, each recorded with a rollback id
- 89
My public case study is a tax resolution platform, built between February and September 2026. I directed the work with Claude as the engineering partner. Of the 1,973 recorded changes, 1,214 were written by Claude sessions under my direction and 158 more name Claude as co-author.
Every feature was checked where it runs. Four fresh reviewers went after it and found 19 real defects, each fixed and pinned with a test. Each production deploy records where it came from, so going back is one command, and a rollback never touches the data. The AI tools run behind a server-side proxy, so no key ever reaches a browser.
Training and handover
Training on your own work, and a full handover.
I train the people who use it on their own tasks and their own tools, so it gets used the next morning. When the working sessions end, your team can operate what was built, and the prompts, the runbook and the failure modes are written down.
Everything is documented so your own team or another firm can run it. Every handover includes the source code and configuration in your repositories, the architecture and operating documentation, and training for the people who run and use the system.
Handed over on the case study
- A numbered requirements register tied to tests
- An API contract written for a Django backend
- An embed guide for the portal teams
- An onboarding brief for the client's developers
- A go-live guide and a downloadable portal bundle
- A design-token system with rebuild instructions
- A written operating standard with a 60-check audit harness
- A restore point of the original codebases
Delivery
Four ways to get the work done.
You can pick a different path for each piece of work, and change it as you go.
Added capacity · Start now
Done for you
I build, test and launch each system, then hand it to your team. Best for the fastest results without pulling people off their work.
Your current team · Build skills first
Train your current team
I train your people to build and run each tool, using your own work. Best for keeping the know-how inside the company.
Your current team · Start now
Do it yourself
Your team builds it from the written scope and my recommendations, at its own pace. Best for teams with technical staff and time to take it on.
Added capacity · Build skills first
Train new hires
I train the people you hire for these roles to build and run the tools from the start. Best for adding capacity without stretching the team you have.
Who does the work
I lead every engagement, onsite when it helps.
I scope, design and lead every engagement personally. Specialists support defined workstreams under my direction.
Most of the work is done remotely. When seeing the work in person helps, I come onsite, configure the systems on your hardware, and don't leave until your team can run it without me.
Onsite work includes
- Onsite system setup and configuration
- Hands-on team training, on your tools and your workflows
- Same-day support during implementation
Questions
Questions about implementation.
Can we start with implementation?
Yes, when the work is already defined. I run a short scoping phase first to confirm the requirements, integration points and success measures before the build begins.
Where does the system run?
Inside your own cloud or on-premises environment, using frontier models from established providers under enterprise data terms. Private models, on-prem inference, PII scrubbing and role-scoped tool access are standard patterns for me.
How long does implementation take?
Timing depends on access, integrations, review and the scope. I set the milestones and acceptance checks in the written scope before the build starts.
Does a build make us compliant?
No, not by itself. I can scope the technical controls with your legal, compliance and security reviewers, and any approval they require comes before production use.
Who pays for the AI models and software?
You do, directly. Model and software subscriptions are billed to you by the vendor, so you can see them and cancel them.
What does implementation cost?
It's quoted in writing after a first conversation, with a fixed quote for each part before it starts. On the pricing page I explain what makes a project cost more or less.
Next step
Before the build, and after it.
Prototypes
One workflow built on your own data, in your own accounts, in about 30 days, ending in a go, adjust or stop decision.
How prototypes workOngoing support
An optional monthly retainer after launch, quoted per client, with no automatic renewal.
How support worksOwnership
What you own when the work is done, under the services agreement, and what I keep.
What you own
The first step
Tell me what needs to run, and where.
In 30 minutes I'll ask about the systems involved, the access and who approves the work, and tell you what I'd put in the written scope.

