When a product team asks how to prioritize features in a digital product, the instinctive answer is to reach for a framework. MoSCoW, RICE, Value/Effort matrix, Kano model, ICE score — product literature has spent two decades generating frameworks with increasingly creative names. And yet backlogs remain graveyards of good intentions, roadmaps look more like wish lists than strategic bets, and sprint demos keep showcasing features nobody uses.
The problem is not that the team chose the wrong framework. The problem is that they applied it at the wrong moment, on raw material that wasn't ready to be processed.
Prioritising without minimum discovery is not agile methodology. It's voting with different criteria and calling it a process.
- Every prioritisation matrix assumes you already know what the user wants — if you don't, you're sorting assumptions.
- The strategic value of a feature cannot be estimated without understanding the real job the user is trying to do.
- The framework you choose matters far less than the quality of the input you feed it: garbage in, garbage roadmap out.
The Real Issue: Prioritisation Is an Answer, Not a Question
There's a widespread foundational confusion: prioritisation gets treated as the starting point of the product process, when it should actually come near the end of a prior phase. Prioritising answers the question "what do we build first?" But before answering that, you need to have answered far more fundamental questions: What specific job is the user trying to do? Where does the current flow fail them? What workaround are they using today because the product doesn't reach? What's the consequence for them if the problem persists?
Without those answers, when the team gathers around a whiteboard with forty backlog items and starts assigning impact and effort scores, they're doing something resembling astrology: there's a system, there are symbols, there are numerical outputs. But the foundation is collective intuition, not evidence.
A well-prioritised backlog built on unvalidated hypotheses is a very tidy map of a territory that doesn't exist.
The framework you choose — MoSCoW, RICE, whatever — is neutral. It's a calculator. The calculator doesn't generate the numbers: it multiplies them. If the input factors are team opinions dressed as estimates, the output is a team opinion dressed as data.
Discovery: What Needs to Happen Before Opening the Spreadsheet
Product discovery is not a luxury phase for teams with time and budget to spare. It's the work that turns hypotheses into valid inputs for any prioritisation framework. Without it, you're not prioritising: you're sorting by preference.
What does minimum viable discovery look like before you start prioritising? At least three things:
- Understand the job to be done: what real task — functional, emotional, social — is the user trying to accomplish with your product, or with the workaround they use in its absence.
- Map current friction points: where does the flow break today, what specific friction causes abandonment or frustration, what steps does the user handle outside the product because the product doesn't cover them.
- Validate value hypotheses before estimating: before scoring a feature's "impact" in RICE, you need some evidence — even qualitative — that the impact is real for someone other than the product team.
We've seen this pattern repeatedly: teams arrive with fifty features ranked by RICE, and three well-conducted user interviews later, the top-ranked item turns out to solve no real problem the user actually has. It solves the problem the team imagined the user had.
If you want to understand what this prior work looks like in practice, the post on what digital product discovery is and why most teams get it wrong goes into the detail this article can only sketch.
JTBD as a prerequisite, not a complement
Jobs-to-be-Done has a reputation problem among teams who've used it as a label ("this feature covers the job of managing notifications") rather than as a research method. When applied properly, JTBD forces you to reformulate a feature as a solution to a specific user job, with a context ("when I'm in situation X"), a motivation ("I want to achieve Y") and a success criterion ("so that Z"). That level of precision changes how you evaluate a feature's value entirely.
A feature you can't formulate as a JTBD probably doesn't solve anything specific. And if it doesn't solve anything specific, the impact score you assign in RICE is fiction.
How much discovery is enough?
This is the practical question that comes up most often. The honest answer: it depends on the risk of the decision. For small, low-cost, easily reversible features, a couple of user sessions and an analysis of existing behavioural data may be enough. For major bets — a feature that will consume three sprints or change the product's main flow — the evidence threshold rises. This isn't perfectionism: it's risk management.
What's never acceptable is skipping discovery because "we know our users well." That's the argument we've heard most often right before discovering that a team has been building in the wrong direction for months.
Prioritisation Frameworks: When They Work and When They Lie
Once you have valid inputs — jobs identified, friction points documented, hypotheses minimally validated — prioritisation frameworks stop being pseudoscience and start being useful. But each one has a different underlying assumption worth understanding before you choose.
MoSCoW (Must have, Should have, Could have, Won't have) is extremely simple, which is why it works well in contexts where the team already has clarity on what's critical for the MVP and what's optional. Its weakness: without that clarity, everything ends up as "Must have" because no one wants their feature cut. It becomes a political negotiation where whoever pushes hardest wins, not whoever has the most evidence.
RICE (Reach, Impact, Confidence, Effort) is more sophisticated because it introduces the Confidence factor, which forces the team to make explicit how certain they are of their estimates. It's the only popular framework with an internal mechanism to penalise unsupported assumptions. Its weak point: Reach is usually estimated without real data, and Impact tends to be scored against subjective criteria that vary between people on the same team.
Value/Effort is the most intuitive and, for that reason, the most dangerous. The "Value" column is a blank field that the team fills with its own projections. If those projections have no research behind them, the matrix is just a chart of team opinions organised on two axes.
The framework doesn't create knowledge: it organises it. If the knowledge doesn't exist, the framework organises ignorance.
Which framework should you choose? The one that best fits your team's context and the nature of the decisions at hand. But that choice is secondary. The primary question is always: do we have enough evidence about the value of these features for the real user, or are we estimating from team intuition?
Prioritising with Judgement: A Two-Stage Process
The model that works is not "choose the best framework and apply it." It's a clearly separated two-stage process: first you generate knowledge, then you process it with a framework.
In the first stage — discovery — the goal is to reduce uncertainty on three things: who has the problem, how severe it is, and what concrete value solving it would deliver. The tools are interviews, behavioural analysis, support ticket reviews, quick proof-of-concept tests. You don't need to answer everything before prioritising, but you do need to have reduced uncertainty below a reasonable threshold.
In the second stage — prioritisation proper — you use the framework that best organises the knowledge you've generated. RICE if you want to make confidence in your estimates explicit. MoSCoW if the context is a tightly scoped MVP and the team already has consensus on what's critical. Value/Effort if you need a quick conversation with non-technical stakeholders.
There's a third element that often gets overlooked: reversibility. Some product decisions are easy to undo; others leave technical debt or create user expectations that are nearly impossible to walk back. All else being equal, prioritise features you can measure and adjust quickly. Delay those that imply structural commitments until you have more evidence. The same logic that applies to validating a product idea before committing to build it applies equally to individual feature bets within an existing product.
The role of behavioural data in prioritisation
A source of evidence teams systematically underuse is behavioural data from the existing product. If you already have a product in production, you have a stream of signals about which features get used, how often, in what contexts, and where users drop off. That data doesn't answer "what does the user want" — for that you need qualitative research — but it does answer "what is the user actually using," which is a far more reliable input than any team estimate.
Combining quantitative behavioural data with qualitative interview insight is the minimum reasonable standard before assigning priorities. One without the other is incomplete: data tells you what's happening; interviews tell you why. The friction points in the user experience — those moments where the flow breaks without the technical team knowing — typically emerge precisely at the intersection of both sources. The post on the break points that destroy customer experience in your app explores how to surface those cracks before they turn into churn.
Stakeholders, politics and the backlog as a battlefield
There's a factor that no prioritisation framework mentions in its official documentation: internal political pressure. In most mid-sized companies, the backlog is not just a technical list. It's the outcome of negotiations between sales ("client X asked for this"), product ("we need to reduce churn"), engineering ("we need to pay down technical debt") and leadership ("I need something impressive for the next board meeting"). Each stakeholder has their own success metrics and their own urgencies.
In that context, the prioritisation framework sometimes serves a more political than methodological function: it legitimises the outcome of a negotiation that had already happened informally. That's not necessarily bad — organisational politics are real and must be managed — but it's worth being honest about what's actually going on. If the RICE score is the result of adjusting factors until the ranking matches what the team had already decided, the problem isn't RICE. It's that the decision-making process isn't transparent.
The solution is not a more robust framework. It's establishing, before the prioritisation session, which criteria take precedence and who has authority to decide when criteria conflict. That's product governance, and it precedes any matrix.
The Criterion That Matters: Evidence Before Elegance
After everything above, the answer to how to prioritise features in a digital product is not a framework recommendation. It's a sequence recommendation:
- Before prioritising, generate evidence about the user's real problem: interviews, behavioural data, support analysis.
- Formulate each candidate feature as a solution to a specific job to be done: if you can't, that's a signal the hypothesis isn't defined well enough yet.
- Choose the framework that best organises the evidence you have, not the one that sounds most rigorous.
- Make confidence in each estimate explicit: features with low confidence should go back to discovery before entering the sprint.
- Favour reversible, measurable features when evidence is ambiguous.
The mistake is not in the framework. It's in believing the framework generates the knowledge you need to use it well. It doesn't. That's your work, your team's work, and partly the work of the user you haven't interviewed yet this week.
If your team is at that point — a backlog growing without clear criteria, roadmaps that don't survive first contact with data, or the persistent sense that you keep building the right thing for the wrong user — this is exactly the work we do at Room 714. From clarifying the real problem to defining what to build and in what order. You can start with a free product diagnostic session to see whether it makes sense to go further together.






