How do you prioritize a backlog with RICE or WSJF?
RICE = Reach × Impact × Confidence ÷ Effort, good for mass-market products. WSJF (Weighted Shortest Job First) = Cost of Delay ÷ Job Size, good for roadmaps where time matters as much as value — you use one, the other, or both depending on the kind of decisions you make.
A backlog prioritized "by the PM's gut" is how decisions get made politically, not economically. The two popular frameworks — RICE and WSJF — force the team to write down on paper their assumptions about impact size, effort and delay penalty. The numbers are not sacred, but the conversation they trigger is far more useful than "I think this matters more".
1. RICE: for products with measurable users
RICE = (Reach × Impact × Confidence) ÷ Effort. Reach = how many users the feature touches in a period (next month, next quarter). Impact = how much it changes behaviour per user (scale 0.25/0.5/1/2/3). Confidence = how much you trust the estimates (50% / 80% / 100%). Effort = person-months.
Output is a RICE score per item — sort descending and you have your order. Real value is not in the score, it is in the discussion it forces: "OK, you claim Reach of 50,000 users — what is your source? If Impact is 3 (massive), what is the behaviour assumption?" You enforce rigour, you do not produce certainty.
2. WSJF: for roadmaps where time has a cost
WSJF (Weighted Shortest Job First) comes from SAFe and computes: (Business Value + Time Criticality + Risk Reduction) ÷ Job Size. The key difference vs. RICE: it explicitly includes Time Criticality — how much value you lose by shipping a month later.
Useful when you have external dependencies (a launch tied to a big customer, a regulator deadline, the Black Friday window). A feature with medium value but high time-criticality rises above a higher-value feature with no time pressure. That mirrors real decision economics.
3. Estimate in Fibonacci, not in days
Both RICE (Effort) and WSJF (Job Size) require sizing the work. Do it on a Fibonacci scale (1, 2, 3, 5, 8, 13, 20) — not in days or hours. The non-linear scale reflects reality: uncertainty grows exponentially with size, and 8 is not "twice 4", it is a different league.
The team sizes in 10 minutes using planning poker (everyone shows the card at the same time). The conversation about why one dev says 3 and another says 13 is more informative than the average — it surfaces different assumptions about scope or implementation.
4. Confidence intervals, not single numbers
A common trap: RICE score = 42.7. Sounds precise, it is illusory. Every input is estimated with ±50% error, so the final score sits between 20 and 90. Treat scores as intervals, not numbers — and overlapping intervals mean "equal", not "this one is better".
Practically: any difference under 30% between two RICE/WSJF scores is effectively a tie. That is where PM judgement counts — based on factors the formula does not capture (strategy, team momentum, blocking dependencies). The framework does not replace judgement, it calibrates it.
5. Re-prioritize on every major change, not monthly
A backlog prioritized once a quarter is stale in 2 weeks — the big customer asks for something new, the competitor ships a feature, the regulator changes the rules. Re-score with RICE/WSJF on every meaningful change, not on a monthly ritual.
Practically: keep RICE/WSJF scores next to every backlog item (visible column). When context shifts, open the affected items and adjust Reach/Impact/Time Criticality. Sort order updates automatically. That converts the framework from a quarterly ceremony into a live mechanism.
Prioritised backlog in 4myprojects
The order you settle on with RICE or WSJF lives in the backlog itself: a priority and labels on every item, story points for size, and the comment where you argued the score right next to the task — no parallel spreadsheet.