How is WSJF different from RICE?

[RICE](/frameworks/rice-framework) scores features on Reach, Impact, Confidence, and Effort. WSJF scores on Cost of Delay (three sub-components) divided by Job Duration. The key difference is WSJF explicitly captures time sensitivity. A feature with a hard deadline in 4 weeks scores higher in WSJF than one with the same value but no deadline. RICE does not account for this.

What if all my features have similar time criticality?

If nothing is time-sensitive, the Time Criticality scores will be similar and WSJF reduces to (User-Business Value + RR/OE) / Job Duration. In that case, WSJF still works but you get less differentiation from it. Consider using RICE or ICE instead if time sensitivity is not a major factor in your backlog.

Should I use WSJF for user stories or only for epics?

WSJF works best at the epic or feature level. User stories are too granular for meaningful Cost of Delay estimates. Score features and epics with WSJF to determine build order, then break them into stories and use story points or t-shirt sizing for sprint-level planning.

How do I estimate Job Duration without detailed planning?

Use relative sizing. Pick the smallest feature as your baseline (score 1) and rate everything else relative to it. A feature that is roughly 3x the effort gets a 3. One that is 8x gets an 8. You do not need precise hour estimates. Relative sizing is sufficient for sequencing decisions.

Can I modify the Cost of Delay components?

Yes. The three standard components (User-Business Value, Time Criticality, RR/OE) work for most teams. If your context requires it, you can add a fourth component (for example, Regulatory Urgency) or replace RR/OE with a domain-specific dimension. Just keep the total number of components at 3-4 to avoid scoring fatigue.

WSJF (Weighted Shortest Job First) Template

What This Template Is For

Weighted Shortest Job First (WSJF) is a prioritization method from the Scaled Agile Framework (SAFe) that sequences work by dividing the Cost of Delay by Job Duration. Cost of Delay captures how much value you lose by not building a feature sooner. Job Duration captures how long it takes to deliver. Features with a high cost of delay and short duration rise to the top because they deliver the most value per unit of time.

This template structures the WSJF calculation for your product backlog. It breaks Cost of Delay into three components (User-Business Value, Time Criticality, and Risk Reduction/Opportunity Enablement) so you can score each dimension separately and produce a well-rounded delay cost. The calculation is straightforward: score the three Cost of Delay components, sum them, then divide by Job Size. The result is a WSJF score that tells you which features to build first.

WSJF is especially useful when time-sensitivity varies across your backlog. Some features lose value if delayed (seasonal launches, competitive responses), while others maintain their value regardless of timing. Standard scoring methods like RICE capture impact and effort but not time sensitivity. WSJF fills that gap. For a broader view of prioritization options, see the RICE vs ICE vs MoSCoW comparison. The Product Strategy Handbook covers how to connect feature sequencing to your strategic planning cycle. You can also run quick scores through the RICE Calculator for features where time sensitivity is less of a factor.

When to Use This Template

Your backlog contains features with different levels of time sensitivity and you need to account for delay costs
You are running SAFe or a scaled agile process and need to prioritize across multiple teams
Stakeholders are pressuring you to ship everything at once and you need an objective sequencing method
Some features have hard deadlines (regulatory, contractual, seasonal) and others are evergreen
You want to optimize for maximum value delivery per unit of time, not just total value
PI (Program Increment) planning requires a data-driven ranking that all teams can align on

How to Use This Template

Step 1: List features or epics. Add every feature under consideration. WSJF works at the epic or feature level, not individual user stories.

Step 2: Score Cost of Delay components. For each feature, rate three dimensions on a relative scale (1, 2, 3, 5, 8, 13, 20 using a modified Fibonacci sequence): User-Business Value, Time Criticality, and Risk Reduction/Opportunity Enablement.

Step 3: Calculate total Cost of Delay. Sum the three component scores for each feature.

Step 4: Estimate Job Duration. Rate the relative size of each feature using the same scale (1, 2, 3, 5, 8, 13, 20). This represents implementation effort.

Step 5: Calculate WSJF and rank. Divide Cost of Delay by Job Duration. Sort features from highest WSJF to lowest. Build in that order.

The Template

# WSJF Template

## Scoring Scale (Relative, Modified Fibonacci)

| Value | Meaning                                  |
|-------|------------------------------------------|
| 1     | Minimal                                  |
| 2     | Low                                      |
| 3     | Moderate                                 |
| 5     | Significant                              |
| 8     | High                                     |
| 13    | Very high                                |
| 20    | Critical / Urgent                        |

## Cost of Delay Components

### User-Business Value
How much value does this feature deliver to users and the business?

### Time Criticality
How much does the value decrease if we delay? Is there a deadline,
seasonal window, or competitive pressure?

### Risk Reduction / Opportunity Enablement (RR/OE)
Does this feature reduce a significant risk (technical, market, compliance)
or enable future opportunities that are blocked without it?

## WSJF Scoring Sheet

| # | Feature              | User-Biz Value | Time Criticality | RR/OE | Cost of Delay | Job Duration | WSJF Score | Rank |
|---|----------------------|----------------|------------------|-------|---------------|--------------|------------|------|
| 1 |                      |                |                  |       |               |              |            |      |
| 2 |                      |                |                  |       |               |              |            |      |
| 3 |                      |                |                  |       |               |              |            |      |
| 4 |                      |                |                  |       |               |              |            |      |
| 5 |                      |                |                  |       |               |              |            |      |
| 6 |                      |                |                  |       |               |              |            |      |
| 7 |                      |                |                  |       |               |              |            |      |
| 8 |                      |                |                  |       |               |              |            |      |

## Sequencing Output

Build order (highest WSJF first):

1.
2.
3.
4.
5.

## Common Scoring Mistakes

| Mistake                                | How to Avoid                                 |
|----------------------------------------|----------------------------------------------|
| Scoring everything as 13 or 20         | Anchor one feature as 1 in every column      |
| Using absolute values instead of relative | Compare features to each other, not to external benchmarks |
| Ignoring RR/OE because it is harder to score | Discuss risks and dependencies explicitly     |
| Not recalculating when deadlines change| Set a calendar reminder to re-score monthly  |
| Treating WSJF as a filter (cut low scores) | WSJF sequences work. All items may ship eventually |

## Assumptions and Notes
- All scores are relative to each other (not absolute)
- Score at least one feature as 1 in each column to anchor the scale
- Re-score when new features are added or deadlines change
- WSJF is about sequencing, not filtering. All features may eventually ship.
- Time Criticality should reflect real deadlines, not perceived urgency
- RR/OE captures enablement value: features that unblock future work score high here

Filled Example: Enterprise Platform PI Planning

# WSJF Scoring: CloudDeck PI 7 Planning

## WSJF Scoring Sheet

| # | Feature                          | User-Biz Value | Time Criticality | RR/OE | CoD | Job Duration | WSJF  | Rank |
|---|----------------------------------|----------------|------------------|-------|-----|--------------|-------|------|
| 1 | GDPR data export compliance      | 8              | 20               | 13    | 41  | 5            | 8.20  | 1    |
| 2 | Single sign-on (SAML)            | 13             | 8                | 5     | 26  | 5            | 5.20  | 2    |
| 3 | Real-time collaboration editing  | 13             | 3                | 8     | 24  | 8            | 3.00  | 4    |
| 4 | Mobile app offline mode          | 8              | 2                | 3     | 13  | 13           | 1.00  | 7    |
| 5 | API v2 migration                 | 5              | 5                | 13    | 23  | 8            | 2.88  | 5    |
| 6 | Customer health dashboard        | 8              | 5                | 5     | 18  | 3            | 6.00  | 3    |
| 7 | Advanced permissions model       | 5              | 3                | 8     | 16  | 8            | 2.00  | 6    |
| 8 | Custom report builder            | 8              | 1                | 2     | 11  | 13           | 0.85  | 8    |

## Sequencing Output

Build order:

1. GDPR data export (WSJF: 8.20). Regulatory deadline in 6 weeks. Time criticality drives the score.
2. Single sign-on (WSJF: 5.20). High business value, 3 enterprise deals waiting on this.
3. Customer health dashboard (WSJF: 6.00). Quick to build (3), strong CoD, good early-PI win.
4. Real-time collaboration (WSJF: 3.00). High value but large job size reduces WSJF.
5. API v2 migration (WSJF: 2.88). High RR/OE because current API limits future features.

## Key Insight
GDPR export has only moderate User-Business Value (8) but extreme Time Criticality (20)
because the compliance deadline is immovable. Without WSJF, the team might have prioritized
Real-time Collaboration (higher User-Business Value of 13) first. WSJF correctly sequences
the time-critical work ahead of the higher-value but time-flexible feature.

## Assumptions
- GDPR deadline: April 15, 2026 (non-negotiable)
- SSO is blocking 3 enterprise contracts worth $180K combined ARR
- API v2 migration enables 4 features planned for PI 8
- Scored mobile offline as 1 anchor for Time Criticality (no deadline)
- Custom report builder has highest Job Duration (13) due to complex rendering engine
- Advanced permissions model has high RR/OE (8) because it enables self-serve admin for enterprise

## What We Learned
WSJF surfaced a sequencing decision that the team would have missed with RICE alone. The
Customer Health Dashboard ranked third by WSJF (6.00) despite having lower User-Business
Value than Real-time Collaboration. Its small Job Duration (3) made it a better early win.
The team decided to ship it in Sprint 1 alongside the GDPR work, using the remaining
capacity that the GDPR feature did not fill.

Key Takeaways

WSJF sequences features by dividing Cost of Delay by Job Duration, optimizing for maximum value per unit of time
Cost of Delay has three components: User-Business Value, Time Criticality, and Risk Reduction/Opportunity Enablement
Time Criticality is what makes WSJF different from other scoring methods. It captures the urgency dimension that RICE and ICE miss
Use relative scoring (modified Fibonacci: 1, 2, 3, 5, 8, 13, 20) rather than absolute estimates. Anchor at least one feature as 1 in each column
WSJF is about sequencing, not filtering. A low-WSJF feature is not unimportant. It just should be built later
Re-calculate WSJF whenever deadlines change or new features are added, because time criticality is dynamic

WSJF (Weighted Shortest Job First) Template