Prioritize Features with Data-Driven Frameworks

This skill covers feature-prioritization frameworks and product-management methodologies for making data-driven decisions about what to build next, balancing user needs, business objectives, and technical constraints. Core frameworks: RICE (Reach times Impact times Confidence divided by Effort), demonstrated via a scoring function:

def calculate_rice_score(reach, impact, confidence, effort):
    """
    Calculate RICE score for feature prioritization
    
    Args:
        reach: Number of users affected per time period
        impact: Impact score (1-3 scale: minimal=1, high=3)
        confidence: Confidence percentage (0-100)
        effort: Development effort in person-months
    """
    if effort == 0:
        return 0
    
    rice_score = (reach * impact * (confidence / 100)) / effort
    return round(rice_score, 2)

a Value-vs-Complexity matrix (a 2x2 scatter plot with quadrant labels - Quick Wins, Major Projects, Fill-ins, Money Pit - plotting features by value and complexity), the MoSCoW method (a template categorizing features into must-have, should-have, could-have, and won't-have buckets, each with criteria and worked examples like user authentication, advanced search, dark mode, and blockchain integration), a weighted-scoring model (a class validating that criteria weights sum to 1.0, scoring and ranking features against weighted criteria like user value, business impact, technical feasibility, strategic alignment, and resource availability), and Kano-model analysis (a lookup table mapping functional/dysfunctional questionnaire response pairs to five Kano categories - Must-be, One-dimensional, Attractive, Indifferent, Reverse).

Advanced prioritization considerations cover technical-debt impact assessment (a weighted debt multiplier combining code complexity, test coverage, dependency risk, and architecture alignment) and opportunity-cost analysis (sorting features by value/effort ratio, greedily selecting features within a resource constraint, and reporting the lost value of features that didn't make the cut).

Implementation best practices cover regular review cycles (quarterly prioritization reviews, updating scoring criteria for market changes, tracking effort and impact estimate accuracy, maintaining historical data for framework refinement), stakeholder alignment (consistent scoring scales across teams, documented assumptions and rationale, visual dashboards for transparency, clear escalation paths for conflicts), and data-driven validation (A/B testing feature assumptions, tracking adoption and usage metrics, correlating prioritization scores with actual outcomes, adjusting frameworks based on retrospectives).

Use it when deciding what to build next with a systematic, data-driven method - scoring features via RICE, MoSCoW, a weighted model, or Kano analysis, or assessing technical-debt impact and opportunity cost of a prioritization decision. The must-have MoSCoW criteria specifically flag legal or compliance requirements and core user-journey dependencies (worked examples: payment processing, data security) as the bar for automatic inclusion, versus won't-have items like AI recommendations or a VR interface that are simply out of scope for the current release. It is not a roadmap-communication or stakeholder-presentation tool by itself - it produces the scores and rankings that feed into a roadmap, not the roadmap narrative.

Given a set of candidate features with their reach, impact, effort, and confidence, it produces a ranked RICE score - a worked example scores "Mobile App" (reach 5000, impact 3, confidence 80%, effort 6) at 2000, "Dark Mode" (reach 2000, impact 2, confidence 95%, effort 2) at 1900, and "API Integration" (reach 1500, impact 3, confidence 70%, effort 4) at 787.5 - alongside a value-vs-complexity plot, a MoSCoW categorization, a weighted ranking, a Kano category, or an opportunity-cost report given resource constraints.

Code samples use Python (RICE calculator, weighted scoring model, Kano analysis via enum, technical-debt and opportunity-cost calculators), matplotlib/numpy for the value-complexity plot, and YAML for the MoSCoW template.

Product managers and product teams making systematic, data-driven feature-prioritization decisions.