Topic 27

Severity vs Priority + the Bug Lifecycle

Bugs

Two questions decide every bug's fate: how bad is it, and how soon should someone fix it? They sound like one question — and they are not, which is why "severity versus priority" is the most reliably asked trap in junior QA interviews. A typo in the company name on the homepage is trivially severe and urgently prioritized. Get that example into your head and the trap never catches you again; this page makes sure of it, then walks the full journey a bug travels from filed to closed.

Severity: How Bad, Technically

Severity measures technical impact: what breaks, how completely, for how many users. Typical scale: blocker (nothing works — checkout is down), critical (a core function fails with no workaround — payments fail for one card type), major (significant function wrong, workaround exists — FW-312's shifted dates), minor (small function wrong — a fee displays with the wrong rounding), trivial (cosmetic — misaligned icon). Severity is judged from the failure itself, which is why it's usually the tester's call: you saw the evidence, you know what breaks. It goes on the report at filing time.

Priority: How Soon, for the Business

Priority measures urgency: fix now, fix this sprint, fix someday. And it's a business judgment — what does this bug cost us per day, who's affected, what does the release calendar look like, what would customers see? That's why priority is usually product's call — Petra's, at Fernway — informed by your severity and evidence. The hospital ER runs on exactly this split: severity is the diagnosis (how sick is this patient), priority is the triage order (who gets seen first) — and a famous patient with a scratch may be seen quickly while the diagnosis stays "scratch."

The Four Corners

Severity and priority usually travel together — but the corners where they split are where the understanding lives, and interviews aim exactly there:

The 2×2 — one example living in each corner
High / High
checkout down — fix now, all hands
High sev / Low pri
crash in a feature scheduled for deletion
Low sev / High pri
the homepage typo — trivial and urgent
Low / Low
misaligned icon in admin — someday, maybe

The Lifecycle: a Bug's Journey

From filing to closure, a bug moves through states — and yes, this is Chapter 4's state diagram applied to your own artifact; forbidden transitions included. The main road: new (filed, awaiting triage) → triaged (severity checked, priority assigned, owner picked) → in progress (a developer is on it) → fixed (the developer believes it's done — note the word believes) → verified (QA re-tested the fix on a build that contains it — Chapter 3's re-testing, now a lifecycle gate) → closed. The loop road: reopened — verification failed, or the bug returned; it happens, it's normal, the state exists so nobody pretends otherwise.

And the exits that don't pass through "fixed": duplicate (already reported — closed with a link to the original), cannot reproduce (the steps don't produce the failure for anyone else — sometimes an environment difference, sometimes a report problem, occasionally a genuinely vanished bug), and won't fix (real, understood, and deliberately not worth fixing). Each exit is legitimate when it's a decision — and each is a failure mode when it's a dodge, which is why the next topic's tracker hygiene matters.

The Gate QA Owns

Look at the lifecycle again and notice which transition belongs to you: fixed → verified. Nobody closes a bug except the person who can re-run the failing scenario — not the developer who believes it's fixed (belief is not evidence; that's why the state is called "fixed," not "gone"), not a manager tidying the board. This is the one gate QA owns outright, and it's the daily bread of the verification queue: every morning, a handful of "fixed" bugs waiting for your re-test, each one either graduating to verified or bouncing to reopened with your evidence attached. Guard the gate politely and absolutely.

Disagreeing Like a Professional: FW-341's Priority

The split of powers — you propose severity, product decides priority — will eventually produce a decision you disagree with, and how you handle it is a career skill. Live case: FW-341, the zero-guest booking. You file it severity major — a booking with no guests charges real money and corrupts the books. Petra prioritizes it low: she checks the data, and no real traveler has ever booked zero guests; the validation fix ships next sprint with other form work. You disagree — quietly convinced it's a money bug waiting for a bored teenager. The professional move: state your case once, with data ("the API also accepts it, so the UI fix alone won't close the hole — see FW-341's comments"), get the decision on record, and commit to it. Priority is Petra's call; making sure it's an informed call is yours. You'll be right sometimes, wrong sometimes; the record keeps everyone honest either way.

Common Confusions
  • "Severity and priority always move together." The corners exist and interviews love them: the deleted-feature crash (high sev, low pri) and the homepage typo (low sev, high pri) are the canonical counterexamples. Memorize both.
  • "QA sets priority." QA proposes severity and informs the priority call with evidence; product makes it. Recommending is your job; deciding isn't — and the boundary is what keeps triage from becoming a turf war.
  • "Closed means fixed." Duplicate, cannot-reproduce, and won't-fix are also closures — legitimate ones, when they're decisions. Verified-fixed is the only ending QA certifies with a re-test.
  • "The developer closes the bug when the fix is done." The developer moves it to fixed — a belief. Verification — re-running the failing scenario on the right build — is QA's gate, and nothing closes without passing it.
Why It Matters
  • "Severity versus priority, with examples" is the single most reliably asked junior QA interview question — the 2×2's corners are the complete answer.
  • Knowing who owns which decision (severity: you; priority: product) prevents the most common workplace friction a new tester walks into.
  • The verification gate is QA's daily structural power: fixes don't count until you've re-tested them, which makes your morning queue the team's quality checkpoint.

Knowledge Check

The homepage spells the company name "Farnway." Classify it.

  • High severity, high priority
  • Low severity, high priority
  • Low severity, low priority
  • High severity, low priority

Who typically decides a bug's priority, and why?

  • The tester, because they found and understand the bug
  • Product, because priority weighs business cost and the release calendar
  • The developer, because they know how hard the fix is
  • Nobody — priority is computed automatically from severity

A developer marks FW-329 "fixed." What has to happen before it's closed?

  • Nothing — fixed means the bug is resolved
  • QA re-tests the failing scenario on a build with the fix and verifies it
  • A manager reviews the board and closes completed items weekly
  • Two weeks pass without the bug being seen again

Petra sets a priority you're convinced is wrong. What does a professional do?

  • Accept it silently — priority isn't your business
  • Re-raise the disagreement at every standup until it's fixed
  • Raise the bug's severity so the priority has to follow
  • State your case once with data, get the decision on record, and commit to it

You got correct