Software testing severity and priority

Tram Ho

1. Concepts

Bug severity – the severity of the bug

The severity of the bug is the extent to which the bug affects the software we test. The higher the effect of the bug will lead to a higher severity. The QA should regularly determine the severity of the defect.

Priority – Priority

Priority is defined as the order of when a bug should be fixed. The higher the priority, the earlier it should be resolved. Errors that cause unusable software to take precedence over a small faulty function.

2. Classification

In software testing, error severity is divided into 4 categories:

  • Critical: This error indicates that the operation of the system has been stopped, it should be handled immediately.
  • Major: This is a bug that can partially shut down the system, but some other functions still work normally.
  • Medium: causes undesirable behavior but the system still works.
  • Low: a small error, does not affect any functions of the system.

Error precedence is usually divided into three categories:

  • High: Error must be fixed as soon as possible because it seriously affects the system and cannot be used until the fix is ​​complete.
  • Medium: Error needs to be addressed. We can test other parts until the new version of the bug is built.
  • Low: It’s annoying, can be fixed when another more serious bug gets fixed.

3. Tips for determining bug severity

  • Occurrence frequency: in some cases, if a minor error occurs frequently it can be more serious. So, from the perspective of the viewer, it becomes more serious, albeit only a minor error.
  • Isolation of bugs: Isolating the error can help us find the magnitude of the error => its severity.

4. Difference between Priority and Severity

Determine the order in which the developer needs to solveDetermine the impact level of the error on the software
Related to planningConcerning standards and other functions
Priority indicates how early a bug should be fixedSeverity indicates the severity of the defect on the product functionality
Priority is decided in consultation with a manager / clientQA determines the severity of the bug
Priority is determined by the businessSeverity is determined by function
May change over a period of time depending on the project situationLess likely to change
When UAT, the development team will fix the errors based on priorityDuring the SIT process, the development team fixes the bug based on more severity and then priority

5. Error severity and priority example

Below are examples of low severity, high priority, and vice versa:

  • Low severity, high priority: The logo of a website is wrong, maybe of low severity because it does not affect other functions but may have a high priority because the wrong logo affects reputation. corporate credit.
  • High severity, low priority: Example error in a game with many levels. Currently level 5 is having a crash, can not play. This is a very serious error but has a lower priority. Because we want to get to level 5, we must pass level 1,2,3,4, so errors at level 1,2,3,4 have a higher priority.

6. Defect triage (error test)

Failure testing is a process to try to rebalance the process in which the testing team is faced with limited human resources. Large number of errors, limited human resources, the error classification will help us solve them faster. Processing includes the following steps:

  • Look at all bugs including rejects
  • An initial assessment of the error is based on its content and sets its priority and severity respectively
  • Prioritize errors based on inputs
  • Specifies errors that need to be fixed for an exact release by the product manager
  • Assign the bug back to owner / group for execution

7. Suggest that the tester should consider before choosing the severity

The severity is evaluated by the tester while the priority is evaluated by the product manager or the classification team. For prioritization, it is imperative that testers choose the correct severity.

  • Understand the concept of priority and severity
  • Always assign severity based on bug type as this will affect its priority
  • Understanding specific scenarios or testcases will affect the end user
  • Consider how much time it takes to correct errors based on complexity and time to verify the error.


In software engineering, defining false severity can slow down the software development process and reduce the overall performance of the team. Therefore, the responsible person needs to accurately determine the severity and priority of the defect.

Translated and supplemented article:

Share the news now

Source : Viblo