Severity and Priority of Bugs

Severity of Bugs:

Severity of the bugs is classified depending upon the impact of error on the application / system. The severity classification is as follows:

·     Critical:

The error is classified as Critical severity bug when

¨     the core functionality of the application / system has an error

¨     the error is causing the whole system to fail

Unless this error is resolved the application will not be available to public. Mostly resolution of a critical bug is given priority above all other bugs.

For example: In a banking application, the account does not increment the balance after a deposit is made.

·     High: 

The error is classified as High severity bug when

¨     the error which does not cause failure of the system but hinders the system from working correctly

¨     the error can cause the application to give incorrect or incomplete results.

For example: An application which does not allow the user to change the password.

·     Medium: 

The error is classified as Medium severity bug when

¨     the error which create random failures or do not work exactly per the requirement is classified as Medium severity bugs.

For example: A banking application that does not display history of transactions later than 3 months old.

·     Low: 

The error is classified as Medium severity bug when

¨     the error in the application which does not affect the core functionality

¨     the error is some part of the application not conforming the requirement standard, for e.g. field color.

For example:  A college website form has the first field as Surname instead of Name.

Priority of Bugs

The Priority of the bug is classified per the importance of resolving the error. The priority classification is as follows:

·     Immediate The bug should be resolved immediately. For example – Core functionality working erroneously, incorrect logo of the company.

·     High The bug should be resolved as soon as possible in the normal course of development activity, before the software is released.

·     Medium The bug should be repaired after serious bugs have been fixed.

·     Low The bug can be resolved in a future major system revision or not be resolved at all.

Some companies / clients consider only severity of the bug as a criterion while raising bugs. Mostly the developers resolve the bugs according the highest severity first.

However, severity may not always be a factor considered while resolving a bug.  For example, if the logo in the application is displayed incorrectly, it may have LOW severity but the developers will tend to resolve it first because in case the application goes live to public with this error unresolved there can be greater issues. Here the priority of this bug will be high.

Consideration of both Severity and Priority of the bug makes it easier for the developer and the tester to track, discuss, report, resolve and test the error.

Bugs are reported by the testers per the Severity of the error and the bugs are resolved by the developers per the Priority of the error.

Each company / client may have their own way of classification of the severity and priority of the bugs but broadly the classification is the same as given above.

Sr No	Severity	Priority
1.	Technical based	Importance / Urgency based
2.	Most critical severity has high technical complexity	Most high priority has greatest urgency

                                       Find us on facebook: facebook.com/softwaretestingbykunti