Feature prioritization: methods that work for a first product
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.

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%.

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.
| Method | What you score | What you need | Time for 20 items | Best for | Weakness |
|---|---|---|---|---|---|
| RICE | Reach, impact, confidence, effort | User data and an estimate of the work | 1–2 hours | Ordering a backlog with numbers | Needs numbers that are easy to fudge |
| MoSCoW | Must, Should, Could, Won't | Team agreement and a stage budget | 1 hour | Scoping an MVP or a stage with a deadline | Everything easily ends up in Must |
| Kano model | How a feature affects satisfaction | A survey or user interviews | Days (survey) | Telling basic features from differentiating ones | Labor-intensive, says nothing about cost |
| Value vs effort | Value and effort on two axes | A shared workshop | 30–60 minutes | A quick first split | Scores are subjective |
| Eisenhower | Important and urgent | A task list | 15 minutes | Work tasks, not product features | Says nothing about value to the customer |
| ICE | Impact, confidence, ease | Scores on a 1–10 scale | 30 minutes | Marketing and growth experiments | No single official formula |
| WSJF | Cost of delay ÷ job size | A shared assessment of value, urgency and risk | 1–2 hours | Large teams using SAFe | Too 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.
| Component | Scale in Intercom's original | What it means |
|---|---|---|
| Impact 3 | Massive | The feature changes how people use the product |
| Impact 2 | High | A clear improvement for every person it affects |
| Impact 1 | Medium | A noticeable improvement |
| Impact 0.5 | Low | A small convenience |
| Impact 0.25 | Minimal | Almost no change |
| Confidence 100% | High | You have data on both reach and impact |
| Confidence 80% | Medium | You have data on one and an estimate of the other |
| Confidence 50% | Low | You 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 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.
| Feature | Reach | Impact | Confidence | Effort | RICE score | Rank |
|---|---|---|---|---|---|---|
| SMS reminder before the appointment | 900 | 1 | 80% | 0.5 | 1,440 | 1 |
| Online booking | 1,200 | 2 | 80% | 2 | 960 | 2 |
| CRM integration | 1,200 | 1 | 50% | 3 | 200 | 3 |
| Dark mode | 300 | 0.25 | 100% | 0.5 | 150 | 4 |
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.

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.
| Quadrant | Value | Effort | What you do | Example from the RICE calculation |
|---|---|---|---|---|
| Do first | High | Low | Into the next stage | SMS reminder, online booking |
| Plan | High | High | Break it into smaller parts or plan a separate stage | CRM integration |
| If time allows | Low | Low | When there is time left in the stage | Dark mode |
| Not now | Low | High | Onto the "Won't have this time" list | Elaborate 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 situation | Method | Why | What to avoid |
|---|---|---|---|
| First version of an app with a deadline | MoSCoW, then RICE inside the stage | Protects the stage deadline and budget | Must above 60% of effort |
| You have a product and usage data | RICE | Numbers instead of opinions | A 1–5 scale instead of the original |
| You don't know what users want | Interviews, then Kano | Knowledge first, order second | Surveys without interviews |
| First workshop with the team | Value vs effort | 30–60 minutes, no data needed | Treating the result as final |
| Your own work tasks | Eisenhower | Separates important from urgent | Using it for product features |
| Marketing tests | ICE | Quick comparison of many ideas | Mixing products and averages |
| Several teams, one shared backlog | WSJF | Accounts for cost of delay | Rolling 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.

Four decisions from the build log, each with a different method in the background:
| Date | What happened | Decision | Equivalent in the methods |
|---|---|---|---|
| September 2, 2026 | The account with the search volume data provider was not verified yet | Volume data moved from stage T2 to T3, onboarding launched without it | A dependency changes the order, not the score |
| September 2, 2026, before stage T4 | Competitor research showed they publish articles automatically | Autopilot as the default, draft mode as a control | Kano: a must-be feature in this category |
| September 3, 2026 | The first article on the largest AI model cost $2.10, a scan of 22 phrases cost $0.10 | A cheaper model as the default and a daily budget of $2 per site | New data on effort and cost, score to be recalculated |
| September 20, 2026 | Perplexity had returned a rate limit error since the first test on September 3 and needed separate handling | Perplexity removed from the scan | Won'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.
- One goal in one sentence. Who the user is, which problem goes away and how you will measure it.
- All the ideas on one list. No scoring yet, just writing them down.
- A first MoSCoW split. Must is only what you can't test the goal without.
- The 60% test. If Must takes up more than 60% of the estimated work, move something to Should.
- RICE inside Must and Should. Original scales, effort in person-months or weeks.
- Confidence below 50% means a conversation, not a build. Talk to five users first.
- A written Won't have this time list. With one sentence on why not now.
- 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.


