5 Common Severity Levels of Software Bugs

5 Common Severity Levels of Software Bugs
March 10 10:00 2015  

Note: the article was updated in April 2019.

Have you ever wondered what is the average number of bugs detected during the process of software testing? According to surveys, the number of bugs in an average code varies from 0,5 to 25 per 1,000 lines of code. Other statistics show that 21% of all bugs reported in the process of software testing are fixed immediately. How to decide which of them require immediate fixing and which can wait for better days? Read the article to get a background for your decision.

Severity Levels of Software Bugs

Logged defects are characterized by several attributes in order to quickly make sense of them, determine to which aspect of the program they belong, know fixing of what defects is urgent, and which ones may be corrected later.

Among the most important software bugs attributes is severity. It can be of several types:

bug severity levels

Blocker is a type of bug that blocks further testing, e.g. app’s crash on a specific environment.

Critical error is connected with security and leads to the program crash, data loss or other serious damage. Such bugs disable app’s main functionality and are primarily fixed.

Major level of severity is assigned to a bug which affects other aspects of definite testing type and may influence subsequent checks. For example, in case of localization testing, these are non-displayed letters, systematic omissions of spaces, when the text goes beyond the screen bounds, the text is not translated, etc.

Minor error does not influence the process of testing or app’s basic functions. It happens when, for instance, the text does not fit in a separate bar, incorrect hyphenation, missing space in a particular place, etc.

Bugs of low severity level are generally found in the course of user interface testing. It may be the wrong size of a button, too bright color of an object and so on. Errors of this type have little impact on the program functioning.

Severity vs Priority: How they match

QA engineers often wonder what is the procedure of bug fixing and how developers decide what errors should be corrected first. Here the notion of priority arises. Bug-tracking tools such as Jira, define the following levels of bugs priority:

bug priority levels

These levels do not always coincide with the severity division. Bugs can be of:

  • high priority, blocker severity (e.g. page is not displaying);
  • medium priority, major severity (e.g. submission button does not work);
  • critical severity, high priority (e.g. log-in field is missing);
  • low severity, lowest priority (e.g. wrong color of the submission button).

The combinations of these two levels are not restricted to those mentioned above and can vary depending on the product specifics and workloads of employees engaged at the project. Effective organization of cooperation between developers, QA, and technical specialists is one of the ways to make the workflow transparent and avoid risks connected with the bugs assignment and prioritization.

Final Thoughts on Bug Severity Levels

The qualification of quality assurance specialists depends also on their skill of correct documentation processing which is a result of bugs analysis. It is a basic competence which is often taken for granted, though far not all testers are able to define the true level of error severity. This guide of basic notions will serve as a handbook for people who hold different positions in the IT sphere and need a clue on its basics.

Learn more from QATestLab

Related Posts:

About Article Author

view more articles
Nataliia Vasylyna
Nataliia Vasylyna

View More Articles

Related Articles