AI & Workflow Automation
Workflow automation on n8n, Make.com and the tools you already run
The repetitive work running itself, end to end. With the one step that carries a consequence still going to a person.
We are proud to work with these companies
Fit
Who this is for.
The same handful of steps happen by hand every day, and they are the same steps every time.
Work sits waiting because it has to pass between systems that do not talk to each other.
Something gets missed occasionally, and when it does it is always at the same point.
Scope
What arrives.
The automations
- Processes built end to end, from whatever triggers them to the record at the far side
- Built on n8n, Make.com and GoHighLevel — or inside the tools you already pay for
- Custom code where the platform stops short of what the process actually needs
- AI document checks: legibility, expiry, and whether it matches the record
- Connected to what you already run — sheets, CRM, email, WhatsApp, your own database
Around it
- The process mapped on paper first, exceptions included, before anything is built
- The handover named — which decisions stop for a person, and what they see
- Errors that surface to a person instead of failing quietly
- A log of what ran, when, and what it decided
- Written instructions for keeping it running, handed over with the build
Standard
7 things ship as standard.
The difference between an automation that survives its first year and one that quietly stops is almost entirely in this list.
True of every build
- Built in your accounts, on your subscriptions, with credentials you can revoke
- The map of the process is written down and yours, not held in somebody's head
- Every step that carries a consequence is routed to a person before it acts
- What the automation decided is logged, so a wrong answer can be traced rather than argued about
- Nothing is automated before it has been written down and agreed
- If a job fails, a person is told — an automation that stops quietly can go unnoticed for weeks
- Handed over with instructions, whether or not we stay on to run it
Add-ons
And what you can bolt on.
None of these is assumed, and none is padding. Each is quoted on its own, so you can see exactly what it adds and take the ones you want.
Going further
- The CRM itself set up and configured, not just connected
- WhatsApp and email sequences triggered by what the process finds
- A portal where the person approving can see what is waiting for them
- Reporting that reads the log rather than a person re-counting it
- Moving an automation off a platform that has stopped suiting you
Working together
How it runs.
The process, written down
What actually happens now, mapped before anything is built — including the exceptions nobody documented, which is where an automation built from the tidy version would have broken. You keep the map whether or not the build follows.
Built in stages
The main path first, then the branches. Each stage runs on real work before the next is added, so a fault shows up in one step rather than somewhere in eleven.
The handover, agreed
Which decisions stop for a person, what that person sees when it reaches them, and what happens to the job while it waits. Agreed before it goes live rather than discovered after.
Yours to run, or ours
It is handed over in your accounts with written instructions for keeping it going. Where you would rather not hold that, it runs as a retainer and keeping it working is ours — including when a third party changes something underneath it.
What we need from you
- Access to the systems the process touches
- Someone who knows what actually happens, including the exceptions nobody wrote down
- A straight answer on which steps carry a consequence if they go wrong
- Permission to change how the work is done, not only how it is recorded
Where it stops
The step that waits for a person.
Six steps, and five of them resolve the moment the job reaches them. One does not. Everything before it is a rule and can be written down; that one is a judgement, and a rule that guesses at a judgement is how automation earns its bad name.
- It arrivesA form, an email, an order, a file
- Details gatheredPulled from the systems that already hold them
- Checks runComplete, legible, in date, matching the record
- A person decidesThe one call that carries a consequence
- The work happensIssued, filed, scheduled, replied to
- Written downWho did what, when, and why — kept
Step 4 · A person decidesEverything above this is a rule. This is a judgement, and a rule that guesses at a judgement is how automation earns its bad name.
Cost
What it depends on.
- How many steps, across how many systems
- Two steps between two tools is a small piece of work. Eleven stages tracked across five connected workflows is a build, and it is priced like one.
- Whether the process is written down
- If it lives in one person's head, mapping it is the first real piece of work. Skipping that is where most of the cost of a bad automation gets paid, late.
- How much judgement is in it
- Steps that follow a rule are quick. Steps that need a person are not automated at all — they are designed, which takes longer and is the reason the finished thing can be trusted.
- Project, or an ongoing arrangement
- Built, handed over and closed is one quote. Kept running is another: third-party tools change without asking, and somebody has to be on the hook when they do.
Every project is quoted against its own scope. Quoted either way — as a project that is built, handed over and closed, or as a retainer where keeping it running is ours. Which suits depends on whether you would rather own the maintenance or hand it over with the build. Tell us what you are trying to do and you will get a number, not a range that moves later. Start that conversation.
Proof
Eleven stages, five workflows, one person.
A compliance process built for TradieGet, a delivery company: a driver applies, uploads their licence and insurance, and comes out the far side cleared to be dispatched. Drawn as it was built rather than captured from the tools it runs on — the interesting part is not what the canvas looks like, it is where the automation stops.
- W1
Intake and portal access
Runs whenThe driver submits the application form
- 01Application received
- 02Application validEmail and phone checked, then the first portal door unlocks and the upload link goes out
- W2
Documents and the AI checks
Runs whenThe driver uploads licence, insurance and the rest
- 03Documents uploaded
- 04Documents reviewA secure webhook hands them to n8n, which checks legibility and expiry
- 05Application rejectedThe branch that exists because not every application should proceed
- W3
Approval
Runs whenThe AI checks come back clean
- 06Documents approved
- A person at TradieGet reviews and approvesThe automation has read the documents and says they are valid. Whether this driver is cleared to drive is not a thing a rule should decide, so it stops here and waits.
- 07Contract providedSet by hand, and that is what releases the signable agreement to the driver
- W4
Contract and training unlock
Runs whenThe agreement comes back signed
- 08Contract signedThe second portal door unlocks
- 09Compliance training links sent
- W5
Training and activation
Runs whenThe driver finishes the training module
- 10Training completed
- 11Available for dispatch
Eleven stages across five workflows, and one of them is a person. The documents go to an API for the legibility and expiry checks — they are not used to train anything, which for a compliance process is the part worth knowing.
Case studies using AI & Workflow Automation
Questions
The ones people actually ask.
What happens when a tool we depend on changes?
Third-party tools change without asking, and an automation that was fine on Friday can stop on Monday. On a retainer that is ours to fix, and it is the main reason retainers exist on this service. On a project handover it is yours — which is why the instructions cover what to look at first when something stops, rather than leaving you to work it out under pressure.
Will this replace somebody's job?
What goes is usually the part of a job nobody wanted — the copying between systems, the chasing, the checking of things that could be checked by a rule. The decisions stay, and they stay with people, because that is the only version of this that works. If a process is mostly judgement there is less here to automate than you would expect, and the map shows that before you have spent anything on building it.
Do we own it?
Yes. It is built in your accounts, on your subscriptions, with credentials you can revoke. If we stopped working together tomorrow the automation carries on running.
What if the automation gets something wrong?
It is logged, so what it decided and why can be read back rather than reconstructed. Anything carrying a consequence goes to a person before it acts, which is how these are designed rather than a safeguard bolted on afterwards. And errors are made loud on purpose — a failure nobody notices is worse than no automation at all.
Can you work inside the tools we already pay for?
Usually, and it is normally the cheaper answer. n8n, Make.com and GoHighLevel are what we reach for when there is nothing in place, but if you already run something that can do the job, building inside it beats adding another subscription to the stack.
Can AI actually be trusted to check a document?
For legibility, expiry dates and whether it matches the record it already holds — yes, and it is faster and more consistent than a person doing it forty times a day. For whether to accept it, no, and we do not ask it to. It reports what it found; a person decides what that means.
Where this usually goes next
Next step
Tell us what your team does twice a day
One process, described in a couple of sentences, is enough for us to say whether it is worth automating and roughly what it would take. The map comes first either way, and it is worth having even if you never build the thing.