Abstract 3D paths representing refactoring and rewriting
Application Refactoring: When to Refactor and When to Rewrite
iOS and Android Compared: Platform Choices for 2026

Most triage advice says to score a bug's severity and then work the most severe item first. One field, one sorted list, no arguments. That model survives until the morning a crash report lands from a browser almost nobody uses and, twenty minutes later, a pricing typo goes live on the page a paid campaign points at. The crash tops the list because it's a crash. The typo waits.

Severity measures how badly the system or users are harmed. Priority sets the order in which the team works. Those are two different questions, answered by different people, from different information, and on different clocks. Treating them as one field is the most common reason a backlog looks disciplined while the wrong things ship broken.

The split isn't a glossary nicety. It's what decides whether a support engineer gets pulled off a call, whether a release gets held, and whether the incident review asks why nobody looked at the thing that cost money. Priority vs severity becomes a practical problem the moment you have more incidents than capacity, which is most weeks.

What follows is how the two fields split in real triage, how to re-check both as facts change, and how to score your labels afterwards against the harm that was confirmed. The charts and tables are built to be lifted into your own runbook.

Table of Contents

Severity and Priority Side by Side

The one-line answer: severity measures how badly the system or users are harmed, while priority sets the order in which the team works.

Severity is largely a property of the defect. Priority is a property of the team's decision, and it can move without the defect changing at all.

Criterion Severity Priority
Question answered How bad is the impact? What gets worked on first?
What it measures Size of the failure and who it hits Order of response and fix
Usually set by QA, support or the reporter, from observed impact Triage owner or incident lead, using context
When it changes When impact is confirmed or reduced When deadlines, workarounds or capacity change
Example Crash for one user on a rare browser: high Typo on a launch-day pricing banner: high

A comparison table contrasting severity as system impact with priority as team workflow sequencing.

A checkout page makes the split easy to see. A crash that hits one user on a browser you barely support is high severity, low priority: the defect is real, the blast radius is small, and the fix costs a day of debugging a rendering path nobody else walks. A typo in the pricing banner on launch morning is low severity, high priority: the system works perfectly, and every visitor sees the wrong number on the day you're paying for traffic.

Run the same defect through both fields and you get two answers that don't contradict each other. The crash is a serious failure. The typo is an urgent piece of work. Neither field overrides the other, which is exactly why one field isn't enough.

Practical rule: if your tracker has one field, you'll keep finding team members who quietly repurpose severity to mean urgency. Two fields, both visible on the ticket, ends that argument.

Where teams go wrong is the assumption that the two should track each other. They don't, and a triage process that forces them into alignment teaches people to inflate severity whenever something feels urgent, which corrodes the only field that describes actual harm.

Define both fields in writing before the next incident, with one example per level. A definition nobody wrote down is a definition that changes depending on who's in the room.

How Severity Is Scored from Real Impact

A severity scale is only useful if a new engineer can apply it at 2am without asking anyone. Start with the three-level scale Atlassian publishes in its incident handbook, which pairs each level with an example and a response pattern.

Severity Definition Example Normal response
SEV 1 Critical, very high impact Service unavailable to all customers, privacy breach, or customer data loss Immediate response with continuous 24/7 management
SEV 2 Major, affects a subset of customers or impairs core functionality Core feature broken for a segment of customers Immediate response with continuous 24/7 management
SEV 3 Minor, low-impact inconvenience Workaround available or usable but degraded performance Handled by the responsible team during business hours

Notice what the definitions measure: availability, data, privacy, and the share of customers affected. Nothing in them mentions deadlines, contract value or who escalated fastest. That's the point.

Turning impact into a number

Prose definitions drift. Percentages don't. Google's SRE guidance on product-focused reliability works severity from measured feature impact, using a mail service as the example. A major incident includes any impact on sending or receiving mail, or more than 20% impact on core features. A medium incident covers more than 5% impact on core features or more than 20% impact on auxiliary features. A minor incident is any impact above 0% on any feature.

Read as bands, that gives you a chart you can pin next to the on-call laptop:

Core-feature impact Chart Band
0 to 5% ██░░░░░░░░ Below medium; minor if above 0%
Above 5% to 20% ██████░░░░ Medium
Above 20% ██████████ Major

Headcount-based scales do the same job for customer-facing products. Atlassian's developer incident severity levels set the lowest user band at 1,000 to 100,000 affected users or 3 to 10 affected apps, the middle band at 100,001 to 5,000,000 users, and the top band above 5,000,000 users, escalating also on report volume from more than 2 reports up to more than 15.

The procedure, then the self-check

Count the affected features and users, compare the count against the thresholds, then pick the level. Before you apply Google's major, medium and minor labels, agree a mapping rule onto your own SEV 1, SEV 2 and SEV 3, so every incident is scored on one scale instead of two vocabularies fighting in the same channel.

The self-check before you commit a level: can you name the feature, the percentage and the user group behind it? If not, you're guessing, and the honest label is "unconfirmed" with a time to re-check.

When a scale needs more formal treatment, a structured risk method adds detection and occurrence to the impact score. The FMEA risk ranking guide for engineers explains how risk priority numbers combine those factors. Separately, the impact data behind a severity call only exists if reports capture it, which is why a QA checklist built around reproducible evidence saves hours of triage guesswork.

How Priority Is Set After Impact Is Known

Emergency medicine settled this argument before software existed. In disaster response, severity describes the seriousness of a patient's condition, while priority determines the order in which limited resources are allocated. The distinction became operational with the Simple Triage and Rapid Treatment (START) system, created in 1983 by the Newport Beach Fire and Marine Department and Hoag Hospital in California. START sorts patients into four categories: red for immediate treatment, yellow for delayed, green for minor injuries, and black for deceased or expectant patients.

The Cambridge review of START triage accuracy makes the logic explicit: the system doesn't rank injuries by severity, it converts observations into an action sequence. A severe injury can receive a lower treatment priority when survival is unlikely with the resources on hand, while a seriously injured patient with a good chance of survival goes first. Responders start by identifying who can walk, then assess the rest on breathing, respiratory rate, circulation and mental status.

That's not callousness. It's arithmetic under constraint, and incident response runs the same arithmetic.

The factors that move work up or down

Factor Question to ask Raises priority when
Urgency and time sensitivity Is the damage still growing or is a deadline closing? Data loss or a contractual deadline is hours away
Users and customers affected How many people and which accounts are hit? A key account or a large user segment is affected
Regulatory or safety exposure Does the defect break a legal, privacy or safety requirement? A compliance deadline or patient-facing workflow is involved
Mitigation available Is there a tested workaround? No workaround exists or the workaround is failing
Launch or revenue timing Does the defect touch a launch, billing or sales event? It lands on a campaign or payment flow during the event
Team capacity and ownership Is an owner available to act now? The only owner is unavailable and the window is short

Two rows do most of the work in practice. A tested workaround can hold a high-severity defect at medium priority for weeks. A payment issue during a flash sale can pull a low-severity defect to the top of the queue within an hour.

The response windows you promised in your service level agreement also belong here. They're a priority input, not a separate document living in a sales folder.

Priority isn't a label you set once at intake. It's a decision you re-make every time the facts move.

Which is why the same defect can climb or fall without its severity changing by a single level. A workaround that fails at 4pm changes the priority. The defect didn't.

The Triage Matrix for Severity and Priority

Two fields only pay off when they combine into an action. Here's the decision grid, with severity in rows and priority in columns.

Severity Lower priority Higher priority
SEV 1 Amber. Schedule a dated fix while the mitigation holds Red. Stop current work and start response now
SEV 2 Cool. Plan the fix in the next release cycle Hot. Respond immediately and track to resolution
SEV 3 Cool. Place in the backlog for normal planning Amber. Make a small, targeted change before the deadline or launch

The logic is short. A SEV 1 with high priority means the response starts now and other work stops. A SEV 1 with lower priority usually means someone found a mitigation that holds, so the fix gets a date and an owner rather than an immediate fire drill. A SEV 3 with high priority is the launch-morning typo: small, targeted, and time-boxed. A SEV 3 with low priority is backlog work and shouldn't get a meeting.

The two cells teams misjudge

The first is the stable outage whose remediation window is closing. Stabilised doesn't mean finished, and if the fix path closes at midnight, the work is urgent even while the graph looks flat.

The second is the minor rendering bug on a feature with a launch deadline. Teams routinely let a severe fault in an unused module outrank it because the severity number is bigger, then ship a visible flaw into a campaign.

Practical rule: rank by the column first when a deadline is inside the week. Rank by the row first when nothing time-bound is competing.

Where you draw the line between levels is a judgement, not a discovery. A 2024 study of 990 people in England and Wales, published by the Office of Health Economics, found the public judged health conditions severe at roughly 50% proportional shortfall, against NICE's 85% threshold, and very severe at about 65% against 95%. Same word, different line, different consequences. Your organisation will have its own version of that gap between what the team calls severe and what the business does.

Treat the grid as a starting point the team adapts with its own thresholds, not a substitute for judgement under incomplete facts.

Worked Examples Where Severity and Priority Split

Three cases, each with a clear answer in both fields.

The export crash. A data export tool crashes for two enterprise customers, and a manual workaround exists: support runs the export server-side and emails the file. Severity is high for those users, because their work stops without the file. Priority is medium while the workaround holds, with a dated fix on the board. If the workaround breaks, priority jumps the same day and severity doesn't move.

The launch-week label. A sign-up page has a misaligned field label the week a campaign drives paid traffic to it. Severity is low, the form submits correctly. Priority is high, because every new visitor sees it and the campaign has a budget attached to first impressions. This is a two-hour fix that gets scheduled ahead of a week-long architectural ticket.

The report that's slow for one client. A reporting job takes minutes longer than the contract promises, and that client's renewal review is tomorrow. Severity is moderate. Priority is high for exactly one day, then it drops back the moment the meeting ends.

Colleagues collaborating at an office desk while viewing data analytics and ticket metrics on computer monitors.

Why first labels go wrong

Human triage is systematically noisy. A review of pediatric emergency triage, described in the Emergency Severity Index material published by the US government, reported over-triage rates of 40% to 54% and under-triage rates of 12% to 15%. Over-triage spends scarce capacity on cases that prove less urgent. Under-triage gives a serious case too little urgency, which is the failure that hurts people.

Software shows the same distribution. A defect can be technically severe and low priority when it hits a rarely used, noncritical function with a workaround. A moderately severe fault becomes top priority when it touches many customers, a regulated workflow, revenue operations or a time-sensitive business event.

The noisiest input is the reporter. A study of patient-safety event prioritisation in JMIR Medical Informatics reported that a ranking model retrieved 83% of high-severity events within the top 200 cases, against 41% for reporter-assigned severity. Reporter labels are a starting signal, not ground truth.

Treat the first label as a hypothesis. Re-check it at each change of facts, and score it afterwards against the harm that was confirmed.

Assigning Severity and Priority in Your Workflow

Six steps, in order. Each one has a reason and a familiar way to get it wrong.

  1. Record observed impact first. Name the affected feature, the share of users, any data loss or security exposure, and measure it against your scale. The reason is simple: impact is the only input severity is allowed to use. The common slip is writing a symptom ("page is broken") instead of an impact ("checkout returns 500 for card payments, roughly a fifth of sessions").

  2. Assign severity inside the first minutes, even when you're unsure. A provisional level with a confidence note beats a blank field, because responders need something to work against. The slip is waiting for certainty and leaving the field empty while the clock runs.

  3. Add the priority factors. Deadline, regulatory exposure, mitigation status, launch timing, capacity. Atlassian's incident management guidance is blunt about why this step exists: high severity doesn't automatically put an incident at the top of the priority list, and high priority doesn't always mean the system is down. The slip is skipping this step and letting the severity number decide everything.

  4. Set priority, name one owner, state the response window. One name, not a team alias. The slip is downgrading priority to make a real severity look less alarming, which hides the risk instead of scheduling it.

  5. Re-check both fields at every status change, and whenever a workaround fails or new users report the issue. The two-stage model proves its value at those moments. The slip is setting labels at intake and never revisiting them, so a mitigation that broke at noon is still being trusted at six.

  6. Review after closure. Ask whether the labels predicted the actual impact, then change the rule that missed. The slip is closing the ticket without that question, which guarantees the same misclassification next quarter.

A five-step workflow diagram illustrating how to assign severity and priority in project management processes.

Handling incomplete data and competing demands

Blast-radius numbers are usually wrong in the first ten minutes. Score severity on the confirmed portion, record low confidence, and set a time for the next check. Research on IT-service priority optimisation identifies urgency, impact, reassignment count and resolution time as influential predictors, as set out in this analysis of IT service priority, which is a formal way of saying priority is a live operational decision rather than a synonym for severity. A calibration exercise makes that testable: have responders classify a batch of historical incidents using only what was known in the first five minutes, then measure how much they disagree.

When stakeholders push conflicting demands, the incident lead records each request and decides on the priority factors, not on who asks loudest. A lightweight reporting cadence keeps both fields and their progress visible to everyone without slowing the responders down. We use exactly that: a lightweight reporting cadence that keeps progress visible without getting in the team's way.

For the wider process around these steps, the guide to the incident management process covers escalation paths and post-incident review structure.

Confirm Your Triage Rules Before the Next Incident

The decision to make now is to adopt a two-field triage rule before the next incident, not during it. Put these items in the issue tracker as short, checkable lines:

  • Severity definitions with one real example per level, named by feature and user group.
  • The priority factors the team agreed on, written down rather than remembered.
  • The matrix pinned where responders look first, not buried three folders deep.
  • A named owner for every SEV 1 and SEV 2, with the response window attached to the level.
  • An explicit rule that priority can change while severity stays put, with both fields re-checked at every status change.
  • A post-incident review question that asks whether the labels matched the confirmed harm, and which rule changes if they didn't.

A checklist for establishing incident triage rules, emphasizing severity, priority, and team training for effective management.

Teams with thin on-call coverage should settle who owns the matrix and who runs the review before an incident forces the question, because labels nobody owns are the ones that drift. Our Support & Maintenance service takes over a client's support and maintenance operations so the client's core team can keep focus on product innovation, and the first thing that gets fixed in that handover is usually exactly this: one severity scale, one priority rule, one owner.

This week, write the definitions and examples for your three most common incident types. Then run the checklist against your last five incidents and mark where the labels would have changed. That gap is the size of the problem.


Every queue that holds up under pressure has the same thing behind it: two fields, defined in advance, re-checked as facts move, and scored afterwards against real harm. devPulse builds that discipline into the systems and support operations it runs, from incident severity scales to SLA-backed response windows, and modernizes legacy platforms incrementally so the high-impact areas get fixed first. If your triage rules are still one field wide, visit devPulse and start with the conversation about what your team needs to sort first.

✕

Clarity starts with the right conversation

    By clicking "Send A Message", You agree to devPulse's Terms of Use and Cookie Policy. 

    Get In Touch

    "

    We partner with ambitious teams to solve complex challenges and create meaningful impact. From early ideas to full-scale delivery — we’re here to support every step. Tell us what you’re working on, and we’ll help you define the best way forward.

    Anna Tukhtarova

    CTO & Co-Founder

    ✕

    Vlad Tukhtarov

    CEO & Co-founder

    Vlad Tukhtarov is a technology executive and entrepreneur with over 15 years of experience building complex digital products and leading engineering teams. He began his career as a macOS (OS X) developer, working deeply with system-level applications and gaining a strong foundation in performance, architecture, and user-focused engineering. This hands-on technical background continues to influence how Vlad approaches leadership today — combining deep engineering understanding with business and product thinking. 

    As CEO & Co-Founder at devPulse, Vlad focuses on helping companies turn ideas into scalable digital products. He works closely with clients to define product direction, align business goals with technology, and ensure that solutions are designed not just to function — but to grow. 

    Want to turn your idea into a scalable product?

    Work directly with an experienced technology leader to define the right path forward.

    ✕

    Anna Tukhtarov

    CEO & Co-founder

    Anna Tukhtarova is a Chief Technology Officer and system architect with over 15 years of experience designing and delivering complex, high-performance software systems. She began her career as a C++ developer, working on performance-critical and system-level applications where efficiency, reliability, and precision were essential. 

    Over time, Anna transitioned into Technical Lead and System Architect roles, where she focused on designing scalable architectures, solving complex technical challenges, and ensuring that systems could evolve reliably under real-world conditions. As CTO & Co-Founder at devPulse, Anna drives technological innovation, aligns engineering practices across teams, and ensures consistent delivery of scalable, high-quality, and cost-effective solutions. 

    Need a technical audit or solid architecture?  Work directly with an experienced system architect.

    ✕