Summary: The Feature Prioritization Matrix is a compact, repeatable framework for founders and product leaders to rank and decide which features to build next, supporting multiple scoring systems (Weighted Scoring, RICE, WSJF, Kano) and a formal decision process tied to measurable outcomes. To use it, pick an appropriate scoring model, consistently score and normalize candidates, bucket features into prioritized cohorts, and review with stakeholders while tracking confidence, dependencies, and outcomes (the provided template lists fields like Reach, Impact, Confidence, Effort, and various scores).

Feature Prioritization Matrix Template (Markdown)

Purpose

• A compact, repeatable framework founders and product leaders can use to rank and decide which features to build next.
• Supports multiple scoring systems (Weighted Scoring, RICE, WSJF, Kano) and a formalized decision process that ties prioritization to measurable outcomes.

How to use

1. Pick a scoring model (or combine models) that matches your business rhythm (e.g., RICE for growth experiments, WSJF for larger backlog with cost-of-delay concerns).
2. Score each candidate feature consistently using the defined scales and rubric.
3. Calculate scores, normalize if you combine models, and bucket features into prioritized cohorts.
4. Review with stakeholders, include confidence and dependencies, and iterate based on outcomes.

Template: Feature Prioritization Table

Feature ID	Feature name	Description	Owner	Reach	Impact	Confidence	Effort	Dependency	Kano	RICE Score	Weighted Score	WSJF	Priority
F-001	Example: Quick Onboarding	Reduce signup time from 3 min to 1 min	PM	2000/mo	6/10	0.8	2 PM	None	Performance	4800	7.1	2400/2 = 1200	P1

Notes

• Reach = number of users impacted in a time window (e.g., per month, quarter).
• Impact = business impact per user (scale, see rubric).
• Confidence = probability [0–1] reflecting evidence (research, data, experiments).
• Effort = normalized sizing (e.g., person-months, story points normalized to team velocity).
• Kano = qualitative tag: Must-have / Performance / Exciter / Indifferent / Reverse.
• RICE/W SJF/Weighted Score columns are computed (see formulas below).

Scoring rubrics (recommended)

Use objective anchors to keep scoring consistent.

Impact (per-user business impact 1–10)

• 0–1: negligible
• 2–3: small
• 4–6: moderate
• 7–8: significant
• 9–10: transformational

Reach (per-window)

• Absolute number (users per month or quarter). Use consistent timeframe.

Confidence (0–1)

• 0.25: Gut feel
• 0.5: Some qualitative evidence
• 0.75: Data-backed + prototype
• 0.9–1.0: Experiment-proven

Effort (person-months or normalized story points)

• Use consistent unit across backlog.

Kano mapping

• Must-have: essential; deprioritize using pure score (but still required).
• Performance: linear value increase.
• Exciter/Delighter: high perceived user love, may have non-linear impact.

Included models & math

1. Weighted Scoring (generic, multi-criteria)

• Let criteria i ∈ {1..n}, each feature has score s_i and weight w_i (weights reflect strategic priority).

• Weighted score S:

  S = (Σ_{i=1..n} w_i * s_i) / (Σ_{i=1..n} w_i)

• Spreadsheet (row 2, criteria in B2:E2, weights in B1:E1):

  =SUMPRODUCT(B2:E2,$B$1:$E$1)/SUM($B$1:$E$1)
  

2. RICE (Reach, Impact, Confidence, Effort) good for growth/features with measurable reach

• Let R = Reach, I = Impact, C = Confidence (0–1), E = Effort.

• RICE score:

  RICE = (R * I * C) / E

• Sheet example:

  =(R2 * I2 * C2) / E2
  

3. WSJF (Weighted Shortest Job First) for cost-of-delay scheduling (SAFe-style)

• JobSize (often same as Effort). Cost of Delay (CoD) often decomposed:
  CoD = UserBusinessValue + TimeCriticality + RiskReduction / OpportunityEnablement

• WSJF = CoD / JobSize

• Use normalized scoring for CoD components when mixing scales.

• Example CoD: if using 1–10 for each subcomponent:

  CoD = VB + TC + RR
  WSJF = CoD / JobSize
  

4. Normalization (to combine models)

• Min-max normalization to [0,1] for a column x:

  x' = (x - min(x)) / (max(x) - min(x))

• If max = min, set x' = 0.5 (neutral).

• Sheet formula (range B2:B100, cell B2):

  =(B2 - MIN($B$2:$B$100)) / (MAX($B$2:$B$100) - MIN($B$2:$B$100))
  

5. Confidence-weighted scoring (combines score with certainty)

• If S_raw is a raw score (e.g., expected value), then:

  S_weighted = S_raw * Confidence

• Useful to down-weight speculative bets.

Worked example (RICE + Weighted)

Feature F-001 values:

• Reach R = 2000 users / month
• Impact I = 6 (scale 1–10)
• Confidence C = 0.8
• Effort E = 2 person-months

RICE:

• RICE = (2000 * 6 * 0.8) / 2 = (9600) / 2 = 4800

Weighted (example combining Impact, Effort, Risk with weights)

• Criteria: Impact (w=0.5) score=6; Effort (inverse scoring: lower is better) turn Effort to Ease e = 10 - normalized_effort_score = 8; RiskReduction (w=0.2) score=4
• Weighted S = (0.56 + 0.38 + 0.2*4) / (0.5+0.3+0.2) = (3 + 2.4 + 0.8) / 1 = 6.2

Note: Keep units meaningful mixing absolute Reach with scaled Impact requires normalization (see normalization section).

Spreadsheet implementation tips

• Use separate columns for raw inputs and normalized inputs. Keep formulas visible for auditability.
• Protect header row with weights (fixed cells with $).
• Use named ranges for clarity (e.g., =SUMPRODUCT(FeatureScores,Weights)/SUM(Weights)).
• Add a Confidence column and compute Confidence-weighted score = Score * Confidence.
• Add a Dependency column and use it to bump priority or block scheduling until dependency resolved.
• Conditional formatting:
  • Top 10% (green), next 20% (amber), bottom 70% (red) based on final priority score.
  • Highlight low-confidence (C < 0.5) in yellow.

Example Excel formula snippets:

• RICE: =(B2C2D2)/E2
• Normalize column B: =(B2-MIN($B$2:$B$100))/(MAX($B$2:$B$100)-MIN($B$2:$B$100))
• Weighted score: =SUMPRODUCT(B2:E2,1:1)/SUM(1:1)

Best practices for founders (concise, actionable)

1. Align criteria to strategy: weights must reflect company objectives (growth, retention, revenue). Revisit quarterly.
2. Use outcome-based metrics: prioritize features by expected impact on key metrics (ARR, MAU, activation rate), not vanity proxies.
3. Include reach explicitly: a high-impact feature that touches few users may still be low priority vs moderate-impact affecting many.
4. Use confidence as a first-class input: reduce exploratory risk with prototypes, experiments, and data before full investment.
5. Prefer simple models early: start with RICE or a 3–4 criterion weighted model. Complexity later only if you have >100 candidates.
6. Normalize before combining: do not sum raw Reach (absolute) with Impact (1–10) without converting to the same scale.
7. Protect must-haves: Kano “must-haves” may be low-scoring but necessary treat them as maintenance or mandatory priorities.
8. Make prioritization a governance process: weekly triage + monthly strategic review with stakeholders. Keep the decision trail.
9. Track outcomes, not just outputs: measure expected vs actual impact post-launch and update confidence/scoring heuristics accordingly.
10. Account for dependencies and strategic sequencing: multiply priority by a blocker factor or tag features as “blocked”.
11. Use cost-of-delay for timing decisions: when time-to-market matters, WSJF helps order features by urgency per unit of effort.
12. Beware of bias: anchor by providing data, use independent scoring by several people, and average scores to reduce individual bias.

Governance & cadence

• Weekly: Triage meeting for near-term sprint/backlog grooming; owners present new data and confidence updates.
• Biweekly/Monthly: Prioritization review where leadership adjusts weights, OKRs, and high-risk bets.
• Quarterly: Retrospective of prioritization compare predicted vs realized outcomes, recalibrate models (weights & rubrics).

Decision record

• For each decision record: Date, Decision maker(s), FeatureID, Model used, Final score, Rationale, Data sources, Next steps, Post-launch metric target.

Common pitfalls (and how to avoid them)

• Mixing units without normalization always normalize before aggregation.
• Overweighting “nice-to-have” subjective opinions enforce data anchors & confidence.
• Using effort as a negative without normalizing (effort units must be consistent).
• Ignoring maintenance/technical debt include a separate line item and criteria for technical risk reduction.
• Letting noisy metrics drive decisions use cohorts and statistically valid experiments where possible.

Appendix: Quick checklist before assigning development

• Is the business outcome clearly stated? (metric and target)
• Is the Reach clearly defined (time window)?
• Do we have evidence for Impact and Confidence? (analytics, interviews, experiments)
• Are dependencies enumerated and resolved or planned?
• Is the Effort estimate normalized to our velocity?
• Have we considered alternative cheaper experiments to validate assumptions?
• Is this aligned to Q-level OKRs/strategy?

If you’d like, I can:

• Convert this template into a Google Sheets with formulas and conditional formatting applied.
• Produce a one-page stakeholder summary template that pulls the top 5 priorities and expected outcomes.
• Add a small script (Python/Apps Script) to auto-normalize and bucket results from raw inputs.

Which follow-up would be most useful?