Severity Vs Priority

In this post, we see the difference between Severity and Priority. Severity and priority are the two things we have to choose once the bug is found. Whenever we find a bug, we select the bug severity and bug priority. Usually, Testers select the severity of the bug and the Project Manager or Project Lead selects the bug priority. Let’s see bug severity and bug priority in detail.

Severity and Priority Infographic:

What is Severity?

Bug/Defect severity can be defined as the impact of the bug on the application. It can be Critical, Major or Minor. In simple words, how much effect will be there on the system because of a particular defect

What are the types of Severity?

Severity can be categorized into three types:

As mentioned above the type of severity are categorized as Critical, Major, and Minor

Let’s see how can we segregate a bug into these types:

Critical:

A critical severity issue is an issue where a large piece of functionality or major system component is completely broken and there is no workaround to move further. For example, Due to a bug in one module, we cannot test the other modules because that blocker bug has blocked the other modules. Bugs which affects the customers business are considered as critical

Major:

A major severity issue is an issue where a large piece of functionality or major system component is completely broken and there is a workaround to move further.

Minor:

A minor severity issue is an issue that imposes some loss of functionality, but for which there is an acceptable & easily reproducible workaround.

For example, font family or font size or color or spelling issue

Trivial:

A trivial severity defect is a defect which is related to the enhancement of the system

What is Priority?

Defect priority can be defined as an impact of the bug on the customers business. Main focus on how soon the defect should be fixed. It gives the order in which a defect should be resolved. Developers decide which defect they should take up next based on the priority. It can be High, Medium or Low.

Most of the times the priority status is set based on the customer requirement.

What are the types of Priority?

Priority can be categorized into three types:

As mentioned above the type of severity are categorized as High, Medium, and Low

Let’s see how can we segregate a bug into these types:

High:

A high priority issue is an issue which has a high impact on the customers business or an issue which affects the system severely and the system cannot be used until the issue was fixed. These kinds of issues must be fixed immediately. Most of the cases as per the user perspective, the priority of the issue is set to high priority even though the severity of the issue is minor.

Medium:

Issues which can be released in the next build comes under medium priority. Such issues can be resolved along with other development activities.

Low:

An issue which has no impact on the customer business comes under low priority.

Some important scenarios which are asked in the interviews on Severity and Priority:

High Priority & High Severity:

A critical issue where a large piece of functionality or major system component is completely broken. For example, 1. Submit button is not working on a login page and customers are unable to login to the application 2. On a bank website, an error message pops up when a customer clicks on transfer money button. 3. Application throws an error 500 response when a user tries to do some action. 500 Status Codes: The server has problems in processing the request and these are mainly server errors and not with the request.

These kinds of showstoppers come under High Priority and High Severity. There won’t be any workaround and the user can’t do the further process.

Low Priority & High Severity:

An issue which won’t affects customers business but it has a big impact in terms of functionality. For example, 1. Crash in some functionality which is going to deliver after couple of releases 2. There is a crash in an application whenever a user enters 4 digits in the age field which accepts max 3 digits.

High Priority & Low Severity:

A minor issue that imposes some loss of functionality, but for which there is an acceptable & easily reproducible workaround. Testing can proceed without interruption but it affects customers reputation.

For example, 1. Spelling mistake of a company name on the homepage 2. Company logo or tagline issues

It is important to fix the issue as soon as possible, although it may not cause a lot of damage.

Low Priority & Low Severity:

A minor issue that imposes some loss of functionality, but for which there is an acceptable & easily reproducible workaround. Testing can proceed without interruption. For example, 1. FAQ page takes a long time to load. 2. Font family or font size or color or spelling issue in the application or reports (Spelling mistake of company name on the home page won’t come under this Low Priority and Low Severity)

These kinds of issues won’t bother the customers much.

Some more points:

1. Development team takes up the high priority defects first rather than of high severity.

2. Generally, severity is assigned by Tester / Test Lead & priority is assigned by Developer/Team Lead/Project Lead.

Final Words:

The above are just examples. Selection of severity and priority may vary depends on project and organization. In Gmail, composing an email is main functionality, whereas composing an email feature in a banking (email option to send emails internally) application is not the main functionality.