A spelling mistake in the company name on a bank’s login page hurts nobody’s money. A crash in the year-end interest calculation that runs once a year, on a branch nobody will touch for eleven months, could cost crores. Which one should be fixed first? If you answered instantly, you have probably mixed up two separate questions that defect tracking keeps apart on purpose: how bad is the damage, and how soon do we need to act.

Two fields, two owners

Severity describes the impact of a defect on the system or the user if it occurs. It is a technical judgement: does the application crash, lose data, compute a wrong amount, block a workflow, or just look untidy? Testers usually set severity because they have seen the failure and understand what it does.

Priority describes the order in which defects should be fixed. It is a business judgement that weighs severity against things the tester may not know: release dates, which customers use the feature, contractual penalties, regulatory deadlines, marketing launches and how many developers are free. Product owners or project managers usually own priority, often in a triage meeting.

The ISTQB glossary draws the same line: severity is the degree of impact a defect has on the development or operation of a component or system, and priority is the level of business importance assigned to an item. Tools such as Jira let teams configure both fields, but many teams use only one and then argue about what it means.

The four combinations, with realistic examples

Because the two dimensions are independent, every combination happens in practice. Picture an Indian online grocery app preparing for a festive sale.

CombinationExampleWhy it lands there
High severity, high priorityUPI payments fail for all users at checkoutCore flow broken, revenue lost every minute
High severity, low priorityApp crashes when a user sets the language to an option enabled only in an internal buildCrash is serious, but no real customer can reach it yet
Low severity, high prioritySale banner shows “Diwali Sael” on the home screenNothing breaks, but millions will see it and the brand looks careless
Low severity, low priorityTooltip on the order history page is misaligned by a few pixels on one tablet modelCosmetic, rarely seen

The low severity, high priority quadrant surprises newcomers most. The typo does not affect functionality at all, yet it may be fixed before a genuine crash because of who will see it and when. The high severity, low priority quadrant is the opposite trap: a crash sounds alarming, but if the path is unreachable in production, the team can schedule it calmly.

Typical scales and what each level should mean

There is no universal standard for the labels. Many organisations use four or five severity levels, such as Blocker, Critical, Major, Minor and Trivial, and a priority scale such as P1 to P4. What matters is that every level has a written definition the whole team agrees on. A usable severity guide might read:

  • Blocker: testing or usage cannot continue; no workaround. Example: login fails for every user.
  • Critical: a major function fails or data is corrupted or lost. Example: an invoice saves with the wrong GST amount.
  • Major: a function misbehaves but a reasonable workaround exists. Example: export to Excel fails, but the CSV export works.
  • Minor: small functional or usability issue. Example: a filter resets when the user goes back.
  • Trivial: cosmetic issue with no functional effect.

Without definitions like these, severity drifts towards whoever shouts loudest. Testers who want attention mark everything Critical; developers who are overloaded downgrade everything to Minor. Written criteria turn an emotional debate into a quick lookup.

What happens in a triage meeting

Triage borrows its name from emergency medicine, where patients are sorted by urgency rather than arrival order. Defect triage does the same for the backlog of new bugs. In a typical Indian services setup, the meeting might happen daily during system testing and twice a week otherwise, often timed for the overlap between IST and the client’s time zone.

Participants usually include a test lead, a development lead, the product owner or business analyst, and sometimes a release or project manager. For each new defect the group answers a short sequence of questions:

  1. Is this a genuine defect, a duplicate, a requirement gap, a test data problem or working as designed?
  2. Is the report complete enough to act on, or does it need logs, steps or screenshots first?
  3. Is the severity correctly stated against the agreed definitions?
  4. Given the release plan, what priority does it get, and which release or sprint should carry the fix?
  5. Who owns it?

A good triage meeting is fast. If one defect takes fifteen minutes of debate, it is usually because the expected behaviour was never agreed, and that discussion belongs with the product owner separately. Triage also produces useful signals: a spike in “working as designed” outcomes suggests testers are not getting requirements clearly, while many “cannot reproduce” outcomes point to weak bug reports or unstable environments.

Where teams go wrong

Using one field for both meanings. If a team records only “priority”, testers start inflating it to signal impact, and the business loses its ability to rank work. Keep both fields, or at least be explicit that a single field is a business ranking.

Treating severity as fixed forever. Severity is about impact, and impact can change when facts change. A crash thought to affect one rare device may turn out to hit a popular budget Android model sold widely in India. Update the field when new information arrives, and note why.

Ignoring priority drift. A P3 issue in a reporting screen becomes urgent when the client announces that the report will be used in an audit next week. Priority is meant to move; reviewing open defects before each release catches these shifts.

Letting the release gate depend on counts alone. “Zero open Critical defects” is a sensible exit criterion, but it invites quiet downgrading near a deadline. Pair it with a review of every defect downgraded in the last week, so any change in severity is visible and justified.

A quick way to reason about any new bug

When you log a defect, ask yourself two questions in order. First, if a real user hit this, what would actually happen to them or their data? That gives you severity, and you should be able to defend it with the team’s definitions. Second, leave room for the people who know the release calendar and customer commitments to rank it, but give them what they need to decide: how many users could reach this path, whether there is a workaround, and whether any money, compliance or security exposure is involved. A defect report that answers those points makes priority almost obvious, and it is the main reason good triage meetings finish on time.

Written by the RP Strativa Team. The app, scenarios and labels in the examples are illustrative.

Leave a Reply

Trending