When every project feels urgent and nothing gets done
You’re sitting in a meeting with five projects on the table – a security upgrade, a customer-requested feature, a marketing redesign, an internal tool, and a tech debt sprint – and three stakeholders who each think theirs is the priority. The meeting ends with “let’s revisit this next week.” The RICE prioritization framework was built for exactly this kind of gridlock. Sean McBride, a product manager at Intercom, created the RICE scoring model in 2018 to replace opinion-driven debates with a four-factor formula that produces a single, comparable score for every initiative [1].
The framework scores each project on Reach, Impact, Confidence, and Effort, then generates a number you can rank against competing options. It doesn’t eliminate judgment – but it structures judgment so that two people looking at the same scores can have a productive conversation instead of a circular argument.
This guide walks you through the exact RICE formula, shows you how to estimate each factor when data is incomplete, and gives you a process for turning scored lists into defensible decisions.
RICE prioritization framework is a quantitative scoring model that ranks competing initiatives by multiplying Reach, Impact, and Confidence, then dividing by Effort, producing a single score that represents expected value per unit of work invested. It transforms subjective judgment into measurable rankings, enabling teams to build product roadmap prioritization based on comparable, evidence-weighted factors rather than opinion.
Key takeaways
- RICE scores rank projects by expected value per unit of effort, reducing reliance on gut instinct or office politics.
- The formula is (Reach x Impact x Confidence) / Effort, where each factor follows a defined scale.
- Impact uses a fixed scale (3, 2, 1, 0.5, 0.25) to prevent score inflation from vague optimism.
- Confidence percentages (50%, 80%, 100%) force you to flag when you’re guessing rather than knowing.
- RICE works best as a conversation starter, not a final verdict on what to build or pursue.
- The Score Integrity Test catches inflated confidence and sandbagged effort before they distort rankings.
- Projects with high Reach but low Confidence often beat low-Reach, high-Confidence pet projects once scored honestly.
How does the RICE prioritization framework formula work?
The RICE formula compresses four factors into a single comparable score. The calculation is straightforward: multiply Reach by Impact by Confidence, then divide by Effort. The result represents how much value a project delivers relative to the resources it consumes.
RICE Score = (Reach x Impact x Confidence) / Effort
Sean McBride designed the formula at Intercom to solve a specific problem: product teams kept arguing about which features to build without any shared criteria for comparison [1]. Each factor captures a different dimension of a project’s potential, and together they produce a score that accounts for both upside and uncertainty.
Here’s what makes this different from a simple cost-benefit analysis: the Confidence factor. Most prioritization methods treat your estimates as equally reliable. RICE forces you to flag which estimates are backed by data and which are educated guesses. That single addition changes how teams talk about their priorities.
Reach is the number of people or events an initiative will affect within a defined time period, measured in concrete units such as customers per quarter, transactions per month, or page views per week.
Impact is the expected magnitude of effect on each person reached, scored on a fixed scale where 3 = massive, 2 = high, 1 = medium, 0.5 = low, and 0.25 = minimal.
Confidence is the percentage expressing how certain the estimator is about the Reach, Impact, and Effort numbers. It represents high certainty (data-backed), moderate certainty (partial data), or low certainty (mostly guessing), typically scored at 100%, 80%, or 50%.
Effort is the total amount of work required to complete an initiative, measured in person-months or person-weeks, including all team members involved.
The RICE prioritization framework converts subjective judgment into structured, comparable scores by separating each dimension of value and uncertainty into its own measurable factor. Separating each dimension of value into its own measurable factor is the mechanism that makes RICE useful. When someone says “this project is more important,” RICE asks: more important on which dimension?
How do you estimate each RICE factor when data is incomplete?
When data is incomplete, use proxy metrics for Reach, default to Impact score 1 unless you have evidence of higher effect, assign Confidence percentages honestly (50% for guesses, 80% for partial data, 100% for strong data), and round Effort estimates up by 50% based on estimation research showing systematic underestimation [3]. Perfect data doesn’t exist for most prioritization decisions. In practice, many product teams lack reliable quantitative data for all four RICE factors when scoring new initiatives. The rest are estimating at least two factors from incomplete information. That’s normal, and the framework accounts for it. Data-driven prioritization requires making educated estimates when perfect information is unavailable.
Estimating reach
Reach is the most data-friendly factor. Pull numbers from analytics platforms, customer counts, or transaction logs. If you’re scoring a product feature, Reach might be “customers who visit the pricing page per month.” If you’re scoring a content project, it could be “monthly search volume for the target keyword.”
When you don’t have direct data, use proxy metrics. A blog post targeting a keyword with 5,000 monthly searches has an estimated Reach of 5,000. A process improvement affecting everyone in a 40-person department has a Reach of 40. The key is defining the time period upfront and keeping it consistent across all projects you’re comparing. For entirely new markets with no analog data, use the total addressable population as an upper bound and discount by a realistic adoption assumption – a product targeting 50,000 small businesses with a realistic 5% capture rate has a working Reach of 2,500 per year.
Scoring impact
Impact is where people introduce the most bias. The fixed scale (3, 2, 1, 0.5, 0.25) exists for a reason: it constrains how much enthusiasm can inflate a score. Research on planning and estimation shows that people routinely overestimate the positive effects of projects they personally champion [2]. As Jorgensen and Shepperd’s systematic review of estimation research confirms, even experienced professionals demonstrate consistent bias toward optimistic project assessments [3].
Score a 3 only when you have evidence that the initiative will dramatically change behavior or outcomes for the people it reaches. A 1 is the correct default for most initiatives. Reserve 0.25 for projects where the effect on each individual is barely noticeable, regardless of how high Reach is.
| Impact Score | Label | When to Use | Example |
|---|---|---|---|
| 3 | Massive | Fundamentally changes user workflow or outcome | Launching a feature that eliminates a top-3 customer complaint |
| 2 | High | Significant measurable improvement | Reducing onboarding time by 40% |
| 1 | Medium | Noticeable but not transformative | Adding a shortcut that saves 2 clicks per session |
| 0.5 | Low | Minor convenience or marginal gain | UI polish that looks better but doesn’t change behavior |
| 0.25 | Minimal | Barely perceptible effect per person | Fixing a tooltip typo on a settings page |
Assigning confidence
Confidence is the honesty check. Score 100% when you have strong data backing your Reach, Impact, and Effort estimates. Score 80% when you have some data but are extrapolating. Score 50% when you’re mostly guessing (McBride [1]).
Confidence percentages in RICE scoring function as a built-in penalty for uncertainty, automatically discounting projects where the estimated value rests on shaky assumptions. This is the factor most people get wrong. Teams frequently assign 80% confidence to projects they’re excited about and 50% to projects they want to deprioritize, regardless of the actual evidence quality. Research on optimism bias and overconfidence in organizational decision-making confirms this pattern: managers consistently overrate their certainty on preferred initiatives, and optimism bias is among the top contributors to flawed project estimates [2][5].
Calculating effort
Measure Effort in person-months (or person-weeks for smaller projects). A project that takes one designer two weeks and one developer four weeks has an Effort of 1.5 person-months. Include everyone who contributes meaningful time: design, development, testing, content, and project management.
The most common Effort mistake is excluding non-obvious work. Stakeholder reviews, QA cycles, and documentation add up. Software estimation research consistently shows that projects exceed initial effort estimates, with overruns commonly in the 30% range across the studies reviewed, and wide variance by project type [3][6]. Add a buffer or round up.
“RICE scores shouldn’t be used as a hard and fast rule. There are many reasons why you might work on a project with a lower score first.” – Sean McBride, Intercom [1]
RICE scoring walkthrough: three projects compared
Theory matters less than practice. Here’s how RICE scoring plays out when you compare three real project types side by side. Each project uses the same formula and the same scales, which is exactly why the scores become comparable.
| Factor | Project A: Onboarding redesign | Project B: Mobile app notification | Project C: Internal reporting dashboard |
|---|---|---|---|
| Reach (per quarter) | 3,000 new users | 15,000 active users | 40 team members |
| Impact (0.25-3) | 2 (high) | 0.5 (low) | 2 (high) |
| Confidence (%) | 80% | 80% | 100% |
| Effort (person-months) | 4 | 1 | 3 |
| RICE Score | 1,200 | 6,000 | 26.7 |
Project B wins the ranking, and it has the lowest Impact score per user. Why? Reach. Fifteen thousand users experiencing even a small improvement outweighs 3,000 users experiencing a bigger one, especially when the effort is one quarter of the alternative. Project C scores last – not for lack of value, but for reaching only 40 people.
This is where RICE earns its keep. Without the scores, Project A likely wins the argument – “redesigning onboarding” sounds more impressive than “adding push notifications.” The numbers tell a different story.
A scored RICE ranking makes hidden tradeoffs visible, turning “I feel like Project A matters more” into “Project A scores lower on Reach but higher on Impact, so here’s the specific bet we’re making.” Score transparency is what makes RICE useful beyond the math.
When running RICE with a team, assign each factor to whoever owns the best data for it. Product typically estimates Reach using analytics. The project lead or engineering manager estimates Effort. Impact is scored collaboratively, with the team voting independently before discussing, to prevent anchoring on the first number someone says. Confidence is set by the person with the most direct evidence, not the loudest advocate. A first-pass group scoring session for five projects usually takes 45 to 60 minutes, including discussion of any scores where team members diverged by more than one tier.
Blank RICE scoring template
Copy the structure below into a spreadsheet to score your own projects. Each row is one initiative; the formula auto-calculates the RICE Score column.
| Project Name | Reach (per [time period]) | Impact (0.25-3) | Confidence (50%/80%/100%) | Effort (person-months) | RICE Score |
|---|---|---|---|---|---|
| [Initiative 1] | = (Reach x Impact x Confidence) / Effort | ||||
| [Initiative 2] | = (Reach x Impact x Confidence) / Effort | ||||
| [Initiative 3] | = (Reach x Impact x Confidence) / Effort | ||||
| [Initiative 4] | = (Reach x Impact x Confidence) / Effort | ||||
| [Initiative 5] | = (Reach x Impact x Confidence) / Effort |
How to use: Define a consistent time period for Reach across all rows. Score Impact using only the fixed scale (3, 2, 1, 0.5, 0.25). Assign Confidence honestly using only 50%, 80%, or 100%. Count all contributors when estimating Effort. Sort by RICE Score descending to see your ranked list.
RICE score calculator (Google Sheets formula)
In Google Sheets, if Reach is in column B, Impact in C, Confidence in D, and Effort in E, the formula for row 2 is =(B2*C2*D2)/E2. For Confidence entered as a percentage (e.g., 80%), use =(B2*C2*(D2/100))/E2 instead. Paste that formula into the RICE Score column for every row and the sheet will rank automatically when you sort column F from largest to smallest.
RICE scoring biases: what quietly wrecks your rankings
RICE is only as honest as the people filling in the numbers. Three bias patterns show up consistently in practice, and all three produce rankings that look data-driven but aren’t.
Bias 1: Confidence inflation on pet projects. Confidence inflation is the tendency to assign higher certainty percentages to projects the estimator personally championed. Someone who championed a project idea scores their confidence at 80% when the honest answer is 50%. Research on optimism bias shows that project advocates often overestimate success probability [2]. The fix: have someone who didn’t propose the project assign the confidence score independently.
Bias 2: Effort sandbagging on favored initiatives. Effort sandbagging is the practice of undercounting person-months required for a favored project in order to inflate its RICE score. If three projects all have effort estimates of “about 2 months,” question the consistency. Break effort into phases and count every contributor’s time.
A third pattern is Reach cherry-picking: selecting the time window or user segment that makes a project’s reach look highest while ignoring less favorable definitions. If you measure reach per quarter for one project and per year for another, the comparison is meaningless [4]. Lock in one time period for all projects before scoring begins.
The biggest threat to RICE ranking accuracy is not missing data – it is the selective optimism people apply to projects they personally champion. Research on motivated reasoning in teams confirms that scoring frameworks reduce but don’t eliminate preference-driven bias [4]. The framework works best when you add procedural safeguards around how scores get generated.
The RICE Score Integrity Test: catching inflated rankings before they stick
We call this the Score Integrity Test – a diagnostic we developed to catch the three most common distortions before they corrupt your RICE rankings. The test works by asking three questions about every RICE score that lands in your top five.
Question 1: “If I cut Confidence by one tier, does this project still rank in the top half?” Drop a 100% to 80%, or an 80% to 50%. If the project falls out of the top half, its ranking depends heavily on optimism rather than evidence. That’s a signal to gather more data before committing resources.
Question 2: “If Effort doubled, would I still pursue this?” Software estimation research consistently shows that projects exceed initial effort estimates, often by 30% or more [3][6]. If doubling the effort estimate kills the project’s case entirely, the score is fragile.
Question 3: “Can I explain the Reach number to someone unfamiliar with the project in one sentence?” If you can’t, the reach estimate may be a composite of optimistic assumptions rather than a concrete metric. “2,500 users who visit the pricing page monthly” passes. “About 2,500 people who might benefit” does not.
The Score Integrity Test targets the exact points where human judgment introduces systematic error into RICE scores. Running this check adds about five minutes per project, and it has a way of reshuffling rankings that felt certain before the test.
Score integrity test – quick reference
For each project in your top 5:
- Confidence Stress Test: Drop Confidence by one tier. Still in top half? If no, gather more data first.
- Effort Resilience Check: Double the Effort estimate. Still worth doing? If no, the score is fragile.
- Reach Clarity Test: Explain the Reach number in one sentence to an outsider. If you can’t, refine the estimate.
If a project survives all three checks, the RICE score is solid. If it fails two or more, treat the ranking as preliminary until you can strengthen the underlying estimates. This is the difference between using RICE as a rubber stamp and using it as a genuine decision tool.
How does RICE compare to other prioritization methods?
RICE is best suited for comparing 5-30 dissimilar initiatives where uncertainty varies across projects; the Eisenhower Matrix is better for daily triage, and MoSCoW is better for categorical scope decisions.
| Method | Best for | Scoring type | Handles uncertainty | Time to implement |
|---|---|---|---|---|
| RICE | Comparing 5-30 initiatives with varied Reach | Quantitative (formula) | Yes (Confidence factor) | 1-2 hours per round |
| ICE | Scoring when all items affect the same user base | Quantitative (formula) | Yes (Confidence factor) | 30-60 minutes |
| Eisenhower Matrix | Daily task sorting by urgency and importance | Qualitative (2×2 grid) | No | 5-10 minutes |
| 1-3-5 rule | Limiting daily task count | Constraint-based | No | 2 minutes |
| MoSCoW | Categorizing features into Must/Should/Could/Won’t | Qualitative (categories) | No | 30-60 minutes |
| Value vs. Effort | Quick scoring when you have only two dimensions | Quantitative (2×2 matrix) | No | 15 minutes |
ICE scoring (Impact, Confidence, Effort) is RICE without the Reach factor. It uses the same formula structure but drops the audience-size multiplier. ICE works well when every item on your list affects the same user base and Reach would be identical across all candidates, making it a redundant input. When your list mixes initiatives that touch very different user populations, RICE adds the Reach factor to surface that difference. If you find yourself debating whether two projects have meaningfully different Reach, that is the signal RICE is the right tool.
RICE shines when you need to compare dissimilar projects – a revenue feature against a technical debt cleanup against a customer support improvement. The Eisenhower Matrix works better for daily triage. The 1-3-5 rule works better when you’re cutting a bloated task list down to what matters most. No single framework handles every prioritization challenge.
RICE adds the most value when you’re comparing unlike initiatives that cannot be evaluated on a single dimension – the four-factor formula creates a common scoring language for projects that otherwise resist comparison. For simpler daily decisions, lighter methods like the ABC method or eat that frog get the job done faster.
When NOT to use RICE
RICE is overkill in three situations. First, daily task sorting: if you’re deciding what to work on this afternoon, the overhead of estimating four factors per task wastes more time than it saves. Use the Eisenhower Matrix or a simple 1-3-5 rule instead. Second, decisions with fewer than three options: when you’re choosing between two projects, a direct pros-and-cons conversation is faster and produces the same outcome. Third, personal to-do lists: RICE was designed for team decisions where multiple people need a shared scoring language. Solo prioritization rarely benefits from the formula’s structure.
RICE is also the wrong tool for sprint-level decisions. Sprint planning works with a backlog that already reflects quarterly priorities; scoring individual stories with RICE adds overhead without changing the ranking, since the items are usually scoped to the same sprint and have similar Reach. Use RICE at the quarterly roadmap or epic level to decide which bets to take, then let your sprint process manage execution sequencing within those bets.
Ramon’s take
RICE’s real strength isn’t the math – it’s forcing the Confidence question nobody wants to ask. In managing global campaigns, the projects that caused the most grief weren’t the low-scorers; they were the high-scorers where nobody questioned the assumptions. I remember a quarterly planning session where a feature redesign scored a 2,400 – highest on the board by a wide margin. Everyone nodded along until someone asked, “What’s the Confidence based on?” The room went quiet. The answer was a single customer interview and a gut feeling. We dropped Confidence from 80% to 50%, and the project fell from first to fourth. That one question saved the team from committing a full quarter to a bet nobody could defend. That’s why the Score Integrity Test matters more than the formula itself. Run it every time, especially on the projects you’re most excited about.
Conclusion: putting your RICE prioritization framework into practice
The RICE prioritization framework doesn’t make hard decisions easy. It makes them transparent. When you score Reach, Impact, Confidence, and Effort separately, you see exactly where your assumptions live and exactly where two projects differ. That visibility is what turns circular debates into 30-minute decisions with a clear output. When your top-ranked projects survive the Score Integrity Test, you know the rankings rest on evidence rather than enthusiasm.
RICE doesn’t make the hard call for you. It makes the hard call visible – so you can make it with your eyes open.
Next 10 minutes
- List 3-5 projects or tasks currently competing for your time.
- Estimate Reach for each one using the simplest available metric (users, tasks, people affected).
- Score each project’s Impact using the 3/2/1/0.5/0.25 scale.
This week
- Complete the full RICE calculation for all 3-5 projects, including Confidence and Effort.
- Run the Score Integrity Test on your top two projects to check for inflated estimates.
- Share the scored list with one colleague or stakeholder to test whether the rankings hold up in conversation.
There is more to explore
For a broader view of how different scoring methods fit together, explore our guide on prioritization strategies. If you’re interested in categorical sorting instead of numerical scoring, the MoSCoW framework divides items into must-have vs. nice-to-have buckets. For daily task triage, the 1-3-5 rule provides a faster filter.
Related articles in this guide
Frequently asked questions
How do I estimate Reach when I don’t have analytics data?
Use proxy metrics from the closest available source. For internal projects, count the people in the affected department. For content projects, use search volume data from free tools like Google Keyword Planner. For product ideas without usage data, survey a small sample or use industry benchmarks for similar features. The goal is a defensible number, not a perfect one.
What scale should I use for measuring Impact in RICE?
Use the standard five-point scale: 3 (massive), 2 (high), 1 (medium), 0.5 (low), 0.25 (minimal). This constrained scale prevents the common problem of everyone scoring their favorite project as an 8 or 9 on an open-ended scale. If you and a colleague disagree on an Impact score, discuss the specific behavioral change you expect for each person reached rather than debating the number itself.
Should Effort include all team members or only my own time?
Include everyone who contributes meaningful work, including part-time contributors. A designer who spends two days a week on a six-week project contributes 0.6 person-months, not zero. The same logic applies to PM coordination, stakeholder review cycles, and QA passes. Excluding these inputs makes projects look cheaper than they are and produces inflated RICE scores. If a contributor’s total time on the project is less than one full day, it is reasonable to omit them from the Effort estimate to keep the calculation practical.
How often should I recalculate RICE scores for ongoing projects?
Quarterly recalculation catches the most common drift. Reach estimates change as markets shift, Confidence increases as you gather data during early execution, and Effort estimates become more accurate after the first sprint. Research on software estimation suggests that mid-project re-estimation improves accuracy, though the magnitude varies by context [3].
Can RICE be used outside of product management for personal goals?
RICE adapts to personal prioritization by redefining the factors: Reach becomes the number of life areas affected (career, health, relationships), Impact stays as the expected magnitude of change, Confidence reflects how sure you are the goal is achievable, and Effort becomes hours per week required. The formula works the same way. The main limitation is that personal goals often involve emotional weight that a quantitative score cannot capture.
What do I do when a low-scoring project is politically required?
Score it honestly and document the override. Record the RICE score, then note that the project was prioritized for strategic or political reasons that the framework does not capture. This preserves the integrity of your scoring system for future decisions and creates a record of how often non-score factors override the data. Over time, a pattern of frequent overrides signals that either the scoring criteria need updating or the decision process needs restructuring.
How do I know if my RICE scores are reliable?
Use the Score Integrity Test described in this guide to stress-test your top projects. When a project fails one or more checks, the next step is not to discard it but to identify which estimate is weakest. A project that fails the Confidence stress test needs more user research or usage data before you commit resources. One that fails the Effort resilience check needs a more detailed work breakdown before it earns a high ranking. Failing the Reach clarity test usually means the scope definition needs tightening. Treat a failed check as a specific action item, not a verdict against the project.
What is a good RICE score?
RICE scores are relative rankings, not absolute thresholds. There is no universal score that counts as good or bad. A score of 500 might be your highest-ranked project in one backlog and your lowest in another. What matters is the ordering: the project with the highest score is the one to prioritize next, regardless of its absolute value. The only question RICE answers is which project ranks above which other project in your current list.
This article is part of our Prioritization Methods complete guide.
References
[1] McBride, S. “RICE: Simple Prioritization for Product Managers.” Intercom Blog, 2018. https://www.intercom.com/blog/rice-simple-prioritization-for-product-managers/
[2] Lovallo, D. and Kahneman, D. “Delusions of Success: How Optimism Undermines Executives’ Decisions.” Harvard Business Review, 81(7), 56-63, July 2003. https://hbr.org/2003/07/delusions-of-success-how-optimism-undermines-executives-decisions
[3] Jorgensen, M. and Shepperd, M. “A Systematic Review of Software Development Cost Estimation Studies.” IEEE Transactions on Software Engineering, 33(1), 33-53, 2007. https://doi.org/10.1109/TSE.2007.256943
[4] Kunda, Z. “The Case for Motivated Reasoning.” Psychological Bulletin, 108(3), 480-498, 1990. https://doi.org/10.1037/0033-2909.108.3.480
[5] Flyvbjerg, B. “Top Ten Behavioral Biases in Project Management: An Overview.” Project Management Journal, 52(6), 531-546, 2021. https://doi.org/10.1177/87569728211049046
[6] Molokken, K. and Jorgensen, M. “A Review of Surveys on Software Effort Estimation.” Proceedings of the 2003 International Symposium on Empirical Software Engineering (ISESE), IEEE, 2003, pp. 223-230.
