Software requirements prioritization techniques you should know
Tags: agilewebandappde, agilesoftwaredevel, programming, softwaredeveloper
Published: 2018-01-16 07:35:36

---
title: "Software requirements prioritization techniques you should know"
published: true
tags: Agile web and app de,agile software devel,programming,Software developer
canonical_url: https://apiumhub.com/tech-blog-barcelona/software-requirements-prioritization-techniques/
---

[Software development project](/software-projects-barcelona/) just like any other project has multiple requirements, budgetary constraints, and tight deadlines. Therefore, there is a need to do software requirements prioritization as it is just impossible to do everything at once. So, you need to make decisions on which set of requirements need to be implemented first and which ones can be delayed until a later release.

Normally, [agile project managers](https://apiumhub.com/tech-blog-barcelona/benefits-of-agile-project-management/)want to develop software which is both high-quality and high-value, and the easiest way to develop high-value software is to implement the highest priority requirements first. This enables them to maximize stakeholder ROI.

As normally requirements change frequently, you need a streamlined, flexible approach to requirements change management, for example product backlog ([Scrum](https://apiumhub.com/tech-blog-barcelona/scrum-sprint-explanation/)). So, in agile development, software requirements prioritization is considered a vital part of the project. And for example, to prioritize [user stories](https://apiumhub.com/tech-blog-barcelona/user-stories-affect-team-product/) we could use top 5 prioritization criteria, such as the value users place on product vision, urgency, time constraints, technical complexity, and stakeholder preferences.

Also, very often projects need to be properly prioritized for both the main project objectives and the specific tasks that will achieve the objectives. So we deal with the prioritization on two levels: product level and task level. Especially taking into account that customers normally tend not to understand that they can’t get all the features they want in release 1.0 of a new software product. Every single project should have priorities of the requested features, use cases, and functional requirements. Software requirements prioritization helps the project manager resolve conflicts, plan for staged deliveries, and make the necessary trade-off decisions.

One of the biggest differentiators between companies that thrive and those that fail is the ability to prioritize effectively, but software requirementrs prioritization is never easy. It often involves painful decisions and difficult trade-offs, and for early and expansion-stage companies, there is the added pressure of trying to accomplish a great deal with limited time and limited resources. In order to achieve growth, a team should be directed solely on the things that truly matter and are going to have maximum impact.

Software requirement prioritization is one of the biggest challenges a software team faces. Actually, [25% of tech leaders](https://codingsans.com/blog/prioritize-software-development-requirements) said prioritizing software development is their biggest challenge.   
 But according to Jeanne Ross and Peter Weill’s research for their book IT Governance, “Companies that manage their IT investments most successfully generate returns that are as much as 40% higher than those of their competitors.”

In general, companies should be sure that every team member isn’t just working on a list of tasks. They should have a clear understanding of the impact the task they’re working on has, seeing their direct contribution to the project. They also need to be clear about the purpose of the product, not only understanding the customer’s need but also the business’s value and goals.   
 There can be certain things like [backend architecture](https://apiumhub.com/web-development-barcelona/) that’s not visible for clients but for developers who can point to any architectural issues that could impact the product’s performance in the future. This is why it’s so important to make sure every engineer in the team understands the product backward and forwards.

Software requirements prioritization doesn’t have to be a constant source of pain. With the right method, it can empower your decision making and lead you to vastly improved results. Numerous methods and technologies on how to prioritize requirements have been developed as it is a very big issue for many teams and companies. Let’s look at the most popular and efficient ones:

&nbsp;

## Most popular software requirements prioritization techniques

&nbsp;

#### **Analyze key areas that are taken into account before taking an important decision**

Benefit – an advantage that the business gets as a result of the required implementation.   
 Penalty – a consequence of not implementing a requirement.   
 Cost – effort and resources that are required to implement a requirement.   
 Risk – a probability that the requirement might not deliver the expected value.   
 Dependencies – a relationship between requirements, for example when requirement will require the completion of another requirement for its implementation.  
 Time sensitivity – expiry date, urgency.   
 Stability – the likelihood of the requirement remaining static.  
 Policy Compliance – requirements that must be implemented to meet the regulatory requirements.

&nbsp;

#### Dependency map

It is always a good idea to create a dependency map to better understand the dependencies between the requirements. Especially taking into account, that most requirements are interdependent and you will hardly find any requirement that exists independently.   
 How can you do it? Let me give you an example: you have 8 requirements X,Y,Z,P,Q,R,M,O and N with priorities, on a 5- level scale where 1 is most critical and 5 least critical, as 1,2,1,4,5,1,2,2,3. So, with these priorities, it would be logical, to begin with requirements X, Z and R.  
 Now, let’s move to the dependency part example: we need to complete X before commencing with Y, although X and Y have the same priority levels. Similarly, we need to complete O before commencing R, although when R has higher priority than O. Understanding the requirements dependency is as just as important as prioritization. Without understanding the requirements dependency, it is highly unlikely that you will arrive at the right order of requirements implementation. So, it is a good idea to have the requirements dependency map in place before prioritizing the requirements, especially when you work on software projects.

&nbsp;

#### **MoSCoW**

MoSCoW method works better than the numeric rating system as it is much easier for the stakeholders to rate the requirements as Must, Should, Could or Would.

The acronym represents the following:

MUST – mandatory  
 SHOULD – of high priority  
 COULD – preferred but not necessary  
 WOULD – can be postponed and suggested for future execution

&nbsp;

#### **Voting**

This is the simplest way to prioritize the requirements. When there are too many requirements that need to be categorized into different categories with inputs from different stakeholders, voting is one of the best ways to sort out the prioritization of requirements. Let’s say if 10 features are under discussion, stakeholders have 10 points and they need to spread them across these features. For example, least important 1, most important 10.

&nbsp;

#### **Bubble sort technique**

Very similar to voting, but for some people, this technique helps them get the right priority faster. To prioritize requirements using bubble sort technique, you take two requirements and compare them with each other. If you find out that one requirement has greater priority over the other, you swap them accordingly. You then continue in this way until the very last requirement is properly sorted. The result is a list of requirements that are ranked.

&nbsp;

#### Hundred Dollar Method

This simple method is useful anywhere multiple stakeholders need to democratically vote on which requirements are the most important. All stakeholders get a conceptual 100 dollars, which they can distribute among the requirements. As such, the stakeholder may choose to give all 100 dollars to a single requirement, or the person may distribute the points more evenly. The higher the amount allocated to each requirement, the higher the priority of the requirement. At the end, the total is counted and the requirements are sorted based on the number of points received.

&nbsp;

#### Five Whys

It often happens that stakeholders want to implement a certain feature for reasons that are not founded on logical arguments or the business interests of the company. With five whys, the analyst asks the stakeholder repeatedly (five times or less) why the requirement is necessary until the importance of the requirements is established. The answers reveal whether the requirement is really necessary or can be cancelled/postponed once the priority is determined.

So, which prioritization technique is best? There is no right answer, you can combine them, you can use one for 1 project and another one for second project. The most important is that you analyze the key points that impact the business.

&nbsp;

**Let’s look at the example of how the software requirements prioritization process may look like:**

1. First of all what you do is creating a list of all the requirements, features, or use cases that you wish to prioritize in a spreadsheet. If certain features are logically linked, include only the driving feature in the analysis.

2. The second step is estimating the relative benefit that each feature provides to the customer, the business on a scale from 1 to 9, with 1 indicating very little benefit and 9 being the maximum possible benefit.

3. The third step is estimating the relative penalty the customer or business would suffer if the feature is not included. Again, use a scale from 1 to 9, where 1 means essentially no penalty and 9 indicates a very serious downside.

4. Then goes the total value – it is the sum of the relative benefit and penalty. By default, benefit and penalty are weighted equally.

5. What is next? Estimation of the relative cost of implementing each feature, again on a scale ranging from a low of 1 to a high of 9.

6. Developers estimate the relative degree of technical or other risk associated with each feature on a scale from 1 to 9.

7. Once you enter the estimates into the spreadsheet, it calculates a priority number for each feature and gives you the results taking into account all the inputs.

8. Sort the list of features in descending order by calculated priority. The features at the top of the list have the most favorable balance of value, cost, and risk, and thus should have higher implementation priority.

I hope you found this article useful if you know other software requirements prioritization techniques, please share them in the comments section below.

&nbsp;

And if you are interested in other software development tips, I highly recommend you to subscribe to our monthly newsletter [here](http://eepurl.com/cC96MY).&nbsp;

&nbsp;

## If you liked this article about software requirements prioritization, you might like …

&nbsp;

[Software development books to read in 2018](https://dev.to/apium_hub/20-essential-software-development-books-to-read)

[Why Kotlin language? Why did Google choose it?](https://dev.to/apium_hub/why-kotlin-language-android-why-did-google-choose-kotlin--639)

[iOS continuous integration with Fastlane & Jenkins](https://dev.to/apium_hub/ios-continuous-integration-with-fastlane--jenkins-19n)

[MVP pattern in iOS](https://dev.to/apium_hub/mvp-pattern-in-ios-98f)

[Software architecture books to read this year](https://dev.to/apium_hub/top-19-software-architecture-books-blf)

[Scala Type bounds](https://dev.to/apium_hub/scala-generics-i--scala-type-bounds-38)&nbsp;

[F-bound over generic type of Scala](https://apiumhub.com/tech-blog-barcelona/f-bound-scala-generics/)

[Charles Proxy in Android Emulator](https://apiumhub.com/tech-blog-barcelona/charles-proxy-android-emulator/)

[Top software development blogs&nbsp;](https://apiumhub.com/tech-blog-barcelona/top-software-development-blogs-2017/)

[Top software testing techniques & tools to use](https://apiumhub.com/tech-blog-barcelona/top-software-testing-techniques/)

[A Guide to Tmux that will increase your productivity](https://apiumhub.com/tech-blog-barcelona/tmux-cheat-sheet-tips-tricks/)

[Functional debt vs technical debt](https://apiumhub.com/tech-blog-barcelona/technical-debt/)

[BDD: UI Testing](https://apiumhub.com/tech-blog-barcelona/user-interface-testing/)

[Microservices vs monolithic architecture](https://apiumhub.com/tech-blog-barcelona/microservices-vs-monolithic-architecture/)

[SRP in Object oriented design](https://apiumhub.com/tech-blog-barcelona/single-responsibility-principle/)

[Almost infinit scalability](https://apiumhub.com/tech-blog-barcelona/almost-infinite-scalability/)&nbsp;

&nbsp;

&nbsp;

The post [Software requirements prioritization techniques you should know](https://apiumhub.com/tech-blog-barcelona/software-requirements-prioritization-techniques/) appeared first on [Apiumhub](https://apiumhub.com).