As product managers, it’s essential to prioritize the right development tasks so that teams can complete the most valuable work first. Rather than relying on gut instinct, product managers will use specific priority modeling tools, one of which, in the Agile software environment, is known as the Weighted Shortest Job First prioritization model (WSJF).
Using the WSJF model, product managers can rank features, capabilities, and other development tasks in order of importance. Doing so not only helps create a higher quality product; it ensures teams stay focused on the right tasks for the successful completion of a project. Task prioritization also allows product managers to identify and address potential risks early on so they can eliminate or reduce costly delays.
But what exactly does the WSJF model involve, and when might you use it?
In this guide, we’ll cover everything you need to know about WSJF, including why it’s unique, how it works and when to implement it. We’ll cover:
- What is WSJF?
- How product managers use WSJF
- How is WSJF calculated? A step-by-step guide
Ready to get the basics of WSJF down? Then let’s dive in.
1. What is WSJF?
First up, let’s first cover the basics.
What is a prioritization model?
A prioritization model is a method of ranking tasks, objectives, or ideas in order of importance. Managers will use these models in various contexts to determine in which order to complete tasks. While they apply in areas from business to public policy, prioritization models are also essential for efficient product development and are commonly used to inform product roadmaps.
The basic assumption of prioritization models is that not all tasks have equal value or urgency. By assigning relative importance to different jobs, the right prioritization model will help decision-makers identify what needs doing most urgently, what can wait, and even which tasks to eliminate. This ensures proper allocation of time, money, and personnel.
Prioritization models can be simple or complex. They can also weight tasks based on different criteria. The right model usually depends on the specific needs of an organization, its teams, and its customers.
What is Weighted Shortest Job First (WSJF)?
Weighted Shortest Job First (WSJF) is a well-known and relatively complex prioritization model used in Agile software development. It’s based on the fundamental idea that work with the highest return on investment (ROI) should be prioritized and completed first.
Of course, this first means effectively measuring and benchmarking the ROI of different tasks. To achieve this, WSJF considers factors such as the predicted cost of delaying a task’s completion and a task’s relative size compared to other jobs on a project. There are specific ways of calculating all of these measures, which we’ll explore in depth in section 3.
How is Weighted Shortest Job First different from other prioritization models?
The main difference between WSJF and other prioritization models is its focus on ROI. Other models may only account for a job’s size or relative importance when determining its priority. To calculate ROI, WSJF requires more measures, which means it’s also more complex to implement—calculations need regular updating throughout a project or sprint, making WSJF quite labor-intensive.
Because WSJF is applied in Agile environments, the fact that it takes into account the cost of delay is also significant. Agile relies heavily on feedback, collaboration, and short turnarounds. Since the development process is shorter and more responsive to change, delays can easily disrupt progress. Additionally, Agile focuses on rapid experimentation and learning, so each delay carries a cost in terms of lost learning opportunities.
2. How product managers use WSJF
Now we’ve got a basic understanding of WSJF, how do product managers actually use it?
To understand this properly, it helps to contextualize the context in which we might apply it. Namely, in an Agile environment.
Let’s take a look.
How does WSJF work in Agile?
While we can apply WSJF in any Agile development methodology, it’s best suited to the Scaled Agile Framework, also known as SAFe.
SAFe was initially developed in the early 2010s to meet the needs of large-scale organizations managing multi-team Agile software projects. These projects are typically more complex than single-team Agile initiatives, which justifies the additional labor required to implement the model. WSJF is ideally suited to prioritizing SAFe’s product backlog items, basing decisions on each task’s relative business value, risk reduction, and time criticality.
It’s important to emphasize that the WSJF model is best for prioritizing product development tasks involving complex, high-risk projects or initiatives that require a significant investment of time and resources. This is why it’s so well-suited to SAFe, which usually involves many stakeholders and extensive collaboration, and therefore benefits from a structured decision-making process (rather than flying by the seat of one’s pants!)
Examples of the kinds of things we might prioritize using the WSJF model include:
- Product development roadmap planning
- Feature prioritization
- Establishing development timelines
- Long-term resource allocation
Because WSJF is relatively resource-intensive, it’s not suited to every job. It’s not worth the time and effort when dealing with smaller things like:
- Bug fixes
- Minor feature enhancements
- Quick fixes and small improvements
- Short-term resource allocation
How do product managers use WSJF?
OK, now we have some context, how do product managers actually use the WSJF model to prioritize tasks? Put simply, for each task, they’ll use the model to calculate the following key metrics:
- Cost of delay: This is the estimated cost-benefit of completing or not completing a task at a particular time. It considers any financial or strategic impacts, such as the cost of lost revenue, the competitive advantage of undertaking a task, customer satisfaction, and more.
- Task duration: This is the estimated amount of time and resources it will take to complete a task, from the moment the project kicks off to its final delivery to the client. It will take into account all development days.
- WSJF score: This is typically a numeric value calculated using the cost of delay and job duration metric for each task. The higher the value, the higher the task’s priority, and vice-versa.
By inputting WSJF scores into a spreadsheet or prioritization matrix with the scores of other tasks, product managers can quickly see what needs to be done first. Simple!
3. How is WSJF calculated? A step-by-step guide
Okay, so the principles of WSJF are fairly straightforward. But getting to the point of calculating each task’s WSJF score requires a bit of work.
In this step-by-step guide, we’ll use examples and formulas to help you. While navigating these calculations, remember your overall aim: to identify the tasks that will deliver the most value in the shortest time.
As such, the tasks the model prioritizes might not seem intuitively correct, especially if you’re used to focusing on the more time-consuming or customer-demanded tasks first.
The WSJF score is ultimately decided using the following formula:
WSJF score = cost of delay/job duration
To get to the point where you’re ready to use this formula, you’ll first need to carry out a few other calculations.
For argument’s sake, let’s say you’re a product manager who wants to calculate the WSJF scores of several product development tasks, including:
- Developing a new autosave feature
- Refactoring an existing codebase
- Increasing overall system performance
For each item, you’ll need to do the following.
Step 1: Create a task matrix and value scale
The WSJF equation is straightforward but you need to calculate several other values first. To keep track of these, create a blank table similar to the following:
Don’t worry about the headings just yet—we’ll get to those in a minute!
First, you’ll need to decide on a numeric scale to assign values to each metric. Why? Because it’s common to measure things like the cost of delay using fiscal values and job duration using time, it’s much easier to assign a consistent metric to each from a predefined scale.
Typically, in WSJF, values are represented using a modified Fibonacci scale. Using a single scale keeps things consistent and makes it easier to calculate and compare final WSJF scores for different tasks.
For this example, we’ll adopt a 7-point modified Fibonacci scale (1, 2, 3, 5, 8, 13, 20) with higher values representing higher priority tasks and lower values representing lower priority ones.
Step 2: Estimate the cost of delay
Next, you need to estimate each task’s cost of delay. This factors in things like the money, time, and other resources that will be lost if the task isn’t completed on time, or if you delay starting it.
The standard formula for estimating the cost of delay is:
Cost of delay = user-business value + time criticality + risk reduction and/or opportunity enablement
Hang on, though! What is each of these terms? And how do you measure them?
Here’s a summary:
- User-business value considers both the relative value of the task to the user (in terms of improved experience or increased profits, etc.) and the business (in terms of increased revenue, market share, etc).
- Time criticality considers the importance of the task being completed on time. For example, if a task needs to be completed by a certain date to avoid the customer canceling the project, or to meet a legal requirement, time criticality will be high. Meanwhile, if a task can be completed anytime without causing any issues, its time criticality will be low.
- Risk Reduction and/or opportunity enablement considers how completing the task on time will either reduce risk or enable new opportunities. For example, if completing the task on time will reduce the chances of a lawsuit being filed against the company, risk reduction will be high. On the other hand, if completing the task on time will enable the company to access a new market, opportunity enablement will be high.
Measuring all of these will involve bringing together relevant team members, executives, or other stakeholders to determine appropriate scoring. To measure the cost of delay for a new feature, for example, you might need input from your development team and/or financial director.
While the cost of delay is ultimately a fiscal estimate (and you should keep track of these monetary values) don’t forget to assign each value a number on your Fibonacci scale to make calculating your WSJF score easier.
Start by looking at your table. Taking one column at a time, assign the lowest priority task with a 1 (there should always be a 1 in each column), and then go up from there. Once you’ve completed each column, add the values in each row, and, hey presto, you have your relative cost of delay value.
Here’s how these might look on your table:
Step 3: Estimate the relative job size/duration
The next step—and you’ll be glad to hear this one is a bit easier—is to calculate the relative job size or duration of each task.
Relative job size estimates the amount of work required to complete a task. While the measurement doesn’t have a specific formula, it still requires careful consideration and input from team members who will be working on the task at hand.
For example, to develop the autosave feature, you might speak to your development team and determine that the relative job size is 10 development days. Similarly, if you’re refactoring the existing codebase, you might estimate that the relative job size is five development days (and so on).
Note that your estimated job duration should never be longer than the period you’re prioritizing tasks for. That is to say, if a feature’s development is estimated at 14 days, your sprint should be at least this long. If your sprint is shorter than the estimate, you’ll need to break the task into smaller chunks.
Once you’ve estimated the duration of each task use your numeric scale to assign a value to each so that you can place final estimates into the WSJF equation.
Here’s how your table should look:
Step 4: Calculate the Weighted Shortest Job First score
Finally, you’re ready to calculate your WSJF scores. Satisfyingly, this is the easy part!
Input each relative cost of delay and duration estimate into the WSJF formula, and repeat for each task. In our example, this provides the following values:
Using this method, we can see that the task with the greatest priority—according to the model—is to increase system performance. This is followed by developing the new autosave feature and, finally, by refactoring the codebase.
While this is a simplified walkthrough of the model, it clearly illustrates how it works. If you want to understand it better, the best thing to do is put it into practice with your own software development tasks.
Remember: the WSJF model is not an exact science. This is because it’s impossible to accurately predict the cost of certain tasks before they’ve taken place, especially if you’re developing novel features nobody has created before.
For this reason, you should constantly make adjustments to your calculations as you go. And remember that the final decision always lies with you as the product manager. A model is an excellent tool for helping with decision-making, but it’s not a crystal ball.
So there we have it, the Weighted Shortest Job First prioritization model in a nutshell!
In this post, we’ve explored how prioritizing tasks is essential for efficient product management. Specifically, we’ve looked at the WSJF model, which is used in Agile software development, particularly the SAFe methodology.
We’ve learned that the WSJF model is based on the principle that the task with the highest return on investment should be prioritized and completed first. To measure ROI, WSJF takes into account things like the predicted cost of delay, a job’s relative size, and other risk factors.
Using this guide and a bit of practice, you should now be able to use the WSJF model to prioritize tasks within your own Agile development environment.
In the meantime, if you want to learn more about product development, sign up for this free, 5-day product development short course, or check out the following guides: