Home › Topics › Alert Design › Severity Design

Designing Severity Levels That Mean Something


Somewhere right now, an admin is looking at a screen with forty-one "critical" alerts on it, calmly drinking coffee. That screen is not evidence of a terrible network. It is evidence of a broken vocabulary. When the word critical no longer changes anyone's behavior, the alerting system has lost its most important feature. That is the ability to say this one is different. And that loss happened one reasonable-seeming decision at a time.


Severity is not a label, and it is definitely not a mood. A severity level is a promise about response. It tells the receiver how fast a human must act, on what channel the news arrives, and what happens if nobody does. When the levels keep those promises, a single glance at an alert tells you whether to stand up or finish your sandwich. When they do not, everything is urgent, so nothing is. People then fall back to reading every alert in full and guessing. That is exactly the work severity exists to remove. This guide builds a severity scheme that keeps its promises. It covers the two questions severity answers and a concrete three-level scheme sized for small teams. It also covers the discipline for assigning levels per alert. Then comes the maintenance that stops the whole thing sliding into "everything is critical" again.


In this guide

  • The two questions severity answers
  • A working scheme: three levels plus info
  • Assigning severity: tier times condition
  • Severity inflation, and the deflation discipline
  • What severity does all day
  • Two edge cases worth designing for
  • The severity policy one-pager

The two questions severity answers


Strip away the tooling and severity answers exactly two questions. First: how bad is the impact? Is something user-facing broken right now, or degraded, or merely heading somewhere bad with plenty of runway? Second: how fast must a human act? Within minutes, within the business day, or never — because some findings owe no response at all. Every severity level you define is just a named bundle of answers to those two questions.


Notice what is not in there: how the alert's author felt about it. Severity is a response contract, not emotional temperature. "This subsystem is my baby and I care deeply" is not a severity. "The finance database is unreachable and finance is working today" is. The moment severities start encoding feelings, the vocabulary starts lying. Those feelings include importance-to-me, embarrassment-if-missed, and how loudly a stakeholder complained last time. Receivers then learn to distrust the vocabulary. Keep the two questions taped to the wall; every definition below is built from them.


Watch the two questions work on a live specimen. "Certificate on the VPN portal expires in 21 days." How bad is the impact? Right now, zero — nothing is broken, nobody is affected. How fast must a human act? Within the next couple of weeks, comfortably inside business hours. Two mild answers, so this earns a mild severity — whatever your scheme calls its plan-work lane. Now re-run the same check with a different finding: "certificate expired an hour ago." Impact: every remote worker's VPN client is refusing to connect, right now. Response: minutes. Same check, same certificate, radically different answers — and that is the entire skill. Severity is assigned to answers, never to checks.


A working scheme: three levels plus info


How many levels? Fewer than you think. Big platforms ship five or six (and some venerable standards define eight). But every level is only real if it maps to a genuinely different response. And a small team does not have six different responses. It has about three: drop everything, handle it today, and no response owed. So: three levels plus an informational tier, each with a definition you can test an alert against.


CRITICAL — the wake-someone bar

User-facing impact is happening now, or is imminent and unstoppable without action. The internet link is down. The file server is unreachable. The UPS is on battery with nine minutes left. Response: a human acts within minutes. Outside business hours this level is allowed to page — to interrupt someone's dinner or sleep. That is the test to say out loud before granting the label: would I wake a colleague at 3 a.m. for this? If the honest answer is "well, it could wait until morning," it is not critical. No exceptions for pet systems.


WARNING — the plan-work lane

Degradation, or a lead-time finding: something is heading toward impact with runway to spare. Disk at 88% and climbing. A certificate expiring in three weeks. One power supply of two has failed. Response: a human acts within the business day — it goes on today's list, not this minute's. Warnings are the workhorse of good alerting, because they are where problems get fixed cheaply, on schedule, before they ever earn the critical label. A healthy shop handles many warnings and few criticals; that ratio is the whole point.


One trap to design out early: the warning that owes a response "within the business day" needs a lane where that response actually happens. That means a ticket created, a task on today's list, an owner named. Without a lane, warnings become wallpaper: technically delivered, vaguely noticed, never actioned, until one of them quietly matures into the outage it spent three weeks predicting. If your team cannot say where a warning goes to get worked, the level is a label without a promise. In that case, the fix is process, not tooling.


INFO — context, never interruption

Findings with no response owed: a device rediscovered, a maintenance window opening, a metric worth a glance in the weekly digest. Info exists so that the useful-but-not-actionable facts have somewhere to go that is not your interrupt channels. Be ruthless here: info items go to a digest, a dashboard, or a log — never to the channel where pages arrive. Every FYI that lands in the interrupt stream teaches people to skim, and skimming is how real alerts die. The alert fatigue guides document that spiral in detail.


Here is the whole scheme on one screen — the mapping table your team can adopt as-is and tune later:


LevelDefinitionResponse promiseChannelExamples
CRITICALUser-facing impact now, or imminent and unstoppable without actionAct within minutes; may page after hoursPage / phone / instant pushWAN down; key server unreachable; UPS on battery; scope-filling DHCP failure
WARNINGDegradation or a lead-time finding with runwayAct within the business dayEmail / ticket / team chatDisk 88%; cert expires in 21 days; RAID degraded; link flapping overnight
INFOContext; no response owedNone — read on your own scheduleDaily digest / dashboard onlyDevice rediscovered; config change seen; monthly availability summary

Three levels also means every level stays teachable: a new hire can learn this table in one sitting and act correctly on day two. That is worth more than taxonomic elegance. (If your platform insists on five levels, map its extras onto these three and move on. Unused levels cost nothing, and misused ones cost plenty.)


Assigning severity: tier times condition


The scheme gives you the levels; discipline is how each individual alert gets one. The key insight: severity is not a property of the check. It is a property of the check on that device, in that condition. "Device down" is not inherently critical — it depends entirely on which device.


The clean way to decide is tier times condition. First comes the device's criticality tier — the ranking of how much the business hurts when this box misbehaves. You have ideally already assigned that tier per the guide on criticality tiers. Then, the condition's inherent weight. Cross them: the same "device unreachable" check earns CRITICAL on the Tier-1 core switch. It earns WARNING on the Tier-2 departmental print server, and a mere digest line on the Tier-3 lab machine someone reboots weekly. One check definition, three severities, all three correct — because the impact question has three different answers.


The second assignment pattern is the escalation ladder: the same metric crossing successive thresholds at rising severities. Disk at 80% is a WARNING — plan work, clear space this week. Disk at 95% is CRITICAL — the runway is gone and services will start failing. Warning-at-80, critical-at-95 gives you the early cheap fix and the last-ditch alarm. The gap between the rungs is the time the warning bought you. Ladders work for anything with a gradient: latency, packet loss, queue depth, battery runtime. When you pick the rung values, pick numbers you can defend — the reasoning lives in static thresholds done right.


Run three assignments through the rules to see them settle arguments. "Ping failed: reception printer." Condition sounds dire (device down!), but the tier answer is withering — Tier 3 at best, impact near zero, and printers resurrect themselves hourly. Verdict: INFO in the digest, or at most a WARNING if reception genuinely stops without it. "RAID array degraded on FILE01." Impact today: none — the array still works. But the finding has a nasty property: the protection is gone, and a second disk failure converts this to data loss. Lead-time finding, real stakes, runway measured in days: textbook WARNING, with the response promise "replace the disk this week," not "someday." "DHCP scope 95% full at HQ." Impact is minutes away — when the pool empties, new devices stop joining and the tickets get weird. Imminent, unstoppable without action, user-facing: CRITICAL, even though nothing is technically broken yet. Three alerts, zero mood, three defensible labels.


Tip: record the assigned severity, and the one-line reason, in your alert catalog — the worksheet from the anatomy of a good alert. "CRITICAL because Tier-1 and user-facing" takes seconds to write and ends every future argument about whether it should page.


Severity inflation, and the deflation discipline


Left alone, every severity scheme inflates. Nobody ever files a change request titled "make everything critical" — it happens by drift, through three respectable-looking doors.


Door one: incident-driven promotion. Something bad happens. A post-incident action item says "raise that alert to critical so we never miss it again," and everyone nods. Reasonable! Except no incident ever produces the opposite action item, so promotions accumulate like sediment. Each one is defensible; the pile is not.


Door two: squeaky-wheel severity. A stakeholder is loud, so their system's alerts get promoted — severity as diplomacy. Now the label encodes org-chart volume instead of impact, and the on-call person is being paged at 2 a.m. to manage a relationship.


Door three: vendor defaults. Monitoring templates ship with severities chosen by someone who has never seen your network and has every incentive to err loud. Import a device template, inherit forty opinions — many marked critical — that nobody on your team ever actually made.


The costs arrive on a delay. Paging fatigue first: on-call people are woken for non-emergencies, and their bodies learn what their dashboards should have known. Triage paralysis next: when a real outage puts eleven criticals on screen, nothing tells the responder which one is the disease and which are symptoms. And finally comes the quiet catastrophe: the genuinely critical alert lost in a crowd of fake ones, read late or not at all. That is the exact failure the whole system exists to prevent.


The counter-move is the severity audit. And it is gloriously unsophisticated. Periodically, every CRITICAL in the system must re-justify itself against the wake-someone bar, out loud, or be demoted. "Would we truly get someone out of bed for this?" No? Then it is a WARNING, whatever its history, whoever its sponsor. Do a full pass quarterly, and let your weekly alert review catch the worst offenders between passes. The weekly data shows which criticals fired, and whether anyone actually treated them as critical. That is precisely the evidence a demotion needs. Deflation is not a one-time cleanup; it is a standing chore, like weeding.


What severity does all day


A severity level you only look at when assigning it is decoration. In a working shop, severity is load-bearing in three places.


Sorting and display. Alert lists, dashboards and consoles sort by severity, so the top of every screen is, by contract, the worst thing happening. During a messy incident this is triage for free — but only if the labels are honest. Forty-one fake criticals turn the sort into noise-ordering.


Response timers. The response promise becomes machinery. A CRITICAL unacknowledged after fifteen minutes escalates to the next person or the louder channel. A WARNING waits politely until tomorrow's list. Timers-by-severity is how the promise survives a busy day — and it only works if the level was assigned by policy, not mood. The alert lifecycle guide covers the acknowledgement machinery itself.


Reporting. Counts-by-severity, per week, is one of the most honest health metrics your monitoring system produces — the severity histogram. A healthy shop's histogram is a pyramid. It has a broad base of info absorbed by digests and a solid middle of warnings that became scheduled work. It has a small tip of criticals, each one a genuine drop-everything event. A histogram shaped like a cylinder has criticals about as common as warnings. That is inflation showing up in the data before anyone has said it out loud. Track the shape over time; it will tell you when the audit is due.


Two edge cases worth designing for


The after-hours modifier

Some conditions genuinely change urgency with the clock. A degraded WAN link at 2 p.m. is a drop-everything problem. The same link at 2 a.m., with the office empty, can wait for coffee. The clean pattern is schedule-aware severity. The alert is CRITICAL during business hours and WARNING outside them. Or, equivalently, the level stays put and the paging channel is only attached during business hours. Most platforms can express one of those two shapes with time-based rules or schedules. Use the modifier sparingly and write it down where responders can see it. A severity that silently changes with the clock, undocumented, reads as a broken alert to whoever is on call. And note the direction matters: conditions that threaten overnight processes (backups, batch jobs) may deserve the opposite modifier entirely.


Many warnings, one critical

Sometimes no single finding clears the critical bar, but the pattern does. One access point down is a WARNING. Nine access points down at once means something upstream is on fire, and that pattern deserves a CRITICAL of its own. The idea is the aggregate condition: an alert whose trigger is a count of other conditions. For example, the trigger might be "more than N of these warnings active at once." The aggregate condition is expressed through whatever grouping, dependency or correlation features your platform offers. Even implemented crudely, it encodes a truth flat schemes miss: severity can live in the combination, not the parts.


The severity policy one-pager


Everything above compresses onto one page — and it should, because a severity policy nobody can remember is a severity policy nobody follows. Copy this skeleton, fill in your names and numbers, and put it where the on-call person will find it:


SEVERITY POLICY — [team name]        reviewed: [last audit date]

LEVELS
  CRITICAL  user-facing impact now, or imminent + unstoppable.
            Respond within [15] min. May page 24x7.
            Test: we would wake someone for this.
  WARNING   degradation or lead-time finding with runway.
            Respond within [1] business day. Email/ticket/chat only.
  INFO      context; no response owed. Digest + dashboards ONLY.

ASSIGNMENT RULES
  - severity = device tier x condition (see tier list)
  - gradient metrics use ladders: WARNING at [80]%, CRITICAL at [95]%
  - schedule-aware alerts are listed in [location], with hours
  - nothing enters CRITICAL without passing the wake-someone test

MAINTENANCE
  - weekly review flags criticals nobody treated as critical
  - quarterly audit: every CRITICAL re-justifies or is demoted
  - vendor-default severities are drafts, not decisions

One page, three promises, a handful of rules. The payoff arrives the next time an alert lands after midnight. Its label alone — trusted, because it is policed — tells the reader whether to stand up. That trust is the entire product of severity design.


Where to go next


Severity is one of the six design inputs every alert needs. The guide to the anatomy of a good alert shows the other five and the worksheet that holds them. The level decides where and how loudly the news arrives. That is the territory of the notification channels guides. The words the reader then sees are covered in alert message writing. And the audit that keeps your labels honest gets its cadence from the weekly alert review. The whole set lives in Alert Design.


Put this into practice with SysPeep Monitor

A severity policy needs a platform that can express it. SysPeep Monitor lets you set per-alert severities backed by thresholds, dependencies, and alert rules designed to keep noise down. So a warning-at-80, critical-at-95 ladder or a page-only-for-critical routing takes minutes to build. SysPeep Monitor offers email and other notification options per level. Try it free on any Windows machine.

Download Free TrialLearn About SysPeep