Home › Topics › Incident Response › Incident Severity

Classifying Incidents: A Working Severity Model


It is 2:14 a.m. and the mail server is doing something unpleasant. Before you can touch it, a swarm of small questions wants answering. Do I wake a colleague? Do I email the whole company or just IT? Do I work this now or leave it for morning? Does the boss need to know before breakfast? None of these is a technical question. They are all the same question wearing different hats: how bad is it?


A team without an agreed answer works out its whole response policy from scratch during every incident, under adrenaline, at the worst possible hour. It then argues about it afterwards. A team with a severity model answers once, in daylight, and spends its incidents responding instead of negotiating. A severity is not a measurement. It is a contract. Saying "this is a SEV-1" is shorthand for a bundle of behaviour agreed in advance. That covers who engages, who gets told, how often updates go out, and whose phone rings at night.


This guide gives you a working model sized for small teams. It has three levels with concrete criteria, a classification grid, and plain rules about who calls it and when to change the call. It includes the response matrix each level sets in motion. At the end, six realistic scenarios get classified in front of you, two of them deliberately awkward. The whole policy compresses onto one page you can pin to the wall.


In this guide

  • Why severity is a contract, not a feeling
  • The three levels
  • The classification grid
  • Who calls it — and how fast
  • Upgrades, downgrades, and the borderline rule
  • What each level sets in motion
  • Severity and your definition of "down"
  • Keeping the model honest
  • Six scenarios, classified
  • The policy on one page

Why severity is a contract, not a feeling


Every incident already gets classified — the only question is whether the classification is written down or improvised. Without a model, "how bad is it" is settled by whoever sounds most alarmed, and the response wobbles accordingly. The loud minor issue gets a heroic midnight response while the quiet serious one waits until Tuesday. With a model, the label does the deciding. The responder maps what they see onto a level, and the level pulls a known response behind it like a train pulling carriages.


This is why the model must be simple enough to apply while stressed. Enterprise frameworks with five severities and a priority sub-matrix are fine for enterprises. A small team needs a scheme a tired human can apply in thirty seconds. They do so during minute four of the first fifteen, right after scoping the blast radius. Three levels is the sweet spot: big enough to separate "drop everything" from "queue it," small enough to hold in a rattled head.


Harbourview Clinic inherited a five-level scheme from a template, with a priority sub-matrix on the second page. For a year every incident was logged as a two, because a one felt like an accusation and a three felt like not caring. When the patient-records system went down for all three sites on a Monday morning it was logged as a two. It got the same response as the week the car-park barrier stuck. The review asked what a one had been for. Nobody could say. The clinic has three levels now, and the records system has been a one twice since, both times on purpose.


The three levels


SEV-1: the drop-everything tier

Criteria: a broad user-facing outage — a critical function unavailable for most or all of the organization — or any credible indication that data is at risk, regardless of scope. The contract: all available hands respond immediately, including after hours. Users are notified within minutes. Leadership is made aware early. Updates flow on a fixed cadence until resolution. Examples: the internet connection down for the whole office, the primary server or its storage down, authentication broken so nobody can log in, ransomware indicators on any machine. That last one is the important asymmetry. One infected PC is a tiny blast radius and still a SEV-1, because the risk is organization-wide and growing.


SEV-2: the hurry-without-heroics tier

Criteria: significant degradation of a critical function, or a full outage confined to one team, one site, or one non-critical-but-important service. Work continues, painfully. The contract: a prompt response begins within the hour during business hours. The affected people are told what is happening. After-hours effort is a judgment call rather than an obligation. Examples: email delayed but flowing, one branch office offline, the shared drive down for a single department, a key application limping on its slow database.


SEV-3: the ticket tier

Criteria: minor, cosmetic, or single-user impact with a workaround available or no urgency. The contract: it goes into the queue and gets handled in normal working time, ordered against everything else in the queue. No broadcast communications, no after-hours work, no drama. Examples: one user's printer refusing to accept that it is a printer's job to print. Other examples are a report page rendering oddly, a non-urgent password reset, and a single failed backup job (with a caveat we will get to in the scenarios).


The classification grid


The levels become mechanical when you see what actually drives them: two axes. Impact scope — how many people are affected: one, a team or site, or everyone. And function criticality — how much the affected thing matters: does work stop without it, does work hurt, or does work merely grumble? Cross them and the grid classifies most incidents for you:


Function ↓ / Scope →One userA team or one siteEveryone
Critical — work stops without it (auth, internet, primary line-of-business app)SEV-3SEV-2SEV-1
Important — work hurts without it (email, file shares, printing as a fleet)SEV-3SEV-2SEV-2
Convenience — work grumbles without it (intranet wiki, room booking, one printer)SEV-3SEV-3SEV-3

Two overrides sit on top of the grid. First: credible data risk is SEV-1 from any cell — security indicators, corruption, storage failing under the backups. Second: sustained degradation of a critical function for everyone can be run as SEV-1 even without a full outage. That is because "technically up" is cold comfort when nobody can work. Note that the criticality axis assumes you know which functions are critical. Deciding that in advance is the tiering exercise from Monitoring Scope. And this grid is where the homework pays off.


One distinction saves endless confusion: alert severity is an input, not a verdict. Your monitoring system labels alerts critical or warning based on thresholds set long ago, per check, with no knowledge of context. A threshold does not know it is month-end. How those labels get assigned is the craft covered in Alert Design. A "critical" disk alert on a test box is a SEV-3; a "warning" latency alert can be the first visible edge of a SEV-1. The alert brings you the evidence. A human reads the scope and the criticality, and classifies. That moment of human judgment is the whole point of this model.


Who calls it — and how fast


The responder on the spot classifies, provisionally, alone, immediately. There is no committee at 2 a.m., and there should not be one at 2 p.m. either. The person looking at the evidence makes the call, states it in the incident thread ("treating this as SEV-2"), and the machinery starts. If a colleague or manager later disagrees, the label moves and nobody apologizes. A provisional call that gets corrected beat a perfect call that arrived forty minutes late, every single time.


The word provisionally is doing real work. Early classification is made with early information, which is by definition incomplete. The model expects correction; that is why upgrade and downgrade rules exist. What the model does not tolerate is deferral. "Let's see how it develops" is a classification too, just a dishonest one. That is because the response machinery idles while it waits. Call it, write it down, adjust when the facts move.


A note on names: nothing magic hangs on the string "SEV." Some shops say P1/P2/P3, some say critical/major/minor. Pick whatever your team will actually say out loud. What matters is that the levels are few and defined in writing. The call must get written down in the incident thread's first lines: "14:06 — treating as SEV-2 per policy, branch offline." An unwritten classification is a mood; the contract only starts when the label lands in the record.


Upgrades, downgrades, and the borderline rule


A severity is a snapshot, and incidents are films. Re-classification is not an admission of error; it is the model working. The upgrade triggers deserve to be explicit, because mid-incident nobody re-reads policy documents:


  • Scope grew. The one-user oddity is now five users; the one-site outage is now two. Re-run the grid with the new scope.
  • Duration crossed a threshold. A SEV-2 that has resisted an hour of real effort, or is on track to cross a business deadline (payroll, month-end), earns a promotion.
  • The workaround failed. The temporary path that justified the lower level collapsed, taking the justification with it.
  • Data risk appeared. Any hint of loss, corruption, or compromise jumps straight to SEV-1, no grid required.

An upgrade is not just a label change — sev-up means help. Raising the severity is the moment to pull in the next person: the colleague, the manager, the vendor. If your team runs a formal escalation ladder, the severity bump and the escalation step should travel together. The guide escalation paths covers how those ladders work. A quiet upgrade that brings no new resources is bookkeeping, not response.


Downgrades take more spine than upgrades, because stepping down feels like tempting fate. (Fate does not read the incident thread.) Do it anyway when the facts support it: the outage is contained, the workaround is holding, the risk is bounded. Announce it with the same clarity as the original call — "downgrading to SEV-3; shares are read-only but stable, full fix tomorrow morning". That lets the response machinery stand down honestly and lets the comms note tell users what changed. And when the incident is fully over, resist the urge to just stop: ending properly has its own checklist, including confirming the final severity in the log.


Tip: the borderline rule. When you are genuinely torn between two levels, classify up and set a thirty-minute timer. If the higher level was wrong, you downgrade in half an hour having wasted a little attention. If the lower level was wrong, you have lost thirty minutes of response you never get back. Over-classification for thirty minutes is the cheapest insurance in incident response.


What each level sets in motion


The contract side of the model is the part that makes the label worth calling. Each severity drives five behaviors mechanically, so nobody re-decides them per incident:


 SEV-1SEV-2SEV-3
Who engagesAll available hands, now; roles assignedOne responder, prompt start within the hourWhoever works the queue
Comms cadenceFirst notice in minutes; updates every 30 minNotice to affected people; hourly or on milestonesTicket updates only
Update audienceWhole company + leadershipAffected team/site + ITThe requester
After hoursYes — wake peopleJudgment call; usually waits for morningNever
Review afterwardFull post-incident reviewMini-review: 15 minutes, three questionsNone beyond the ticket notes

Each row is a doorway into its own craft. The cadence row — what those updates should actually say — is the subject of outage communication. The all-hands row only works if the hands have roles rather than a huddle, which is incident command. And the review row is what turns incidents into improvements: the full treatment for SEV-1s, a lightweight version for SEV-2s, per Post-Incident Reviews. The matrix is deliberately boring. Boring is the feature — it is the part of the response nobody has to think about.


Severity and your definition of "down"


If you have already defined what counts as an outage for availability reporting, this whole guide should feel familiar. That exercise is the subject of defining "down". Severity is the same muscle viewed through a different lens. The outage definition decides what the record says afterward; the severity model decides what the response does right now. Both replace a 2 a.m. judgment call with a daytime agreement.


Keep the two documents consistent, because they will be read side by side after a bad month. If your availability policy says "degraded beyond 30 seconds of load time counts as down," your severity model should not shrug at the same degradation as a SEV-3. When one document changes, re-read the other — they are two views of the same promise about what matters.


Keeping the model honest


Severity criteria drift out of date the same way network diagrams do: quietly, and discovered at the worst time. The maintenance loop is cheap. In every post-incident review, ask one standing question: "was this incident classified correctly, and did the criteria help or hinder?" A misfire is a gift. It might be the outage everyone treated as minor until it was not. Or it might be the all-hands scramble for something that turned out to be one user's cache. Either is telling you exactly where a criterion is vague or a function is mis-tiered.


When a misfire exposes a gap, patch the written criteria that week, while the sting is fresh. Not next quarter. Not "when we revisit the policy". That week. The patches are usually small. For example, "a team" turns out to need a headcount ("three or more users"), or "credible data risk" needs an example list beside it. Add the example to the policy page as a precedent ("branch outages are SEV-2 even when small — see the March warehouse incident"). Over a year, the model accretes your organization's actual judgment, and classification gets faster and less contentious every quarter.


Six scenarios, classified


The model only earns trust by handling real mess. Six scenarios, reasoned out loud — the last two are deliberately borderline:


1. The internet is down for the whole office. Critical function, everyone affected. The grid says SEV-1 without hesitation: all hands, immediate notice, leadership aware. The easiest call on the page.


2. One salesperson cannot print. Convenience function, one user: SEV-3, queued. The salesperson will lobby for an upgrade with great conviction. The model exists precisely so this negotiation ends in one sentence — and so the printer, which planned this, is denied an audience.


3. A ransomware note appears on one PC. One user affected — and it does not matter. The data-risk override fires: SEV-1. Isolate first, classify loudly, wake whoever the security plan says to wake. Scope describes what has happened; this call is about what happens next if you are slow.


4. Last night's backup job failed. No user feels anything, so instinct says SEV-3. For a single failure with a clean history, the ticket tier is right: investigate today, not at dawn. The caveat: a second consecutive failure changes the question from "a job hiccupped" to "we may have no restore point." That is data risk wearing pajamas. Two in a row: treat it as SEV-2 and fix it before anything else needs restoring.


5. Email is delayed twenty minutes for everyone, cause unknown. Borderline by design: important-to-critical function, everyone affected, degradation rather than outage. The grid offers SEV-2; the "sustained degradation for everyone" override whispers SEV-1; the cause being unknown means you cannot yet size the risk. Torn between levels, the borderline rule decides: up. Run it as SEV-1 for thirty minutes. When the queue turns out to be a stuck filter and drains in fifteen, downgrade with a smile. Insurance paid, nothing lost.


6. The eight-person branch office is fully offline; HQ is fine. Total outage for them, invisible to everyone else. The grid: critical function, one site — SEV-2. Prompt response, honest updates to the branch, no company-wide broadcast. But criticality is contextual. If that branch is the warehouse and today is shipping-deadline day, the function tier — and the level — move up. The grid gives the default; context is allowed to overrule it, out loud, in the thread.


The policy on one page


Everything above compresses to a card. Copy it, adapt the examples to your own network, and pin it where incidents start:


LevelMeansRespondTellReview
SEV-1Critical function out for everyone, or data at riskEveryone, now, even at nightWhole company in minutes; updates every 30 minFull review
SEV-2Critical function out for a team/site, or degraded for allOne responder within the hourAffected people; hourly or milestone updatesMini-review
SEV-3Minor or single-user, workaround existsVia the queueThe requesterTicket notes

  • The responder classifies — provisionally, alone, immediately. No committees.
  • Torn between two levels? Up, for thirty minutes, then reassess.
  • Sev-up brings help; downgrades are announced, not mumbled.
  • Any data risk is SEV-1 from anywhere in the grid.

Where to go next


At 2:14 a.m. the swarm of questions will still arrive: wake someone, tell everyone, work it now, warn the boss. The difference is that you will have one answer for all of them, agreed in daylight and written on a card. Call the level, write it in the thread, and let the contract do the deciding. The model will be wrong sometimes, which is what the thirty-minute timer and the review question are for. It will still be right far more often than a tired person guessing at the worst possible hour. (The worst possible hour is always the one you are in.)


Severity is the hinge between detection and response. The label you call in minute four of the first fifteen minutes decides the cadence of every update you send. It also decides how many hands the response structure needs. Write the model down this week — the one-pager above is most of the work — and let the next incident test it. The rest of the discipline lives in Incident Response.


Put this into practice with SysPeep Monitor

A severity call is only as good as the evidence in front of you, and scope is the hard half. SysPeep Monitor shows the blast radius on a live dashboard. It shows what is down, what is degraded, and what is merely downstream of the real problem thanks to dependency rules. So the human classification moment starts with facts instead of guesses. Try it free on any Windows machine.

Download Free TrialLearn About SysPeep