Pull up your last ten postmortems. Count how many of them conclude with some version of "we added a new dashboard," "we added a new alert," or "we added a new step to the runbook." Now ask yourself honestly: how many of those additions actually got removed later, once the underlying problem stopped mattering? My guess is close to zero. Operational maturity, in most organizations, is not a line that goes up. It's a pile that gets taller.
I've spent this year writing about the places where reliability work quietly relocates instead of resolving — the error budget argument that moves from the SLO meeting to the roadmap meeting, the MTTR number that drops while the actual user pain stays flat, the escalation path that looks tested until the night it isn't. The throughline across all of it is simple and a little depressing: most operational fixes are displacement, not elimination. You're not removing the failure mode. You're moving where it shows up, and usually who it shows up for.
The Fix Rarely Kills the Problem — It Just Changes Its Address
Here's the pattern I keep running into, in teams of every size and maturity level. Something breaks. The team writes a postmortem. The postmortem produces action items. The action items get implemented — a new check, a new gate, a new piece of tooling. Six months later, something breaks again, and it's adjacent to the first thing, not identical to it. The team declares progress because the exact same incident didn't repeat. But if you zoom out, the total amount of operational toil in the system hasn't dropped. It's just distributed differently — maybe onto a different service, maybe onto a different shift, maybe onto the one engineer who understands the new gate well enough to bypass it at 2am.
This isn't a failure of effort. It's what happens when you treat reliability as a series of discrete bugs instead of a property of the whole system. Bugs get fixed. Properties get traded off. When you tighten a deploy gate to catch one class of regression, you've added latency to every deploy, which means someone, somewhere, is now more likely to batch changes to avoid the friction — which is its own reliability risk, just a quieter one that won't show up in a postmortem for another year.
Boring Reliability Means Admitting the Pile Exists
The teams I trust most aren't the ones with the cleanest incident channel or the most polished dashboard. They're the ones willing to say, out loud, in a retro: "we didn't fix this, we moved it, and here's where it probably went." That's an uncomfortable thing to put in writing because it doesn't read like progress. It reads like an admission that the backlog of operational debt is real and has interest.
Dry as it sounds, I'd rather work with a team that keeps an honest list of the trade-offs they've made than one that keeps a spotless list of problems they've "solved." The spotless list is usually spotless because nobody went looking for where the problem moved to. The alert that used to fire constantly got tuned down — great, but tuned down to what? Did the underlying failure rate actually drop, or did you just change the threshold until it stopped being your problem to look at?
What to Actually Do With That List
None of this means stop fixing things. It means change what you ask when a fix lands. Instead of "did this incident stop recurring," ask "where did the operational cost of this problem go, and who's carrying it now." That's a harder question, and it won't fit neatly into a quarterly reliability scorecard, which is probably why most teams don't ask it.
If you run a retro this month, try adding one line to the template: "what did this fix cost someone else." Not as punishment, just as bookkeeping. The team that can answer that question honestly is the team that's actually tracking reliability instead of just tracking incidents. The team that can't is probably still accumulating a pile it hasn't noticed yet — and piles, unlike graphs, don't announce themselves until the night someone trips over one.
