WSJF — Weighted Shortest Job First

---

Origins

WSJF was developed by Don Reinertsen in The Principles of Product Development Flow¹ as a practical scheduling rule for product development under uncertainty. Reinertsen's argument: in product economics, the right thing to do next is the item with the highest cost of delay relative to its duration. Doing short, high-value items first delivers value to customers sooner and frees the team to take on the next high-value item faster.

SAFe (the Scaled Agile Framework) adopted WSJF as its primary prioritization tool for sequencing features and epics². SAFe's adaptation simplifies the formula for practical use by teams that cannot easily produce dollar-denominated Cost of Delay estimates, replacing precise economics with relative-sized components.

The Formula

WSJF is conceptually simple:

WSJF = Cost of Delay ÷ Job Size

Highest WSJF score gets sequenced first. The economics behind it: when capacity is constrained, completing a short high-Cost-of-Delay item before a long one minimizes total economic loss across the portfolio.

SAFe's Three-Part Cost of Delay

Because dollar-denominated Cost of Delay is hard to estimate, SAFe breaks it into three components, each estimated on a relative scale (typically modified Fibonacci: 1, 2, 3, 5, 8, 13, 20).

1. User-Business Value

The relative value to the customer or business of this feature, compared to other features. Includes potential revenue, customer satisfaction impact, cost reduction.

2. Time Criticality

How urgent is the deadline? Does value decay rapidly if delivered late? Is there a fixed date (regulation, contract, season)? Time-critical items get higher scores; items whose value is roughly constant over time get lower.

3. Risk Reduction & Opportunity Enablement (RR&OE)

Does this feature reduce a major risk for the team or organization? Does it open up future opportunities — new markets, new capabilities, new business models? Items that derisk or enable get higher scores.

The three components are summed for Cost of Delay, then divided by job size (also on the relative Fibonacci scale).

WSJF = (Value + Time Criticality + RR&OE) ÷ Job Size

How to Run a WSJF Session

1. Establish the candidate set

WSJF sequences a defined set of items — features for a Program Increment, epics for a quarter, or a backlog up for re-ranking. It is not for ranking the entire backlog ad infinitum.

2. Calibrate each component

For each component (Value, Time Criticality, RR&OE, Job Size), pick the item with the lowest score and assign it 1. Other items get scored relative to that anchor on the Fibonacci scale. The relative calibration matters more than absolute numbers.

3. Score all items

Walk the items as a group. Each gets four scores. Use planning-poker-style estimation: stakeholders vote simultaneously, discuss disagreements, re-vote. The conversation around the scores is more valuable than the scores themselves.

4. Calculate and sort

Compute WSJF for each item, sort descending. Top of the list is the recommended sequencing.

5. Sanity check

The numbers are an input, not a verdict. Walk the ranked list as a group. Does the order make sense? Are there obvious problems? Adjustments based on judgement are legitimate — pretending the formula is final is not.

What WSJF Does Well

• Forces explicit conversation: scoring components surfaces disagreements about value and urgency that would otherwise stay hidden.
• Favors small, valuable work: the division by job size pulls quick wins toward the top, which is economically correct in most product contexts.
• Combines multiple inputs: value, urgency, and strategic risk all appear in one number, harder to ignore than any single dimension.
• Comparable at portfolio scale: items from different product areas get a common score, useful for cross-team sequencing in SAFe-scale organizations.

What WSJF Does Poorly

• False precision: a WSJF score of 4.7 vs. 5.2 is rarely meaningful given the noise in the inputs. Teams that treat the score as authoritative are reading more from it than the math supports.
• Hides the components: a high score can come from genuine value, from inflated time criticality, or from a small job-size estimate. The number alone doesn't reveal which.
• Gameable: stakeholders who learn the formula can inflate Time Criticality or RR&OE on their pet items. Without active facilitation, the scores reflect politics rather than reality.
• Misses dependencies: items with high WSJF may not be doable next because they depend on items with lower scores. The formula doesn't sequence dependency-aware.
• Wrong tool for some work: bug fixes, compliance work, technical debt — items that don't fit the value/urgency/job-size mold get awkwardly squeezed in. Better to set them aside from the WSJF process and prioritize separately.

Common Pitfalls

• Scoring in isolation: the PM scores everything alone and brings it to the team. The scoring conversation is most of the value — doing it solo throws it away.
• Anchoring on the first item: the first item discussed sets the unconscious scale for the rest. Mix the order, use blind voting, recalibrate periodically.
• Score-as-decision: the team treats the WSJF list as the final sequence rather than as input to a judgement call. Sanity check, adjust, and document the override when one happens.
• Persistent re-scoring: items get re-scored every session, which produces unstable rankings and erodes confidence. Re-score only when material new information appears.
• Job size dominates: when value/urgency/risk scores cluster but sizes vary widely, sequencing becomes "do the smallest items first," which may miss strategic priorities. Watch for the pattern.
• Mandatory WSJF for everything: forcing every backlog item through the formula buries it in process. Reserve WSJF for the items where economic sequencing matters most.

Coaching Tips

Score Together

The scoring conversation is most of the value. Coach against the pattern of one person scoring everything and the team rubber-stamping the result.

Calibrate to an Anchor

Before scoring, pick the lowest item on each component and assign it 1. Without an anchor, scores drift over the session and lose comparability.

Watch for Inflation

Time Criticality is the most-gamed component. Push back when everything is rated 13 or 20 — "if everything is urgent, nothing is."

Sanity Check the Ranking

After computing, walk the list. Does the order pass the gut test? If not, the formula is missing something — investigate before accepting or overriding.

Re-Score Sparingly

Frequent re-scoring produces unstable rankings and reduces team trust in the practice. Re-score only when material new information appears.

Don't Force-Fit Every Item

Bug fixes, compliance items, and tech debt often don't fit the WSJF mold. Set them aside and prioritize separately rather than gaming the formula.

Summary

WSJF is one of the more durable contributions of SAFe to the wider Agile community — not because the formula is uniquely insightful, but because it forces structured economic conversation about sequencing in a way most teams skip entirely. The discipline of scoring value, time criticality, and risk in front of the people who will deliver the work surfaces disagreements that would otherwise stay buried.

The danger is the inverse of the value: a team that worships the score loses the judgement that should accompany it. WSJF is best used as a starting hypothesis for sequencing, refined by the team's understanding of dependencies, learning, and context. Teams that treat the spreadsheet as the answer end up with mathematically optimal rankings of the wrong things. Teams that use the formula to start the conversation, then let judgement finish it, get the best of what the technique offers.

Back to Prioritization