Skip to content
GenAI BPM Process Intelligence

Myth Buster: Automation Fixes Broken Processes

Lukas Pfahlsberger
Lukas Pfahlsberger

The sentence usually arrives about forty minutes into a budget meeting. Someone has just walked through the numbers on invoice processing, or customer onboarding, or claims handling: too slow, too many hand-offs, too many complaints. There is a pause, and then a senior voice says what everyone has been thinking. "We should just automate it." Heads nod. The process is clearly broken, automation is clearly the modern answer, and the decision feels less like a bet than like overdue housekeeping.

This edition of Myth Buster takes that sentence seriously. The assumption behind it — that automation fixes broken processes — is one of the most widely held beliefs in operations, and it is held by capable, experienced people for understandable reasons. So before we examine where it fails, it is worth being honest about why it sounds right.

Where the Myth Comes From

The myth has a true core, and the true core is substantial. Automation genuinely removes a category of problems that plague manual processes: typing errors, forgotten steps, inconsistent handling between two clerks on the same task, and the sheer elapsed time of a document sitting in an inbox waiting for a human to notice it. When a process is stable and well understood, handing its repetitive steps to software produces exactly what the business case promises — fewer errors, faster cycle times, lower cost per case.

The belief has also been fed by two decades of experience and messaging. Early RPA projects were often applied to processes that were already tidy, and the results were striking. Vendor marketing then generalised the lesson: every demo shows a clean process becoming a fast one, and the narrative quietly implies that the cleanliness was produced by the tool rather than being a precondition for it.

Finally, the myth is attractive precisely in the situations where it is most dangerous. A broken process is uncomfortable to examine. It involves conversations about who owns which step and why the exception rate is so high. Automation offers a way to act decisively without having those conversations. It converts a messy organisational problem into a clean technology project with a vendor, a budget and a go-live date.

What Actually Happens

Automating a Broken Process Makes the Defect Faster, Not Smaller

The oldest argument against the myth is also the clearest. In 1990, Michael Hammer opened his Harvard Business Review article on reengineering with the observation that companies were leaving their existing processes intact and using computers simply to speed them up — and that speeding up those processes could not address their fundamental performance deficiencies. His phrase for it was "paving the cow paths". Decades and several technology generations later, the pattern is unchanged, because the problem was never the speed of the technology but the shape of the path.

Consider what a broken process actually consists of. It is rarely a sequence of correct steps performed too slowly. Far more often it is a sequence that contains a redundant approval nobody can justify, a hand-off that loses context, a data field that is wrong at source and corrected downstream, and an exception route that half the cases take. Automate that sequence faithfully and you get a system that performs the redundant approval instantly, loses the context in milliseconds, propagates the wrong data field to three further systems before anyone can intervene, and either cannot handle the exception route at all or handles it as a hard failure. The defect has not been fixed; it has a faster engine and a layer of code that makes it harder to change.

Consider a mid-sized insurer that automates its claims intake exactly this way — a composite of a pattern we see regularly. The manual process has a known weakness: intake staff frequently choose the wrong claim category, and adjusters correct it later. The automation captures the category from the form and routes accordingly. Routing becomes instant — and so does the misrouting. Claims that previously sat for a day and were quietly fixed by an experienced adjuster now arrive in the wrong queue within seconds, are worked by the wrong team, and have to be formally reassigned. Cycle time for correctly categorised claims falls. Cycle time for the rest rises, and the rest can easily be a quarter of the volume. The project is reported as a success on the metric it was designed to improve. We described a close relative of this pattern in the edition on why automation fails when the process is unclear.

The Projects That Fail Mostly Fail on the Process, Not the Technology

If automation fixed broken processes, the projects that targeted the most broken processes would show the best returns. The evidence points the other way. In its early guidance on robotic process automation, EY reported having seen as many as 30 to 50 percent of initial RPA projects fail, and named targeting a highly complex process as a common mistake — recommending low or medium complexity processes as the right starting point.

Deloitte's global RPA survey found that only 3 percent had scaled their automation to fifty or more robots, that 63 percent said their expectations of time to implement were not met, and — the finding that matters most here — that process standardisation was the top challenge faced by organisations across all stages of the RPA journey. The report's own summary is blunt: process complexity drives robot complexity. Operations documented as standard turned out to differ across countries and business units, and every undocumented variant became a build item, a test case and a maintenance burden.

Read together, these findings describe one mechanism. Automation projects stall in discovery when the team realises the "standard" process has eleven versions, overrun when each version needs its own handling, and underdeliver when the automated share of cases is smaller than the business case assumed. None of that is a technology problem. All of it was present before the project started; the project merely made it visible — expensively, and late.

The Event Log Shows the Process You Would Actually Be Automating

The third argument comes from what becomes visible when a process is measured rather than described. When an organisation reconstructs its real execution paths from system timestamps — the discipline of process mining — the picture almost never matches the flowchart that the automation business case was built on. The documented process is one path; the event log typically shows dozens, and what decides whether automation will help is how the volume is distributed across them.

Take a typical purchase-to-pay process in a manufacturing group. The documented happy path — order, goods receipt, invoice, three-way match, payment — often accounts for well under half of the cases. The remainder goes through price-change loops, manual blocks and releases, invoices arriving before orders, and a recurring pattern where the goods receipt was posted after the invoice specifically so that the match would pass. An automation proposal built on the flowchart assumes the happy path is the process. Go ahead with it, and it accelerates the minority of cases that were already working and leaves the majority exactly where they are, with the added effect that the "goods receipt after invoice" workaround is now performed against an automated matcher designed to reject it. This is the same dynamic as in our recent edition on why workarounds become the real process: automate the official route while the real one runs elsewhere, and you have automated a fiction.

What the event log also shows, and what makes it useful rather than merely sobering, is the cause behind each variant. Platforms such as noreja go beyond mapping the paths to identifying what drives them — a supplier segment, a plant, a specific data condition at the start of the case. That turns "the process is messy" into "the process has three root causes, two of which can be removed and one designed as a proper exception path". Once that is done, the remaining process is stable enough that automation does what the myth always promised.

What Is True Instead

The more precise statement is this: automation amplifies whatever process it is applied to. Apply it to a stable, understood process with a high standard-path share, and it amplifies the good — fewer errors, faster cycles, lower cost. Apply it to a broken process, and it amplifies the defects: the wrong data moves faster, the redundant step runs more often, the exceptions pile up in a queue that no longer has a human to absorb them. Automation is a multiplier, not a repair — and multipliers do not care about the sign of what they multiply.

That reframing gives you a usable test before any automation decision. Ask three questions of the process in front of you. Do you know, from measurement rather than documentation, what share of cases follow the standard path? Can you explain the main deviations and say for each whether it is a defect to remove or a legitimate exception to design for? And is the process stable enough that it has not changed materially in the last two quarters? Three yeses mean automation is likely to pay off as expected. A no on the first question means you do not yet know what you would be automating. A no on the second means you would be encoding problems you have not understood. A no on the third means you would be building on ground that is still moving.

None of this is an argument against automation. It is an argument about sequence. Measure first, fix or design the deviations second, automate third — and recognise that for a genuinely broken process, the first two steps are where most of the value is. Organisations that get this right often find the remaining automation is smaller, cheaper and more reliable than the original proposal. Those that skip ahead find, as in the edition on how every new tool inherits the old bottleneck, that they have bought a faster version of the problem they started with.

Food for Thought

For the process you are most tempted to automate right now, do you know what percentage of cases actually follow the documented path — and is that number from a system or from a workshop?

When your last automation project overran, was the cause in the tool, or in process variants nobody had written down?

Which step in that process exists because of a problem that could be fixed at the source instead of handled downstream?

If you automated the process exactly as it runs today, which of its current defects would become faster — and which would become invisible?

Who in your organisation has the authority to change the process before it is automated, and are they in the room when the automation budget is approved?

Conclusion: Automation Multiplies, It Does Not Repair

The belief that automation fixes broken processes survives because it is half true and wholly convenient. It does fix one class of problem — the slowness and inconsistency of manual work on a stable process — and fixes it so well that the result gets generalised into a promise it cannot keep. Applied to a process that is broken in its structure, automation does what any multiplier does: it scales up what is there, defects included, and wraps the result in code that is harder to change than the manual routine it replaced.

The stance we would recommend is neither enthusiasm nor scepticism, but sequence. Find out what the process really does before deciding what software should do with it. Fix what is a defect, design what is a legitimate exception, and then automate what remains — which will be more stable, more predictable and more worth automating than what you started with. We invite you to look at the next automation proposal on your desk and ask one question before the budget question: do we actually know what we are about to make faster?

FAQ

Does automation fix inefficient processes?

Not by itself. Automation removes the slowness and inconsistency of manual work, but it reproduces the structure of the process it is applied to. Redundant steps, bad source data and unhandled exceptions are executed faster, not eliminated — which is why automating a broken process typically makes its defects more visible and harder to change.

When should you automate a process?

When you know from measurement, not documentation, that most cases follow a stable standard path; when the main deviations are understood and either removed or designed as proper exception routes; and when the process has not changed materially in recent quarters. If any of these is missing, the first investment should be in understanding and stabilising the process.

Why do so many RPA projects fail or stall?

Advisory surveys consistently point to the process rather than the technology. Deloitte's global RPA survey found process standardisation to be the top challenge at every stage, with only a small minority of organisations scaling successfully, and EY reported that a large share of initial RPA projects fail, often because they targeted overly complex processes.

What does "paving the cow paths" mean in process management?

The phrase comes from Michael Hammer's 1990 Harvard Business Review article and describes using technology to speed up an existing process without questioning its design. The result is a faster version of the same inefficient route — the problem that process redesign, and today process mining, are meant to address before automation is applied.

How does process mining help before automation?

Process mining reconstructs the paths a process actually takes from system timestamps, showing how much volume follows the documented route and where the rest goes. It reveals which deviations are defects to remove and which are legitimate exceptions to design for, and causal analysis identifies what drives them — giving you a stable process to automate instead of a flowchart to hope for.

Share this post