“Amazing how fire exposes our priorities.”Sherlock
How do you prioritize your tasks? We know that it’s more efficient to solve the most important tasks first, especially when you are a startup and the pace is super fast. But how do you determine which ones are the most important? (And how do you do that without lighting your project on fire first?)
The Pareto principle states that roughly 80% of the effects come from 20% of the causes. Put differently: 80% of the company’s or project’s benefits come from 20% of the time spent by its staff.
In an Agile product development context, the same rule would be something like 80% of the product value comes from 20% of product backlog items. But how can you define what tasks must be included in this “magical 20%”? Getting 20% to contain your most vital tasks means solving the prioritization problem in the most optimal way.
Prioritization is a principle that means “doing the first thing first”. As a process, it means “evaluating a group of items and ranking them in their order of importance or urgency”. Actually, prioritization is our everyday activity. We continuously make choices and direct our activity to some task. Sometimes it is a decision between two tasks:
1) make a call to a potential customer or 2) fill gaps in a regular report.
Sometimes it’s prioritization between three tasks:
1) go to a supermarket,
2) have dinner with colleagues,
3) visit a doctor…
Sometimes, especially in agile software development, we deal with the problem of prioritization of N tasks according to M criteria. Quite a regular situation for a startup company. This is the kind of problem which isn’t solved easily for the human brain and thus needs special solutions.
Here Is the List of Popular Agile Prioritization Methods
Here’s the list of popular prioritization techniques in Agile:
The 100-Dollar Test (100 point method): Distribute a hypothetical $100 across features or tasks.
Priority Poker: Play a game of poker to rank your tasks.
MoSCoW prioritization method: Categorize tasks as “Must Have,” “Should Have,” “Could Have,” or “Won’t Have.”
Kano Model: Classify features based on their impact on customer satisfaction.
Weighted Shortest Job First (WSJF): Calculate the value, time criticality, and risk reduction of work items.
Cost of Delay (CoD): Consider the economic impact of delaying a feature.
Theme Screening: Prioritize user stories or features based on their alignment with strategic themes.
Value vs. Effort Matrix: Plot features or user stories on a matrix based on their value and effort required.
Each of these Agile project prioritization techniques offers unique benefits. Dive deeper into each method to discover which one suits your project best.
The 100-Dollar Test (Cumulative Voting)
The 100 dollar test, or cumulative voting, is a pretty simple and straightforward technique (described by Leffingwell and Widrig). First, it’s important to gather stakeholders in a prioritization session and make a list of options to be prioritized. All participants are given a finite amount of imaginary units (usually 100 dollars, points, etc.). Each of them should divide the amount among the given options (user stories, tasks, requirements). After that, you can calculate the total units for each option and order them accordingly.
Priority poker is a quick and easy design game for prioritizing items. It’s called priority poker because it’s very similar to planning poker (a technique for evaluating the costs of the user stories wildly used in Agile development projects).
Before starting the game, the moderator gathers all the people that need to be involved in the prioritization process, such as stakeholders, product owners, designers, developers, domain experts, and perhaps even users. The moderator will also need to prepare the list of tasks to prioritize and a set of priority cards to provide to each player. The number of cards in this set depends on how many levels of priority are useful to use in this particular case. In some cases, it could be a 5 point scale (e.g. very high priority, high priority, medium priority, low priority, very low priority), a 3 point (e.g. high urgency, medium urgency, low urgency) or even 10 point scale. The number of cards corresponds to the numbers on the scale.
Then, the moderator reads a piece of functionality (user story). Each participant chooses the card that they think is the most appropriate ranking for that task and places the card face down on the table. When all participants have made their choice, all the cards are turned over at the same time. The differences are discussed and the game goes on until the estimates are around the same level.
MoSCoW analysis is the prioritization technique that is recommended for business analysts in the IIBA BABOK and originating from the DSDM (dynamic software development method). According to this method, a list of requirements or user stories should be categorized into the following 4 groups:
M: Must. Describes a requirement that must be satisfied in the final solution for the solution to be considered a success.
S: Should. Represents a high-priority item that should be included in the solution if it is possible. This is often a critical requirement but one which can be satisfied in other ways if absolutely necessary.
C: Could. Describes a requirement which is considered desirable but not necessary. This will be included if time and resources permit.
W: Won’t. Represents a requirement that stakeholders have agreed will not be implemented in a given release but may be considered in the future.
After classification into the 4 groups, the requirements are ranked in order of preference within each category.
The Kano Model, developed by Professor Noriaki Kano, is a unique approach to understanding customer satisfaction. It classifies product features into three categories: Basic, Performance, and Excitement.
Basic features are the minimum requirements that customers expect from a product. Performance features are those that customers are aware of and often base their purchase decision on. Excitement features are the unexpected features that surprise and delight customers.
The Kano Model is a valuable tool in the agile prioritization matrix. It helps teams understand which features will satisfy customers and which ones will delight them. This understanding can guide the product development process, ensuring that the team is not just meeting customer expectations but exceeding them.
Weighted Shortest Job First (WSJF)
Weighted Shortest Job First (WSJF) is a prioritization method that focuses on delivering maximum value in the shortest possible time. It takes into account the size of the job (effort required to complete it) and its importance (value, time criticality, risk reduction, and opportunity enablement).
The idea behind WSJF is to calculate a “cost of delay” for each job and divide it by the job size. The jobs with the highest WSJF scores are the ones that deliver the most value per unit of work and should be done first.
This approach is particularly effective for backlog prioritization in agile development. It ensures that the most valuable and urgent tasks are tackled first, optimizing the value delivered by the development team.
Cost of Delay (CoD)
Cost of Delay (CoD) is a prioritization method that takes into account the economic impact of delaying a feature or task. It combines factors like potential revenue loss, opportunity cost, or time-sensitive benefits to prioritize work items.
In agile development, CoD can be a powerful tool for project prioritization. By understanding the cost of delaying each task, teams can make informed decisions about what to work on next. This can be particularly useful in a fast-paced agile environment, where the timing of tasks can significantly impact the overall success of the project.
Theme Screening is a prioritization method that starts with defining strategic objectives or themes. User stories or features are then prioritized based on how well they align with these themes. This technique ensures that the most relevant work is prioritized, helping teams stay focused on their strategic goals.
In agile development, Theme Screening can be used to align the work of the team with the broader goals of the organization. By prioritizing tasks that align with strategic themes, teams can ensure that their work contributes to the overall success of the organization.
Value vs. Effort Matrix
The Value vs. Effort Matrix is a simple and visual way to prioritize features or user stories based on their value and effort required. It divides the matrix into four quadrants: Quick Wins, Major Projects, Fill-Ins, and Thankless Tasks.
- Quick Wins: Low-effort tasks with high value, bringing significant benefits quickly.
- Major Projects: High-effort tasks with high value, requiring careful planning and resources.
- Fill-Ins: Low-effort tasks with low value, considered nice-to-have but not critical.
- Thankless Tasks: High-effort tasks with low value, often deemed less important.
Using this matrix, teams can focus on quick wins for immediate impact, prioritize major projects for significant outcomes, address fill-ins when resources permit, and reconsider thankless tasks that may not be worth the effort.
The Value vs. Effort Matrix helps teams make informed decisions about task prioritization and resource allocation, ensuring efficient use of time and resources in Agile project management.
How to Choose the Agile Technique that Best Suits Your Project?
Choosing the right prioritization technique for your project can feel like a daunting task, especially with the plethora of options available.
Here are a few pointers to guide you in making the right choice for your backlog in Agile:
- Understand the context of your project. Consider the nature, size of team, complexity of tasks, and expectations of stakeholders. This will help you choose the best prioritization technique for your project. Techniques such as WSJF and CoD can be useful for projects with tight deadlines and high stakes. These techniques focus on value and urgency.
- Consider your team’s expertise. Some techniques require a certain level of expertise to implement effectively. For example, the Kano Model requires a deep understanding of customer needs and expectations, which might not be feasible for all teams. On the other hand, simpler techniques like the Value vs. Effort Matrix or the MoSCoW method might be easier to implement for teams new to prioritization.
- Evaluate your resources. Some techniques require more resources than others. For instance, Priority Poker requires the involvement of multiple stakeholders and can be time-consuming. If your team is small or time-constrained, a simpler technique might be more appropriate.
- Align with your strategic goals. Techniques like Theme Screening can help ensure that your team’s work aligns with the broader strategic goals of your organization. If strategic alignment is a priority for your project, consider techniques that facilitate this.
- Experiment and adapt. Don’t be afraid to experiment with different techniques and adapt them to your needs. Agile is all about flexibility and continuous improvement. If a technique isn’t working for your team, try another one. The goal is to find a method that helps your team prioritize effectively and deliver maximum value.
In the world of Agile development, prioritization is a critical task that can make or break a project. With nine different techniques at your disposal, the challenge lies not just in understanding each one, but in knowing which to apply and when.
Each technique, from the 100-Dollar Test to the Value vs. Effort Matrix, offers unique benefits and potential challenges. Some methods, like the Kano Model or WSJF, require a deep understanding of customer needs and the product itself, making them highly effective but potentially challenging if the team lacks the necessary expertise.
Other techniques, such as Priority Poker or Theme Screening, foster collaboration and consensus, making them valuable for projects where stakeholder buy-in is crucial. Yet, these methods can be time-consuming and may not be suitable for all scenarios.
Ultimately, the key to effective prioritization lies in the ability to adapt. Agile development is, by nature, a dynamic and flexible process. As such, your approach to prioritization should be as well. Don’t be afraid to experiment with different techniques, or even to use a combination of methods, to find what works best for your team and your project.
Remember, the goal of prioritization is not just to rank tasks, but to ensure that your team is always working on the most valuable tasks. By choosing the right prioritization technique, you can guide your team’s efforts, align your work with strategic goals, and deliver a product that truly meets your customers’ needs.
Nevertheless, using at least one of the prioritization techniques is much better than to let “fire expose” your priorities, which sometimes may happen when you are, for instance, a startup. Don’t let the fires get your project! Let us know if you have any questions.