How we work
A clear starting point, and a system your team can actually useYou bring the knowledge of your business; we bring the engineering.
These four stages are how Dedicated engineering and AI transformation run. Unlimited development and the AI security audit work differently — we explain how on their own pages.
Start with the work
We look at what your team does today, where time is lost and what a useful improvement would look like.
- You bring
- Real examples, the people involved and access to the relevant information.
- We work towards
- A clear problem, a practical first scope and a way to judge the result.
- The decision together
- Agree what is worth building.
What you walk away with at each stageNamed upfront, so you know what you're paying for before a stage begins.
- Understand
A discovery report: the scope, a timeline and the budget's limits.
The risks, and a map of the systems involved.
How the result will be measured.
- Design
The technical design, with its security and compliance approach.
A plan for checking the system against your own examples.
A pilot plan, and what it has to hit to pass.
- Build
A working pilot, and what its checks showed.
A clean go or no-go decision, plus a plan to scale if it's a yes.
Production code, with its tests and runbooks.
- Improve
Monitoring, alerts and a clear playbook for when something breaks.
Training for your team, and the documentation.
Regular reviews of what the system is actually achieving.
How we run our own systemsThe same method, practised on the Company Twin, the product we build and run in production.
- Understand
Before building the Twin for an organisation, we agree its definitions with the people who use them: what counts as revenue, a completed project, an overdue commitment.
- Design
We decide what the model can do and what deterministic code has to do. In the Twin, the model plans and the graph engine does the arithmetic.
- Build
Answers are checked against agreed test sets that run without a model, so a change is measured before it ships, not after.
- Improve
Every release takes one path, from checks to staging to production on the same build, with every server monitored as it rolls out.
What live systems have taught usThe reasons the stages are shaped as they are.
- The people doing the job know what the documents miss
- We spend time with them before we propose anything.
- The data is never quite what was promised
- We check what's really there, and how clean it is, before we say what can be built.
- Checking never finishes
- A system that's right at launch drifts over time. We plan for that — and for a person's review — from day one.
- Owning it matters more than a handover
- We build so your team can change and extend the system long after launch.
Clear responsibilities from day one
Who owns what, so nothing falls between the two teams.
Your knowledge of the business
- The people who understand the work and its exceptions.
- Examples of a good result and what needs a person’s judgement.
- Decisions on access, priorities and readiness for use.
Our responsibility for the engineering
- A practical design and clear choices about what to build.
- Connections, software and checks against agreed examples.
- Documentation, handover and support within the agreed scope.
Questions
- Can we stop after a stage?
- Yes. Each stage ends in a decision we make together, and stopping is one of the answers.
- When do we agree the cost?
- Before each stage begins: its scope, the approach and the cost.
- Who does the work?
- The senior engineers who scoped it, from the first conversation to the running system.
- Where does the system run?
- In your own cloud account on AWS, Microsoft Azure or Google Cloud, under your access controls, or hosted and run by us.
Start with something worth improving
Tell us what's slowing your team down and what you'd like to change.