Bad Automation Scales the Problem: Lessons from Failed Projects
Automation makes a process faster, including its mistakes. Three illustrative stories show how automation projects go wrong, and the checks that prevent it.

Automation does exactly what it is told, as many times as it is told, without getting tired or asking questions. That is its strength, and it is also why so many automation failures trace back to a flawed process that was automated as it stood.
The three stories below are illustrative composites, not accounts of specific companies. Each one is built from common patterns in automation projects, and each ends with the check that would have prevented it.
Story one: the invoice robot that paid too quickly
A mid-sized distributor decides to automate supplier invoice processing. Invoices arrive by email, a tool reads them, matches them to purchase orders and schedules payment. The finance team is delighted at first. Processing time drops from days to hours.
Three months later, the auditor finds a pattern of duplicate payments. Some suppliers sent the same invoice twice, once by email and once on paper with the delivery. The old manual process caught most of these because an experienced clerk recognised the invoices. The automation had no duplicate check, because nobody had written down that the clerk was doing one. The rule lived in her head.
The lesson: manual processes often contain invisible controls. Before automating, observe the work closely and list every check people perform, including the ones they do by instinct.
Story two: the sales reminders nobody trusted
A services company sets up automatic follow-up reminders for its sales team in its CRM (customer relationship management) system. Every lead without activity for seven days triggers an email to the rep and a copy to the sales manager. It sounds sensible.
The problem is that the CRM data is incomplete. Reps log some calls but not others, and many leads are duplicates entered by different people. Within two weeks, each rep receives dozens of reminders a day, most of them wrong. They create a mail rule to file the reminders unread. The sales manager stops reading the copies. The automation still runs every day, generating noise that everyone has learnt to ignore, and the leads that genuinely need attention are buried in it.
The lesson: automation built on unreliable data destroys trust in the data and in the automation at the same time. Clean the data and agree the behaviour first. A reminder system works only when people already record activity consistently.
Story three: the approval workflow that copied the chaos
A healthcare group wants faster purchase approvals and asks a developer to automate the existing process exactly as it runs. The process has seven approval steps because, over the years, each new manager added a signature without removing any. Some approvers check budget, some check specifications, and two check nothing in particular.
The new workflow faithfully reproduces all seven steps, now with automatic notifications. Approvals are slightly faster, but each request still passes through seven inboxes, and the group has spent its budget making an unnecessary process run more smoothly. Worse, the workflow now makes the seven steps look official and permanent.
The lesson: redesign before you automate. Ask what each step is for, remove the ones that add nothing, and only then decide what deserves a system.
Checks to run before any automation project
All three failures could have been prevented with questions asked before the build. A short pre-automation review should cover:
- Is the process written down and agreed? If two teams do it differently, the automation will encode one version and break the other.
- What controls exist today, formal and informal? Duplicate checks, sense checks on amounts, verbal confirmations. Each one must either be built into the automation or deliberately removed.
- Is the input data reliable? Sample real records and check completeness and accuracy. If the data is poor, fix the capture process first.
- What happens with exceptions? Every process has cases that do not fit the rules. Decide who handles them and how the automation hands them over.
- Who owns the automation after it goes live? Someone must monitor it, fix it when it fails and update it when the business changes.
- How will you know it is working? Define a few measures, such as processing time, error rate or exceptions per week, and check them from the first day.
None of these checks needs special software or a large budget. Most can be answered in a week by sitting with the people who run the process and pulling a sample of real records. Compared with rebuilding an automation that nobody trusts, that week is the cheapest part of the project.
Build in the ability to notice problems
Even good automation can go wrong when something changes: a supplier changes its invoice layout, a system update renames a field, a new branch uses a different code. Good automation is designed to notice. It logs what it does, sends exceptions to a person rather than guessing, and raises an alert when volumes or values look unusual. A daily summary, such as “42 invoices processed, 3 sent for review”, keeps people connected to what the automation is doing.
Start small, too. Automate one part of the process for one team, watch the results for a few weeks, then expand. Problems found at small scale are cheap. The same problems found after rollout across five branches are not.
Automation that improves the process as well as speeding it up
Before approving your next automation project, ask the team to answer the six checks above in writing. It takes a few hours, and it would have caught every problem described in these stories. The same order explains why Automate comes fifth in the KEMLAT Method, after Know, Evaluate, Map and Launch, and is followed by Track to confirm the impact.
Our Intelligent Automation service follows that order. We look at how the work really happens, fix what needs fixing, and build automation with the controls, exception handling and monitoring that keep it trustworthy.



