Skip to content

Guide

Why automation projects fail

Nine recurring patterns, the warning sign for each, and what to do instead. Most of them are decided long before anything is built.

The short answer

Automation projects rarely fail because the technology could not do the job. They fail because the wrong process was chosen, because the design only covered the case where everything goes right, because a model was used where a plain rule belonged, or because nobody owned the result after handover. The nine patterns below are ordered by when the mistake gets made — before scoping, at design, during build, and after go-live — and five of the nine are already decided before any code exists. Each one lists the signal you can observe early, while it is still cheap.

Before scoping

Decided before anyone writes a line of scope. The cheapest to fix and the most expensive to miss.

  1. 01

    Automating a step that should have been deleted

    A step is automated because it exists, not because it is needed — often one that was introduced to work around a problem that has since been fixed.

    Warning sign
    Nobody can explain why the step is there, and the explanation you do get starts with the name of someone who left.
    What to do instead
    Before scoping anything, ask what breaks if the step is simply removed. Sometimes the honest answer is nothing, and the project ends there having saved more than it would have.
  2. 02

    Modelling the documented process instead of the real one

    The build follows the process document, and the process document describes how the work was supposed to happen two years ago.

    Warning sign
    Discovery happened in a meeting room with managers rather than at the desk of whoever actually does the work.
    What to do instead
    Sit with the work as it happens. The informal steps — the second screen, the sticky note, the person everyone quietly asks — are exactly where the exceptions live, and they are never in the document.

At design

Decided on paper. Still cheap to change here, and almost never revisited later.

  1. 03

    Designing only the happy path

    The automation handles the clean case beautifully and has no defined behaviour for anything else, so the first unusual input dumps everything back on a person.

    Warning sign
    The design review covers what the system does and spends no time on what it does when it is unsure.
    What to do instead
    Design the failure path before the working path. Decide what happens on low confidence, on a system being down, and on input nobody anticipated — and make that behaviour visible rather than silent.
  2. 04

    Using a model where a plain rule belonged

    A language model is used for a decision that is fully specifiable, which makes the outcome non-identical between runs and impossible to explain afterwards.

    Warning sign
    Someone asks why a particular case was decided that way and the only available answer is a description of how the model works in general.
    What to do instead
    Use a model where the input is genuinely ambiguous — free text, a document, a thread. Everywhere else write a rule you can read, change and defend to an auditor. It is cheaper to run and identical every time.
  3. 05

    No agreed measure of success

    Nobody decided in advance what should move, so when the budget conversation comes round there is no way to argue the automation earned its place.

    Warning sign
    Asked what success looks like, the answer is a description of the automation rather than a number that should change.
    What to do instead
    Name the measure at design time — hours per week, error rate, or elapsed time from request to done — and record the baseline before anything ships. If you cannot name it, the work is not ready to scope.

During build

Decided by how the first version is delivered.

  1. 06

    Access that never arrived

    The build stalls for weeks on credentials, permissions or a vendor's approval process, and the delay is attributed to the automation being difficult.

    Warning sign
    The kickoff finishes without a named person responsible for granting access to each system, with a date.
    What to do instead
    Treat access as the first deliverable, not an administrative detail. Engagements stall on permissions far more often than on code, and it is the one risk that is entirely predictable at the start.
  2. 07

    The pilot with no second act

    A proof of concept is scoped so narrowly that it proves nothing extensible, and rebuilding it properly costs more than starting again would have.

    Warning sign
    The pilot runs against sample data, in a sandbox, on a path the real process does not use.
    What to do instead
    Make the first build small but real: one genuine workflow, in production, carrying actual work. A narrow thing that runs beats a broad thing that demonstrates.

After go-live

Decided by what happens on the day it ships, and by who is left holding it.

  1. 08

    Failing silently

    The automation stops and nobody notices for weeks, because working and not working look identical from the outside until a customer points it out.

    Warning sign
    Monitoring is a dashboard somebody would have to open. Nothing pushes to a person when work stops moving.
    What to do instead
    Alert a named person when something is stuck, queue work rather than dropping it while a system is unavailable, and make sure running twice cannot create the record twice. Loud, safe failure is what keeps a team trusting the system.
  2. 09

    No owner after handover

    The automation works on the day it ships and degrades from there, because keeping it working is nobody's job and changing it needs a person who has moved on.

    Warning sign
    You cannot name the person who would change a business rule inside it next quarter.
    What to do instead
    Insist on documentation good enough for another developer to take over, credentials you control, and rules a business person can change without a developer. Then name the owner before handover rather than after it.

The pattern behind the patterns

Five of the nine are settled before anyone builds anything, which is why we spend the first stage of an engagement watching the work rather than scoping it.

Almost none of these are engineering problems. Choosing the wrong process, describing it from a document, designing only the good case, and leaving nobody responsible afterwards are all decisions, and all of them are cheap to reverse right up until the moment something is built on top of them. The technology is rarely the constraint. The most common expensive mistake is a well-built automation of work that should not have been automated.

13.4%

Cybersecurity or privacy concerns were the barrier Canadian businesses most often reported as limiting their use of AI, ahead of cost at 10.6%. Both are design questions before they are technical ones.

Source: Statistics Canada, AI use by businesses, Q2 2026

A short pre-mortem

Four questions worth answering in writing before a build is approved. If any answer is vague, that is the one to fix first.
  1. 01

    What happens if we delete this step instead of automating it?

  2. 02

    What does the system do when it is not sure, and who hears about it?

  3. 03

    Which number should move, and what is it today?

  4. 04

    Who changes a business rule inside this in six months?

A workflow audit answers all four against your own process, in writing, before anyone quotes you for a build.

Related

How we work

The four stages, and how each one is arranged around these failure modes.

Recognise one of these from a past project?

Bring it. Knowing how the last attempt failed is the most useful thing you can arrive with.

Book a workflow audit