The work nobody should be doing by hand.
Lead capture, quoting, follow-up, reporting — built once, owned by you, running whether anyone is watching or not.
Practice · Automations
Everything the Automations practice includes.
Lead capture & routing
Every enquiry lands in one place, tagged and assigned before anyone opens a laptop.
CRM & pipeline plumbing
Records that update themselves, and a pipeline that reflects reality without being maintained.
Quoting & follow-up
Quotes out the same day. Follow-up that happens whether anyone remembers or not.
Reporting
The numbers assembled on schedule, in one place, without the night-before spreadsheet ritual.
Internal tooling
The small, specific tool your team keeps asking for — built into the systems you own.
Integrations
The systems you already pay for, finally speaking to each other.
One practice.
Start the conversation
One standard.
One team.
Find it. Build it. Hand it over.
- 01 · Find it
The process as it runs, not as documented.
We watch a real week with the people doing the work. The manual steps that matter are rarely the ones in the process document — they are the workarounds, the re-typing, the message someone sends to remind someone else. Every step gets written down, timed, and counted, and then we pick the ones actually worth removing.
- A real week observed, not a workshop reconstruction
- Every step timed and counted
- Failure modes recorded before anything is built
- The steps worth keeping human, identified and left alone
- 02 · Build it
On your systems, under your credentials.
Automations are built into the tools you already pay for, running on accounts you own. We design the failure paths before the happy path — what happens when an API is down, a record arrives malformed, a person is on leave — because an automation that fails quietly is worse than the manual step it replaced.
- Built on the systems you already own
- Credentials held in your accounts, never ours
- Failure paths designed before the happy path ships
- Alerts tuned so a notification always means something
- Run alongside the manual process until it is proven
- Nothing goes live on trust alone
- 03 · Hand it over
Documented, so it is never a black box.
Everything ships with a plain-language description of what it does, what it touches, and how to switch it off. If we vanished tomorrow, someone competent could pick it up from the documentation alone. That is the test we hold it to — not because we plan to vanish, but because a system you cannot inspect is not really yours.
- Plain-language documentation, not a config dump
- A written map of every system it touches
- How to pause it, change it, and switch it off
- Reviewed on a cadence as the business changes
From manual step to unsupervised.
- 01 · Week 1
Watch it happen.
We sit with the process as it is actually done, not as the process document claims. The gap between those two is usually where the cost is hiding, and it is never in the diagram.
- 02 · Build
One step at a time.
The highest-cost manual step goes first, on its own, so it can be judged on its own. Failure paths are designed here rather than discovered in production later.
- 03 · Parallel run
Prove it, before it is trusted.
It runs alongside the manual process until the two agree. Nothing is switched off on the strength of a demo — the switch-off is a decision you make once the evidence is in.
- 04 · Handover
Keys, not dependency.
Documented, running in your accounts, on your credentials. You can change it, pause it, or take it to someone else. We would rather be kept than needed.
An automation nobody trusts gets switched off within a month. So the rhythm is built around earning that trust, not around shipping quickly.
How we work this practice.
Watch the process. Remove the manual step. Prove it runs unsupervised. Hand over the keys.
Automation isn’t a product we sell you. It’s the manual work we find inside your business and remove. We watch the process as it actually runs — not as the documentation claims it does — and take out the steps a person should never have been doing.
Then we prove it. It runs unsupervised, it raises its hand when it genuinely needs a person, and it is documented and handed over with the keys. Built once, owned by you, still running long after the engagement.
- The manual step found before anything is built
- Mapped against the process as it runs, not as documented
- Built on the systems you already own
- Credentials held in your accounts, never ours
- Failure paths designed, not discovered in production
- It speaks up when it needs a person — and stays quiet when it doesn’t
- Documented, so it is never a black box
- Handed over with the keys, not held hostage
The lines we hold.
We don’t automate a broken process.
Automating a bad process produces bad outcomes faster. If the process is the problem we say so before quoting the build.
We don’t hold the keys.
It runs on your accounts, under your credentials, documented well enough for someone else to take over. Leaving should be easy — that is what makes staying a choice.
We don’t lead with AI.
Some of it uses models where they genuinely earn their place. Most of it is plumbing. We build what works, not what demonstrates well.
We don’t automate judgement.
The steps where a person should decide stay with the person. Removing the typing is the win; removing the thinking is the trap.
Straight answers.
Sometimes, where a model genuinely earns its place. Mostly it is plumbing — the unglamorous work of getting systems to talk to each other reliably.
It tells us, and it tells you. Failure paths are designed before launch rather than discovered in production. Nothing fails quietly.
You do — that is the entire point. It runs on your accounts, under your credentials, documented well enough for someone else to pick up. Built once, and it’s yours.