The automation audit playbook

A People team I worked with in transit was a fortnight from renewing a licence that cost roughly £40k a year, on a tool three people used and none of them trusted. An automation audit is what stops that renewal going through on autopilot. It is a structured read of where work in your function actually hides, repeats, and breaks, costed in pounds, so you build against the expensive problems instead of the easy ones. We ran the audit, found the one workflow the tool was really there for, and two internal builders rebuilt it. The £40k licence was retired.

Most automation efforts do not end that well. The pattern is so consistent it is almost a law. A team gets excited about a new tool, picks the most visible workflow, builds something, demos it once, and quietly drops it three months later because the maintenance cost outweighed the saving. The cause is nearly always the same. They started with the wrong question.

Start with the problem, not the tool

The wrong question is what can I automate? It optimises for the wrong thing. You end up automating low-value work because it is easy, while the painful, costly workflows stay manual, and you generate technical debt that a future version of you inherits.

The right question is what problem am I trying to solve? Start by mapping the pain. Where is the team losing time, money, or quality, and where are you carrying business risk? For each candidate, work out the true cost. Then design the smallest thing that addresses the highest-impact problem. That reorders everything, because the expensive problem is rarely the easy one.

The shape of the automation audit

An automation audit is not a workshop and a wishlist. It is a sequence, and it runs in about three weeks alongside the day job. Each stage feeds the next, and skipping one is where teams lose the plot. Here is the whole arc before we go into the parts.

Map the pain in pounds

Spend a week observing the team's real work. Not the work as documented, the work as it happens: the copy-paste between two systems, the chase email, the spreadsheet that gets rebuilt every Friday because nobody trusts the last version.

For each workflow, capture five costs. Direct time: hours a week, times people involved, times a loaded hourly rate. Error cost: how often it goes wrong, times the downstream cost per mistake. Opportunity cost: what strategic work is not happening because this consumes the week. Scaling cost: what this does when the company doubles. Risk cost: the worst case if it fails, in compliance, reputation, or legal terms.

None of this needs to be precise. The point is to make the cost visible. Take a joiner-setup workflow: three hours a week, four people touching it, a loaded rate around £45 an hour. That is roughly £28k a year in direct time alone, before a single new-starter error. Once it reads as £28k rather than "a bit of admin", it stops being a nice-to-have and starts being a business problem with a number attached. Keep it to a simple table per workflow: name, rough annual cost, and the person who owns the pain. That last column matters more than it looks, because a workflow with no named owner rarely gets fixed and never gets maintained.

Score every candidate with 6T

Once you have a costed list, you need a fast way to sort the strong candidates from the ones that will waste a build. Score each workflow 1 to 5 on six dimensions.

A workflow scoring 4 or 5 across most dimensions is a strong candidate. One scoring 1 or 2 either does not need automating or will not benefit. In practice, one or two dimensions carry most decisions and the rest just confirm the call.

The scores also tell you what kind of solution fits, which stops you buying an agent for a job that wanted a pipe. High touchpoints and low transparency points to a workflow tool first, something like n8n, which is SOC 2 and ISO 27001 compliant, self-hostable, and runs around £20 per builder seat a month. High tedium plus predictable triggers plus low touchpoints is a clean automation with no model in the loop at all. High touchpoints with real ambiguity in the work needs an AI-assisted workflow with a human reviewing the calls. Match the score to the shape and you avoid the most expensive mistake in this whole exercise, which is building the wrong class of thing. The automation patterns that pay off go deeper on which shape fits which score.

Spot the Swiss cheese before you automate

Borrow this from accident analysis. Most processes have small holes: a missed check, an ambiguous handoff, an undocumented exception. Most of the time the holes do not line up and the work gets through. Occasionally they do line up, and something serious slips out the far side. A person doing the work catches most of these by instinct. An automation catches only what you told it to.

So the audit has to surface the Swiss cheese before the automation hides it. Automate a workflow without addressing the holes and the failures do not stop, they go quiet. They become less visible, not less frequent, and when they surface they are far harder to diagnose because everyone assumes the machine had it. Run every candidate through this before you commit.

The discipline is simple to say and unglamorous to do: document the exceptions before you automate the rule.

Cost the saving honestly

For each surviving candidate, write a one-line business case. Automating this workflow saves X hours a week across N people at a £Y loaded rate, for an annual saving of £Z, against a build cost of £A in time and tooling, paying back in B months, with this named risk if it fails.

Then apply two honesty tests, because this is where most business cases quietly fall apart. The first is maintenance. Add 30 percent of the build cost as ongoing annual maintenance. Automations drift, triggers change, systems update their APIs, and someone has to own the drift. Teams forget this line and watch the ROI evaporate a quarter later. The second is the difference between hard and soft savings. Time saved is only real if the time goes somewhere valuable. If saving Sarah three hours a week means Sarah spends three more hours in Slack, the saving is fiction dressed as a number. A case that survives both tests is worth pursuing. One that only survives on paper is the reason teams stop trusting automation numbers at all, which is a worse outcome than never having built it. If you want the fuller version of this, measuring AI value in People Ops walks through the board-facing side.

Prioritise, then sequence

Now you have costed, scored, de-risked candidates. Rank them on a two by two: business impact on one axis, implementation complexity on the other.

Top-left ships first. Top-right is the strategic backlog: built deliberately, with a sponsor and milestones, never squeezed in between other work. Bottom-left is filler, useful only when a champion wants a low-stakes build to learn on. Bottom-right is the trap most teams fall into, building the interesting thing rather than the valuable one. As a rough split, run about 70 percent of your automation effort in the top-left and 30 percent in the top-right. Anything else means the audit was skipped or ignored.

Then turn the ranked list into a 90-day roadmap you keep. Days 0 to 30: two top-left automations shipped and their ROI measured against the number you wrote down. Days 30 to 60: the first top-right build scoped, with sponsor and budget agreed. Days 60 to 90: a second cohort of quick wins, and the first strategic build going live. The cadence matters more than the volume. Two automations a month, sustained for a year, reshapes a function. Twelve in month one and nothing after reshapes nothing. This is also where the workflow assessment framework hands over to delivery, and where a two-week Grain Audit does the whole read on one process for you if you would rather not run it alone.

One last thing the roadmap should force: audit your existing automations as ruthlessly as your new candidates. The dead script nobody owns and the tool three people distrust are costing you now, in licence fees and silent failures, while you plan the next build. The audit is not a one-time act of tidying before you start. It is the discipline that keeps a function honest about what its automation is actually worth, which is why it sits inside the broader AI workspace for People Ops rather than off to the side as a procurement step.