Skip to content
DevOps AI ToolKit
Newsletter
All guides
AI for Incident Response By James Joyner IV · · 9 min read Last reviewed Jul 2026

Incident Response Failure Mode: Normalization of Deviance and the Chronic Alert You Learned to Ignore

Quick answer

The alert that always fires and never matters trains your team to ignore it, until the day it does. Spot normalization of deviance and reverse it in time.

  • #incident-response
  • #sre
  • #troubleshooting
Free toolkit

Stuck on this Incident Response error? Get the free incident triage checklist

A one-page PDF — the exact steps to isolate, fix, and verify a production error like this one. No spam, unsubscribe anytime.

Overview

There is an alert that fires every few days. It has never once corresponded to a real problem. Everyone knows it is “just that flaky check,” and the standard operating procedure — never written down, but universally understood — is to acknowledge it and move on. Then one day it fires for a real reason, the team acknowledges it out of pure habit, and a genuine incident goes unaddressed for hours because the signal that was trying to warn them had long ago been trained into background noise.

This is normalization of deviance: the gradual process by which a warning signal, or a risky shortcut, or a degraded condition becomes accepted as normal because “it’s always been like that and nothing bad happened.” The term comes from the analysis of the Challenger disaster, where engineers came to treat O-ring damage as acceptable because previous flights had survived it. In incident response, it shows up every time a team learns to tolerate a chronic alert, a recurring near-miss, or a known-broken condition — quietly eroding the boundary between safe and unsafe until the accumulated deviance produces a real failure.

This guide covers how normalization of deviance takes hold in operational teams, how to detect it, and how to reverse it before it costs you an outage.

Symptoms

  • Chronic alerts that “always fire and never matter” are acknowledged reflexively without investigation.
  • Known-broken conditions are tolerated indefinitely — “oh, that dashboard is always red, ignore it.”
  • Recurring near-misses are shrugged off rather than treated as warnings, because they never quite became incidents.
  • New team members are taught the workarounds as normal — “don’t worry about that alert, we just ignore it.”
  • Risky shortcuts have become standard practice because they have worked so far.
  • The team cannot say which of its firing alerts are real without asking the one person who “just knows.”
  • Postmortems reveal the warning was there all along and had been routinely ignored for weeks or months.

Common Root Causes

  • Repeated exposure without consequence. Every time the deviant condition occurs and nothing bad happens, its perceived risk drops a little, until it is treated as safe.
  • Alert noise that is never fixed. A flaky or overly-sensitive alert that is silenced-by-habit rather than repaired trains the team to distrust it — and eventually to distrust the category of alert it belongs to.
  • No mechanism to revisit accepted conditions. Once something is tolerated, nothing ever forces a re-examination of whether it should still be tolerated.
  • Toil and prioritization pressure. Fixing the flaky alert or the known-broken thing is never urgent enough to beat feature work, so it lingers and normalizes.
  • Cultural transmission. The workaround gets taught to newcomers as tribal knowledge, cementing the deviance as institutional practice.
  • Absence of near-miss tracking. Near-misses that could recalibrate the team’s risk perception are never captured, so the warnings evaporate.
  • Success as the enemy. The longer the deviant condition survives without disaster, the more confident the team becomes that it is fine — precisely backwards.

Diagnostic Workflow

1. Inventory your chronically-acknowledged alerts. Pull alerts that fire frequently and are almost always acked without a linked action. Each is a candidate for normalized deviance — either fix it or prove it is real.

2. Ask “what do we ignore, and why?” In a blameless setting, ask the team to list the alerts, dashboards, and conditions they routinely disregard. The list itself is often eye-opening.

3. Audit onboarding lore. Review what new engineers are told to ignore. Workarounds taught as normal are institutionalized deviance and mark exactly where the safe/unsafe boundary has eroded.

4. Trace incidents back to ignored warnings. For recent incidents, check whether a chronically-ignored signal had been firing beforehand. A pattern confirms that normalization is actively costing you.

5. Review near-miss capture. Determine whether near-misses are recorded and discussed. If they vanish without analysis, the team has no mechanism to recalibrate its risk perception.

6. Distinguish “false” from “unfixed.” For each ignored alert, establish whether it is truly false (should be deleted) or real-but-noisy (should be fixed). “We ignore it” is never an acceptable resting state for either.

Example Root Cause Analysis

Incident: A queue-depth alert had fired intermittently for months. It was widely regarded as flaky and routinely acknowledged without action. On the day of the incident, it fired at 11:00 and was acked at 11:01 out of habit. The queue was, this time, genuinely backing up due to a stuck consumer. By 14:30, the backlog had grown large enough to breach processing SLAs and cause customer-visible delays, and only then did anyone investigate.

Surface finding: “Stuck consumer caused a queue backlog and SLA breach.”

Deeper analysis:

  • Detection: The alert fired correctly at 11:00 — three and a half hours before impact. Detection was never the problem.
  • The normalized deviance: Months of the alert firing without a real cause had trained the team to treat it as noise. The 11:01 acknowledgment was reflexive, not considered.
  • Why it was never fixed: The alert was known to be over-sensitive, but repairing its threshold never beat feature work in prioritization, so it stayed noisy and continued eroding trust in its own signal.
  • Cultural transmission: New on-call engineers had been explicitly told “that queue alert is flaky, just ack it,” making the deviance institutional.
  • Systemic factor: No mechanism ever forced a re-examination of whether tolerating this noisy alert was still acceptable, and near-misses (earlier smaller backlogs) had never been captured to recalibrate the team.

Real root cause: Not the stuck consumer, but a chronically-ignored alert whose repeated harmless firing had normalized ignoring it, so a real warning delivered three and a half hours of lead time that the team had been trained to discard.

Corrective actions: (1) The queue alert threshold was fixed so it fires only on genuine backlog, restoring its signal value. (2) A standing rule was adopted: any alert routinely acked without action goes on a “fix or delete” list — ignoring is not allowed as a permanent state. (3) A lightweight near-miss capture process now records smaller backlogs so the team’s risk perception stays calibrated.

Prevention Best Practices

  • Ban “we just ignore it” as a resting state. Every chronically-acked alert must be either fixed so it is trustworthy or deleted if it is truly false. Tolerating a noisy signal indefinitely is the mechanism of normalization.
  • Track near-misses deliberately. Capture and discuss the conditions that almost became incidents. Near-misses are free recalibration for a team’s sense of what is actually risky.
  • Periodically re-examine accepted conditions. Schedule a recurring review of known-broken things and tolerated deviations, forcing the question “is this still acceptable, or have we just gotten used to it?”
  • Fix alert noise as reliability work, not a nice-to-have. A noisy alert does not just waste time; it erodes trust in the whole alerting system. Prioritize repairing it accordingly.
  • Audit onboarding for institutionalized workarounds. What you teach newcomers to ignore reveals where your safe/unsafe boundary has quietly moved. Fix the underlying condition rather than passing down the workaround.
  • Treat surviving-so-far as a warning, not reassurance. The longer a deviant condition has held without disaster, the more scrutiny it deserves, not less. Success is not proof of safety.
  • Make every real alert mean “act.” The goal is a state where a firing alert reliably warrants action, so no one is ever trained to ignore the thing that is trying to save them.

Quick Reference

SignalWhat it indicatesFirst action
Alerts always acked, never actionedNormalized deviancePut each on a “fix or delete” list
”That’s always red, ignore it”Tolerated broken conditionRe-examine whether it is still acceptable
Newcomers taught the workaroundInstitutionalized devianceFix the condition, not the lore
Near-misses shrugged offNo recalibration mechanismCapture and discuss near-misses
Incident preceded by ignored signalDeviance costing you outagesTrace incidents to chronic alerts
Can’t say which alerts are realEroded trust in alertingFix noise as reliability work

Conclusion

Normalization of deviance is quiet and cumulative. No single acknowledgment of the flaky alert feels dangerous; the danger is in the pattern, where repeated harmless firings slowly retrain a team to discard the very signals meant to protect it. By the time the chronic alert fires for a real reason, the reflex to ignore it is already wired in, and hours of hard-won lead time get thrown away out of habit.

Reverse it by refusing to let “we just ignore it” be a permanent answer. Fix or delete every noisy alert, capture near-misses to keep your risk perception honest, periodically re-examine what you have quietly come to tolerate, and treat a long run without disaster as a reason for more scrutiny rather than less. The condition that everyone has learned to ignore is not the safe one — it is the one most likely to be firing, unheeded, on the day it finally matters.

Free download · 368-page PDF

Fixed it? Get 500 Incident Response & DevOps AI prompts — free

500 battle-tested, copy-paste AI prompts engineered by a senior systems engineer — every one with fill-in placeholders and safety/back-out notes. Drop your email and it's yours.

  • 500 prompts: Linux · Kubernetes · Terraform · OpenStack · GitLab · Docker · Monitoring · Incident Response
  • Instant PDF download — yours free, forever
  • Plus one practical AI-workflow email a week (no spam)

Single opt-in · unsubscribe anytime · no spam.

Did this fix your issue?

Free download · 368-page PDF

Get 500 Battle-Tested DevOps AI Prompts — Free

500 battle-tested, copy-paste AI prompts engineered by a senior systems engineer — every one with fill-in placeholders and safety/back-out notes. Drop your email and it's yours.

  • 500 prompts: Linux · Kubernetes · Terraform · OpenStack · GitLab · Docker · Monitoring · Incident Response
  • Instant PDF download — yours free, forever
  • Plus one practical AI-workflow email a week (no spam)

Single opt-in · unsubscribe anytime · no spam.