RICE Scoring: Data-Driven Prioritization

RICE scores a feature with one number: (Reach × Impact × Confidence) / Effort.

Start Here: What Is RICE?

The Problem: The Overloaded Backlog

Your backlog has 147 feature requests.

Sales wants their features. Customer Success has a list from churning customers. Engineering needs to fix technical debt. The CEO just added three "urgent" items.

Sound familiar?

This is reality. The average product team has 3-4x more requests than capacity¹. Without a system, the loudest voice wins and politics fill the gap.

Defending your roadmap becomes a nightmare.

The Solution: A Score for Every Item

You need a score that weighs how many users a feature affects, how much it helps each one, how confident you are, and how much work it takes. RICE does exactly that.

Developed at Intercom, RICE quantifies value objectively².

The formula:

RICE Score = (Reach × Impact × Confidence) / Effort

Score every feature. Replace debates with data.

The Four Components

1. REACH: How Many Users?

Simple Definition: Count the actual number of users who will experience this feature in your chosen time period.

Quick Rule: Use real numbers, not percentages. Be specific.

Common Beginner Mistake: Saying "all users" when you mean "users who click settings" (usually 10-20%).

Pro Tip: Check your analytics for actual usage numbers. Don't guess.

2. IMPACT: How Much Does It Matter?

Simple Definition: How much will this improve the experience for each affected user?

The Impact Scale - Choose One:

Quick Test: Ask yourself - "If we removed this feature after launch, how angry would users be?"

• Riots = 3
• Complaints = 2
• Some grumbles = 1
• Barely notice = 0.5 or less

3. CONFIDENCE: How Sure Are We?

Simple Definition: How certain are you that your Reach and Impact estimates are correct?

The Confidence Scale:

Important Rule: Start at 50% for everything new. Only go higher with real evidence.

Reality Check: If everything is 80-100%, you're overconfident. Most features should be 50-80%.

4. EFFORT: What's the Total Cost?

Simple Definition: Total person-months needed from start to users actually using it.

The Complete Effort Checklist:

Real Example - Adding Filters to a Dashboard:

Discovery: 0.5 PM weeks = 0.125 person-months
Design: 2 designer weeks = 0.5 person-months  
Development: 2 engineers × 3 weeks = 1.5 person-months
Testing: 1 QA × 1 week = 0.25 person-months
Launch: 0.5 PM weeks = 0.125 person-months
Subtotal: 2.5 person-months
+ 30% buffer for unknowns = 3.25 person-months total

Beginner Rule: Always add 30% buffer. Things take longer than expected.

Try It Now

Score a real feature:

Walk-Through Example: Scoring Dark Mode

Let's score "Add dark mode to mobile app" step-by-step to see how RICE works in practice.

Step 1 - REACH: Who will use this?

• Total mobile users: 100,000 MAU
• Analytics shows 50% use app settings
• Thinking: "50,000 users will see and potentially enable dark mode"
• Reach = 50,000

Step 2 - IMPACT: How much will it help each user?

• User feedback: "Would be nice to have for night reading"
• Doesn't solve a core problem, just improves comfort
• Using our scale: This is a "nice improvement"
• Impact = 1 (Medium)

Step 3 - CONFIDENCE: How sure are we?

• Evidence: 20 user requests, competitors have it
• No tests run, but logical that some users want it
• This is more than a guess but not proven
• Confidence = 70%

Step 4 - EFFORT: What will it take?

Design: 1 designer × 1 week = 0.25 person-months
Development: 2 engineers × 2 weeks = 1 person-month
Testing: 1 QA × 0.5 weeks = 0.125 person-months
Documentation: 0.125 person-months
Subtotal: 1.5 person-months
+ 30% buffer = 2 person-months total

• Effort = 2

Step 5 - Calculate RICE Score:

RICE = (50,000 × 1 × 0.70) / 2 = 17,500

What This Score Means:

• 17,500 is a moderate score
• Compare to your other features:
  • Critical bug fix: RICE = 100,000+
  • Nice-to-have feature: RICE = 5,000-20,000
  • Low-priority item: RICE < 5,000
• Dark mode would rank middle-of-the-road in most backlogs

Real-World Examples

Intercom's Team Inbox

The original RICE use case²:

• Reach: 2,000 customers/quarter
• Impact: 3 (Massive - key differentiator)
• Confidence: 80% (extensive interviews)
• Effort: 4 person-months
• RICE: 1,200

Lesson: High effort justified by massive impact for key segment.

Spotify's Discover Weekly (Hypothetical)

• Reach: 100 million users/month
• Impact: 2 (High - drives engagement)
• Confidence: 60% (algorithm unproven)
• Effort: 10 person-months
• RICE: 12,000,000

Lesson: Massive reach makes high effort worthwhile.

Notion's Database Feature (Hypothetical)

• Reach: 10,000 power users/month
• Impact: 3 (reshapes the product)
• Confidence: 90% (deep research)
• Effort: 20 person-months
• RICE: 1,350

Lesson: Strategic value can outweigh moderate RICE score. The framework doesn't capture everything.

Common Mistakes Beginners Make

Here are the most common RICE scoring mistakes and how to avoid them:

1. The "Everyone Will Use It" Trap

What Happens: You score Reach as 100% of users for a settings menu feature. Reality Check: Only 10-20% of users ever open settings. How to Fix:

• Check your analytics for actual feature usage
• Look at similar features' adoption rates
• When in doubt, divide your estimate by 5

2. The "Everything Is High Impact" Problem

What Happens: Every feature gets Impact = 2 or 3 because "it's important." Reality Check: If everything is high impact, nothing is. How to Fix:

• Force yourself to have only 20% of features at Impact = 3
• Define specific metrics: "High = 10%+ improvement in our key metric"
• Compare new features to past launches - what was their real impact?

3. The "We're Pretty Sure" Overconfidence

What Happens: Everything is 80-100% confidence because you discussed it in a meeting. Reality Check: Most features should be 50% confidence until tested. How to Fix:

• Start everything at 50% confidence
• Only increase with real evidence (user interviews, data, tests)
• Track your predictions vs reality - you're probably overconfident

4. The "It's Just Coding" Effort Mistake

What Happens: Effort = 2 engineers × 2 weeks = 1 person-month. Done! Reality Check: You forgot design, testing, documentation, and delays. How to Fix:

• Use the complete effort checklist (see above)
• Always add 30% buffer for beginners, 20% once experienced
• Ask each team lead separately, then add it up

5. The "Different Time Periods" Mix-Up

What Happens: Feature A uses monthly reach, Feature B uses quarterly, Feature C uses yearly. Reality Check: You can't compare scores with different time periods. How to Fix:

• Pick one standard (monthly or quarterly)
• Convert all features to the same time period
• Put the time period in your spreadsheet header as a reminder

AI Prompts for RICE Scoring

Estimate Reach

Estimate Reach for these features based on our segments:
[paste features and user data]
- Total users: [X]
- Segments: [list segments and sizes]
- Feature usage patterns: [current behavior]
Provide monthly reach with reasoning.

Score Impact

Score Impact using our North Star metric:
[paste features]
North Star: [your key metric]
Current baseline: [performance]
Scale: 0.25 (Minimal) to 3 (Massive)
Justify with expected metric improvement.

Assess Confidence

Generate Confidence scores from this research:
[paste research findings]
Assess:
- User evidence (quotes, surveys)
- Competitive analysis
- Technical feasibility
- Similar past features
Output percentage with justification.

Estimate Effort

Estimate effort in person-months for:
[feature description]
Consider:
- Frontend development
- Backend development
- Design work
- QA/Testing
- Documentation
- Rollout complexity
Break down by role and phase.

When to Override RICE Scores

Sometimes you need to build something despite a low score:

• Platform work that future features depend on
• Strategic partnerships or key customer needs
• Compliance or security requirements
• Technical debt that's blocking development

Key Rule: Document why you're overriding RICE. Review these decisions quarterly.

RICE vs Other Frameworks

Progression Path: Most teams evolve from ICE → RICE → Custom weighted scoring as they mature.

Troubleshooting Your RICE Implementation

Problem: "Our scores are all over the place"

Symptom: Team members' scores differ by 10x for the same feature Solution:

• Create a scoring rubric with specific examples
• Do calibration exercises with past features
• Start with comparing rankings, not absolute scores

Problem: "Everything scores low"

Symptom: All features get RICE scores under 1,000 Solution:

• Check your time period - maybe switch from monthly to quarterly
• Your estimates might be too conservative
• Remember: low scores are fine if they're relatively accurate

Problem: "The highest score isn't what we should build"

Symptom: RICE says Feature A, but strategy needs Feature B Solution:

• This is normal! RICE is input, not gospel
• Document strategic overrides
• Consider if you need weighted scoring instead

Problem: "It takes forever to score everything"

Symptom: Spending hours debating each score Solution:

• Time-box scoring to 5 minutes per feature
• Use rough estimates: 10, 100, 1000, not 47 vs 52
• Score in batches, not one by one

Problem: "Our predictions are always wrong"

Symptom: Actual impact never matches estimates Solution:

• Lower all confidence scores by 20%
• Track predictions vs reality for learning
• Focus on relative accuracy, not absolute

Roll It Out

RICE facilitates discussion. It doesn't end it. Work through the plan below over a month, then keep it running.

Week 1: Start Small (30 minutes)

Monday (10 min): Pick your standard time period (monthly or quarterly) Wednesday (10 min): Score your top 3 features using the calculator above Friday (10 min): Share scores with your team, get their reaction

Week 2: Expand (2 hours total)

Monday (1 hour): Score your entire sprint backlog Wednesday (30 min): Review scores with your tech lead Friday (30 min): Present top 5 RICE scores in sprint planning

Week 3: Align (3 hours total)

Team Workshop (2 hours):

• Everyone scores the same 5 features independently
• Compare and discuss differences
• Create your team's Impact definitions
• Document your scoring rules

Follow-up (1 hour): Update all backlog items with RICE scores

Week 4 and Beyond: Refine

• Track whether high RICE features actually delivered value
• Adjust your confidence scoring based on results
• Add RICE scoring to your feature request template
• Review and recalibrate quarterly

When you present to stakeholders, share the scores and the math behind them, not just the ranking. Be clear about when you've overridden a score and why.

Key Takeaways

RICE beats politics. Data wins arguments. When someone says "we must build this," show the scores.

Start at 50% confidence. You're not as sure as you think. Only go higher with real evidence.

Effort includes everything. Discovery, design, development, testing, launch. Add 30% buffer.

Your first scores will be wrong. That's fine. Start anyway.

Use RICE as input, not verdict. Strategic overrides are okay.

Next Steps

Try these next:

1. Score features with our RICE Calculator
2. Try simplified ICE Scoring for smaller teams
3. Use Weighted Scoring for custom criteria
4. Plot on Impact/Effort Matrix for visualization

Sources