All notes Product management

Feature prioritization: methods that work for a first product

In short

Prioritization means putting tasks or features in order by their value, cost and urgency, so the things that deliver the most for the least effort get built first. In product work the most common methods are RICE (reach × impact × confidence ÷ effort), MoSCoW (must, should, could, won't), the Kano model and the value vs effort matrix, while the Eisenhower matrix is enough for everyday work tasks. A method should help you argue less, and the product owner still writes down the decision and the reason for it.

A value and effort matrix on a dark background: the lime "Do first" quadrant with cards for online booking and SMS reminder, next to the Plan, If time allows and Not now quadrants

Prioritization is deciding what you do first, what you do later and what you don't do at all. In feature prioritization for a product, such as the first version of an app for your business, it is the most important decision in the whole project, because every feature added "just in case" costs weeks of work and real money. Below are the prioritization methods for tasks and features that actually hold up in practice, with the original scales from their sources, a comparison table and an example from building a real product.

I went through the articles that rank for "prioritization" and "feature prioritization". Most of the top results are written by vendors of task or product tools. Few of them show the original RICE scales with a source, and none of those I reviewed showed data on how many features in software products go unused.

How we know this: Max Miskow co-founded Skillsbite (an AI tool for screening CVs) in 2021, then designed and built products for clients, and later built his own product, Podium, from zero. We've been on both sides: founders who had to validate our own product ideas, and the team that designs and builds products for clients. The Podium example comes later in this article.

Prioritization: what it is and why it pays off

Prioritization is putting tasks, requirements or features in order based on clear criteria: value to the user, cost to build, urgency and risk. The result is an ordered list where it is obvious what comes first, plus a second list of things you have deliberately decided not to do. Without that second list, prioritization doesn't work.

In product teams you will hear the term feature prioritization, and in IT projects requirements prioritization. British sources, including the DSDM handbook quoted below, spell it prioritisation. The mechanism is the same in every case. The only thing that changes is what you are putting in order.

The data shows why this pays off. Pendo's 2019 report analyzed software usage across 615 subscriptions over three months. The result: 80% of features in the average product are rarely or never used, and on average 12% of features generate 80% of daily usage. In the press release for the report, Pendo estimates that publicly traded cloud companies spent up to $29.5 billion in research and development costs on features like these.

One caveat that rarely comes up. Three months is a short window, so features people use once a quarter or once a year (an annual settlement, for example) may have landed in the "rarely" group. The direction is still clear: most of the work that goes into features never comes back to users as value. Good prioritization moves the budget toward that 12%.

Chart: according to Pendo's 2019 report, 80% of features in the average product are rarely or never used, and 12% of features generate 80% of daily usage
How software features are actually used, Pendo report 2019

Feature prioritization methods in one table

The most widely used methods for prioritizing tasks and features are RICE, MoSCoW, the Kano model, the value vs effort matrix, the Eisenhower matrix, ICE and WSJF. They differ in what they need as input: numbers, conversations with users, or just a shared table and an hour of time. The table shows when each one makes sense.

MethodWhat you scoreWhat you needTime for 20 itemsBest forWeakness
RICEReach, impact, confidence, effortUser data and an estimate of the work1–2 hoursOrdering a backlog with numbersNeeds numbers that are easy to fudge
MoSCoWMust, Should, Could, Won'tTeam agreement and a stage budget1 hourScoping an MVP or a stage with a deadlineEverything easily ends up in Must
Kano modelHow a feature affects satisfactionA survey or user interviewsDays (survey)Telling basic features from differentiating onesLabor-intensive, says nothing about cost
Value vs effortValue and effort on two axesA shared workshop30–60 minutesA quick first splitScores are subjective
EisenhowerImportant and urgentA task list15 minutesWork tasks, not product featuresSays nothing about value to the customer
ICEImpact, confidence, easeScores on a 1–10 scale30 minutesMarketing and growth experimentsNo single official formula
WSJFCost of delay ÷ job sizeA shared assessment of value, urgency and risk1–2 hoursLarge teams using SAFeToo heavy for a small business

The times in the table are typical orders of magnitude for a small team, not standards. For one or two people building the first version of a product, two methods are enough in practice: MoSCoW for the scope of a stage and RICE for the order inside that stage. The others are useful in specific situations, described below.

RICE prioritization: putting numbers on features

RICE is a scoring method where each feature's score comes from a formula: reach × impact × confidence ÷ effort. Sean McBride of Intercom described it in an article from 2018. The higher the score, the higher the feature goes on the list. Effort sits in the denominator, so cheap items with a big impact win.

The four components, as defined in the original:

  • Reach: how many customers the feature will touch in one quarter. In Intercom's example, 500 customers a month × 30% who choose a given option × 3 months gives 450 people per quarter.
  • Impact: how much the feature will change the behavior of one person, on a scale of 3, 2, 1, 0.5 and 0.25.
  • Confidence: how sure you are, in percent, about reach and impact: 100%, 80% or 50%. Anything below 50% is, in the author's words, a "total moonshot".
  • Effort: how much work the feature will take in person-months, counting product, design and engineering together.
ComponentScale in Intercom's originalWhat it means
Impact 3MassiveThe feature changes how people use the product
Impact 2HighA clear improvement for every person it affects
Impact 1MediumA noticeable improvement
Impact 0.5LowA small convenience
Impact 0.25MinimalAlmost no change
Confidence 100%HighYou have data on both reach and impact
Confidence 80%MediumYou have data on one and an estimate of the other
Confidence 50%LowYou are mostly going on gut feeling

Some articles present RICE on a scale from 1 to 5. That is not the original method. The 3 to 0.25 scale is uneven on purpose: the gap between a "massive" feature and a "minimal" one is twelvefold, not fivefold. On a 1–5 scale all the scores flatten out and the ranking stops telling you anything.

RICE scales according to Intercom: impact 3, 2, 1, 0.5 and 0.25, confidence 100%, 80% and 50%, effort in person-months, and the formula reach times impact times confidence divided by effort
The original RICE scales from Intercom's 2018 article

RICE prioritization: a worked example

Take a service business that is building the first version of an app for its customers and has four features on the list. The numbers below are illustrative, there to show the math, not data from a specific client. Effort is in person-months, and reach is in people per quarter.

FeatureReachImpactConfidenceEffortRICE scoreRank
SMS reminder before the appointment900180%0.51,4401
Online booking1,200280%29602
CRM integration1,200150%32003
Dark mode3000.25100%0.51504

The math for the first row: 900 × 1 × 0.8 ÷ 0.5 = 1,440. Two things in this table are typical. A small, cheap feature beats the "flagship" one, because effort divides the score. And the CRM integration drops down the list despite its large reach, because nobody is confident about it. Low confidence is a signal that you need to talk to users before you build anything.

A RICE score is not an oracle. If online booking is a precondition without which SMS reminders make no sense, the dependency reverses the order, not the formula. That is why RICE works best in the middle of a stage, once the scope is already set.

MoSCoW prioritization: scoping a stage and an MVP

MoSCoW is a method for splitting requirements into four groups: Must have, Should have, Could have and Won't have this time. It comes from the DSDM methodology, which the Agile Business Consortium develops today. You use it to decide what will definitely go into a stage with a deadline and a budget, and what is first to be cut when time runs short.

The definitions, according to the DSDM handbook:

  • Must have: the minimum usable set of requirements that the project guarantees to deliver. Without them, the result is useless or illegal.
  • Should have: important but not vital. Painful to leave out, but there is a workaround.
  • Could have: wanted but less important. The first to go when there is a delay.
  • Won't have this time: agreed not to be delivered in this period. It doesn't mean "never", only "not now".

The most important rule in that handbook is also the easiest to miss: Must have is usually no more than 60% of the stage's effort, and Could have is around 20%. The percentages are measured in work, not in the number of requirements. That reserve exists so that, when a delay hits, you can cut the Could items and still deliver every Must.

How a stage's effort is split in MoSCoW according to DSDM: Must have no more than 60%, Could have about 20%, the rest is Should have, and Won't have this time sits outside the stage
MoSCoW according to DSDM: Must up to 60% of effort, Could about 20%

In practice, MoSCoW fits the first version of a product very well. Must is one main flow from start to finish, for example "the customer books a service and gets a confirmation". Anything you can do without while still testing that assumption goes to Should or lower. Once the Must list is set, the next step is turning it into a Now, Next, Later roadmap, which we cover in how to build a product roadmap.

The most common mistake with MoSCoW is that everything ends up in Must. A simple test: if Must takes up more than 60% of the estimated work, the stage has no reserve, and every delay means either a later deadline or a bigger bill.

The Kano model: which features are expected and which set you apart

The Kano model groups features by how they affect user satisfaction. Noriaki Kano and his team described it in a 1984 article in the journal of the Japanese Society for Quality Control. The original is based on surveys about televisions and desk clocks, but the logic carried over to software.

The three categories from the original:

  • Must-be: their absence is very annoying, and their presence makes nobody happy. In a booking app, this is the appointment confirmation.
  • One-dimensional: the more, the better. Speed, for example, or the number of available time slots.
  • Attractive: nobody expects them, but people are pleased when they're there. For example, a reminder that lets the customer reschedule the appointment in one click.

Later work on the model adds "indifferent" and "reverse" categories, meaning features that some users actively dislike. The takeaway for the first version of a product: first all the must-be features for one main flow, then one attractive feature that sets you apart from off-the-shelf tools. Kano says nothing about cost, so pair it with RICE or with the value vs effort matrix.

The value vs effort matrix and prioritizing your own work

The value vs effort matrix is the simplest prioritization method: you place each feature on two axes and get four groups. High value and low effort come first. High value and high effort need to be planned. Low value and low effort get done when there is time. Low value and high effort get set aside.

QuadrantValueEffortWhat you doExample from the RICE calculation
Do firstHighLowInto the next stageSMS reminder, online booking
PlanHighHighBreak it into smaller parts or plan a separate stageCRM integration
If time allowsLowLowWhen there is time left in the stageDark mode
Not nowLowHighOnto the "Won't have this time" listElaborate reports for one person

This is a good method for a first workshop, because it takes an hour and needs no data. Its weakness is subjective scoring, so when people disagree, switch to RICE.

Prioritizing work tasks: the Eisenhower matrix

For everyday work tasks, rather than product features, there is the Eisenhower matrix. It sorts tasks by two questions: is it important, and is it urgent. Important and urgent you do right away, important but not urgent you schedule, urgent but not important you delegate, and the rest you cross off.

The name comes from Dwight Eisenhower's address of August 19, 1954, in which he said: "I have two kinds of problems, the urgent and the important". A detail that usually gets left out: Eisenhower was quoting a former college president, as Quote Investigator documents. The matrix itself was named after him much later.

In product work the Eisenhower matrix has limited use, because it says nothing about value to the customer. It helps when a business owner is splitting time between day-to-day operations and building a product.

ICE and WSJF: when they are worth using

ICE and WSJF are two methods that show up in comparisons but fit a small business less often. ICE is fast and good for experiments. WSJF is precise, but it needs a larger team and a defined process.

ICE scores impact, confidence and ease, usually on a scale of 1 to 10. The method is credited to Sean Ellis, who coined the term growth hacking. Sources disagree on whether to multiply the scores or average them, so decide once as a team and stick with it. ICE works well for marketing tests, where speed matters, and less well for features that cost weeks of work.

WSJF (weighted shortest job first) comes from the SAFe framework. According to the SAFe description, it is the relative cost of delay divided by the relative job duration. Cost of delay is made up of user and business value, time criticality, and risk reduction or opportunity enablement. For a team of two this is too much ceremony, but the question "what does every week of delay cost us" is worth asking about every large feature.

Requirements prioritization in practice: how to choose a method

You choose a method based on what you already know. If you have user data, use RICE. If you have a deadline and a stage budget, use MoSCoW. If you don't know what users expect, start with interviews and the Kano model. If you need a first split within an hour, use the value vs effort matrix.

Your situationMethodWhyWhat to avoid
First version of an app with a deadlineMoSCoW, then RICE inside the stageProtects the stage deadline and budgetMust above 60% of effort
You have a product and usage dataRICENumbers instead of opinionsA 1–5 scale instead of the original
You don't know what users wantInterviews, then KanoKnowledge first, order secondSurveys without interviews
First workshop with the teamValue vs effort30–60 minutes, no data neededTreating the result as final
Your own work tasksEisenhowerSeparates important from urgentUsing it for product features
Marketing testsICEQuick comparison of many ideasMixing products and averages
Several teams, one shared backlogWSJFAccounts for cost of delayRolling it out in a team of 2–3 people

Whatever the method, the output goes into one ordered list. The Scrum Guide calls it the product backlog and describes it as an emergent, ordered list of what is needed to improve the product. The product owner is accountable for the order. In a small business, that role usually falls to the owner or to whoever is responsible for the product.

One last point that few articles make: a method should help you argue less, not look scientific. For every item at the top of the list, write one sentence on why it is there. A month from now, that sentence will tell you more than the score.

Example: how priorities shifted while building Podium

Priorities in a real project change after the first contact with reality. That is what happened with Podium, a tool for writing and publishing articles on company blogs, which Max built from zero. The plan had eight weekly stages, and several decisions about order were only made along the way.

The Podium dashboard with a list of search phrases and, for each phrase, its opportunity, difficulty, monthly searches and article status
The Podium dashboard with the data used to prioritize phrases, a product Max built from zero

Four decisions from the build log, each with a different method in the background:

DateWhat happenedDecisionEquivalent in the methods
September 2, 2026The account with the search volume data provider was not verified yetVolume data moved from stage T2 to T3, onboarding launched without itA dependency changes the order, not the score
September 2, 2026, before stage T4Competitor research showed they publish articles automaticallyAutopilot as the default, draft mode as a controlKano: a must-be feature in this category
September 3, 2026The first article on the largest AI model cost $2.10, a scan of 22 phrases cost $0.10A cheaper model as the default and a daily budget of $2 per siteNew data on effort and cost, score to be recalculated
September 20, 2026Perplexity had returned a rate limit error since the first test on September 3 and needed separate handlingPerplexity removed from the scanWon't have this time

The content plan feature in Podium is interesting in its own right. The planner lays out articles for 14 days from the tracked phrases in a fixed order: priority first, then search volume. It is the same logic as RICE, just written in code: first what matters most to the customer, and within the same weight, whatever will reach the most people.

The lesson from Podium is simple. None of these numbers, $2.10 per article or $0.10 per scan, were known before the first run. Prioritization is not a one-time exercise before launch. It is a decision you repeat every time new information comes in.

Checklist: feature prioritization for the first version of a product

Before you close the feature list for the first version, go through these eight points. It takes an hour and saves weeks of work on features nobody will use.

  1. One goal in one sentence. Who the user is, which problem goes away and how you will measure it.
  2. All the ideas on one list. No scoring yet, just writing them down.
  3. A first MoSCoW split. Must is only what you can't test the goal without.
  4. The 60% test. If Must takes up more than 60% of the estimated work, move something to Should.
  5. RICE inside Must and Should. Original scales, effort in person-months or weeks.
  6. Confidence below 50% means a conversation, not a build. Talk to five users first.
  7. A written Won't have this time list. With one sentence on why not now.
  8. A review date. Come back to the list after the product's first week with real users.

This is how we work when we build an MVP: discovery in week one, a prototype on the client's real data in week two, and the build in weeks three to six. The Must, Should and Won't lists are ready at the end of discovery. We give a range after the first call and a fixed price before each stage, once it is clear what the stage contains.

Frequently asked questions

What is prioritization?

Prioritization is putting tasks, requirements or features in order based on clear criteria, most often value, cost, urgency and risk. The result is an ordered list of what you do first, plus a list of things you have deliberately decided not to do right now.

What are the main prioritization methods?

The most widely used methods are RICE (reach × impact × confidence ÷ effort), MoSCoW (must, should, could, won't), the Kano model, the value vs effort matrix, the Eisenhower matrix, ICE and WSJF. MoSCoW and RICE fit product features best, and the Eisenhower matrix fits everyday work tasks.

How does the MoSCoW method work?

MoSCoW splits requirements into Must have, Should have, Could have and Won't have this time. According to the DSDM handbook, Must is usually no more than 60% of a stage's effort and Could is around 20%, so that when there is a delay you can cut the Could items and still deliver every Must.

How do you calculate a RICE score?

Multiply reach (the number of people per quarter) by impact (3, 2, 1, 0.5 or 0.25) and confidence (100%, 80% or 50%), then divide by effort in person-months. For example, 900 × 1 × 0.8 ÷ 0.5 = 1,440. A higher score means a higher place on the list.

What is the difference between RICE and MoSCoW?

MoSCoW decides scope: what definitely goes into a stage with a deadline and a budget, and what gets cut first. RICE decides order: it scores each feature with numbers so you know what to build first once the scope is set. For a first version of a product, use MoSCoW for the stage and RICE inside it.

What is the Eisenhower matrix?

The Eisenhower matrix sorts tasks by two questions: is it important, and is it urgent. Important and urgent you do right away, important but not urgent you schedule, urgent but not important you delegate, and the rest you cross off. It suits everyday work tasks, not product features, because it says nothing about value to the customer.

How is prioritizing work tasks different from prioritizing product features?

Prioritizing work tasks organizes your time, usually by importance and urgency, for example with the Eisenhower matrix. Feature prioritization organizes what the team will build, by value to the user and cost to build, for example with RICE or MoSCoW.

Who decides priorities in a product?

According to the Scrum Guide, the product owner is accountable for the order of the product backlog. In a small business, that is usually the owner or the person responsible for the product. Scoring methods help the conversation, but one person writes down the decision and the reason for it.

How many features should the first version of a product have?

As many as one main flow from start to finish needs, and not one more. According to Pendo's 2019 report, 80% of features in the average product are rarely or never used, so a smaller scope usually means less wasted work.

If you have a feature list for the first version of a product and want someone from outside to help put it in order, book a 30-minute call. You can also request a free report with ideas for your business, sent by email.

More notes

All notes