Pattern Elimination System

Find the pattern behind recurring failures.

Pattern Elimination System

What this fixes

Your retrospectives feel useful. Good discussion, plenty of actions, everyone leaves feeling productive. Then six weeks later the same kind of incident happens again - different details, same shape - and you run another useful retro that changes nothing.

The reason is obvious once you see it: you’re fixing incidents one at a time. The problem isn’t that the incidents are different - it’s that you keep looking at them one at a time. Treated independently, each fire looks unique, so no one ever lines them up to see that ten “different” problems are really one pattern showing up in ten different ways. The isolation is what conceals it - and a pattern you can’t see is one you can’t stop.

This tool finds the pattern and ends the category. You lay your recent incidents side by side, extract the one condition beneath them, name it, and install a prevention bound to a trigger. You don’t eliminate recurring failures by fixing incidents - you eliminate them by finding the pattern.

How this works

Imagine this: three outages, a missed launch, and a data bug all look unrelated - until you line them up and see every one traces to a dependency no one owned. That’s not five problems. It’s one pattern, five times.

Lay out the recent incidents. Put the last several incidents side by side so the team can see them together - putting them together is what makes the pattern visible in the first place.

You extract the pattern. This is the hard part, and the point of the tool: cluster the similar incidents, identify the common condition, and name it - but only if it shows up in at least three of them. Then check the name against every incident to make sure it really holds.

You shut it out. Bind a prevention to a concrete trigger - “when X happens, then Y” - so the pattern can’t quietly return. Then monitor the next three similar incidents to confirm it’s actually gone. Naming a pattern is discovery; installing the lock is elimination.

Time required

Team ✓   About 45–60 minutes once your incidents are gathered, depending on how many you’re scanning and how quickly the pattern comes into focus.

The time required is indicative and will depend on the size of the team and the number of incidents you’re reviewing.

The facilitator should read the short facilitation guide first - about 6–8 minutes. It is a downloadable PDF on this page.

When to use

Bring several past incidents that feel like they might rhyme - and a suspicion that you keep solving the same thing.

Use it whenever:

  • the same kind of failure keeps coming back in slightly different forms
  • your retros generate good actions, but the recurrence never actually stops
  • you’re firefighting the same category of problem month after month
  • you sense a connection between “unrelated” incidents but haven’t pinned it down
  • you want to prevent a whole category, not just close today’s ticket

What you get

  • A named pattern - written as “we have a ______ pattern” - that the team will recognise again
  • An installed prevention bound to a trigger: “when X, then Y”
  • A way to confirm it worked: the next similar incidents don’t recur

You’ve done it well when: the team can name the pattern in a sentence, point to the prevention you installed, and the next few incidents of that kind don’t happen.

What you’ll notice

  • The moment ten “different” incidents collapse into one named pattern in front of the room
  • How much of your firefighting was the same fire, relit
  • That naming the pattern out loud makes it impossible to un-see

Why this works

Firefighting feels productive - you’re rewarded for fixing today’s incident fast - so each fix stays isolated, and the shared condition stays invisible. Laying the incidents side by side forces the pattern to appear; naming it makes it reusable; and installing an If–Then lock stops it from quietly returning. The category ends because you stopped treating its symptoms as separate problems.

What you need

At least three related incidents. You can’t extract a pattern from one or two - that’s a coincidence. Bring the last several incidents of the kind that keep recurring; three is the minimum, five or more is better.

A facilitator. One person lays out the incidents, forces the extraction beat rather than jumping to a fix, holds the “name it in at least three” rule, and makes sure you leave with an installed prevention, not just a discussion.

The capture sheet (supplied). It carries the whole sequence - the incident tally, the extracted pattern name, and the If–Then lock - so the pattern becomes a record the team can return to, not a whiteboard that gets wiped.

Steps

  1. Tally the incidents (10 min). Lay out the last several incidents - at least three - side by side on the capture sheet, in enough detail that the team can compare them.
  2. Cluster the similar ones (10 min). Group incidents that feel like they share something. Don’t name it yet - just get the ones that rhyme sitting together.
  3. Extract the common condition (10 min). For each cluster, ask what single condition sits beneath all of them. This is the hard, valuable thinking - force it rather than settling for “various causes.”
  4. Name the pattern (5 min). Write it as a sentence: “we have a ______ pattern” - “a Hidden Dependency pattern,” “a Silent Ownership Gap.” Only name it if it appears in at least three incidents. Then run the check: does this name explain every incident in the cluster? If not, go back and re-extract.
  5. Install the If–Then lock (7 min). Bind a prevention to a trigger: “when X happens, then Y.” Make it concrete enough that it fires on its own, without someone remembering to look.
  6. Set the check (3 min). Decide which next incidents will tell you it worked: if the next three of this kind don’t recur, the pattern’s eliminated; if they do, the name or trigger was wrong - revisit it.

Output

  • A named pattern, in a reusable sentence: “we have a ______ pattern”
  • An installed If–Then prevention bound to a concrete trigger
  • A monitoring check that confirms the category has actually stopped

Important rules

  • No pattern from fewer than three incidents. Two points make a line, not a pattern. Require at least three independent incidents - five is better - or you’ll name coincidences and chase ghosts.
  • Extract before you fix. Don’t jump from “here are the incidents” straight to “here’s the fix.” The value is in forcing the abstraction - cluster, find the common condition, name it - not in patching the latest instance.
  • Name it, don’t label it “recurring issue.” A specific, reusable name - “Late Requirement Drift” - is what lets the team recognise the pattern months later. A vague label eliminates nothing.
  • Install, don’t just learn. End on a prevention bound to a trigger, or you’ve run a discovery exercise, not an elimination. “We learned something” is not the output - “we installed something” is.

Planning to facilitate this activity? Access the resources below to get started.

MIndn
Execution must be smooth. Not chaotic or stressful.
Built by Witmer.