I've aggregated prioritization methods from all over the internet, including here on Indie Hackers. Because good feature prioritization results in a better product, but there are a lot of methods to choose from — and there's no consensus on what's best.
So hopefully, I can save you some time by summarizing 24 popular prioritization frameworks.
Not interested in learning about all the methods I found? Check out my TL;DR take below.
My take on prioritizing product features
Here are my top picks based on the needs of indie hackers and early-stage entrepreneurs. See the next section for more info on each one.
- Best all-around approach for indie hackers: DIE
- Quick and dirty approach: Value vs Effort
- Popular among indie hackers: RICE Method
- If you're particularly constrained by a resource: Prioritize by Constraints
And an unpopular opinion: When in doubt, go with your Gut. 💪
Prioritization frameworks: How to prioritize product features
Here are 24 methods for prioritizing your product features. Many require rating the features according to specific factors. Polls and customer interviews will give you solid data for this. But if you’re doing it on the fly, be as objective as you can. The more familiar you are with your market, the better you’ll be at this.
- Value vs Effort Quadrant: Also known as Value vs Cost, or Value vs Complexity. To use this, rate a feature's value to the business and the difficulty to implement it. Plot the resulting point on a quadrant chart. The sweet spot is the highest value with the lowest effort. High effort with low value goes in the garbage.
- Value vs Risk Quadrant: Instead of complexity, look at the risks — that includes schedule risk (might miss deadline), cost risk (might go over budget), and functionality risk (might not be able to pull it off). While it's slightly counter-intuitive, the idea is to go with high-risk/high-value first, as this will keep you from avoiding difficult tasks. Then come the low-risk/high-value features, then the low-risk/low-value. Avoid the high-risk/low-value features.
- Urgency, Impact, and Effort: Rate the urgency, impact, and effort of each feature on a scale of 1-5. Then use this equation to prioritize them: (100 x Urgency) + (10 x Impact) - (1 x Effort). This prioritizes urgency and low-hanging fruit.
- The Kano Model: This is similar to Value vs Effort, except you can replace "value" with "customer delight." Figure out what your customers value, either through market research or polls. Then classify each prospective feature as one of the following: threshold (necessary and expected), performance (features that increase satisfaction), or excitement (users wouldn't notice if you didn't have them but they disproportionately boost delight). Threshold features should be completed first, followed by excitement features, and then performance. You can really go down a rabbit hole with this one so here's some more info.
- DIE: This one comes from @Shpigford of Baremetrics. You measure demand, impact, and effort using this spreadsheet. It's set up so that you'll actually want the lowest number possible, which is created by high demand, high impact, and low effort.
- The Eisenhower Matrix: This one's based on Dwight D. Eisenhower's famous quote, "What is important is seldom urgent and what is urgent is seldom important." It’s a very simple quadrant chart where you weigh urgency against importance. Important/urgent features get done, important/not urgent features get planned, urgent/unimportant features get delegated, and unimportant/not urgent features get thrown out.
- RICE Method: This is a very popular prioritization framework where you rate reach (how many people it'll impact in a certain timeframe), impact, confidence (that it will deliver a desired result), and effort. Then figure out the total impact per time worked with this equation: Reach x Impact x Confidence / Effort.
- ICE Scoring Model: Score impact, confidence, and ease on a scale of 1-10. Note that we're rating ease here, not effort as in the RICE Method. Then we take the average of the ratings, and the highest score is the top priority. Here's a spreadsheet for your calculations.
- Systemico Model: This one is similar to the Kano Model and it's all about value to the customer. Create a grid with user goals on one axis and user engagement on the other. User engagement is broken down into four categories: core (baseline expectations), use (improves usability), engage (increases interaction and retention), and explore (builds a stronger connection between user and product). Then put your features into the grid according to where they fall within the user goals and engagement. And finally, group them into sprints. Core features should generally be top priority, followed by use, engage, and explore, in that order — but it's a flexible framework so you can mix and match. For more info and visuals, check out this article.
- Quality Function Deployment: Figure out your customers' wants and needs, then find out which ones are most important and create a list of features that could address them. Score the relationship between the desire (what) and the feature (how). If there's a strong relationship between the two, give it a score of 9. Moderate relationships get a 3, weak relationships get a 1, and no relationship gets a zero. Here's a spreadsheet you can use.
- Buy a Feature: Put a price tag on each feature based on the investment to develop it. Give a group of people (e.g. users, friends, team, etc.) a theoretical budget that is either a third or a half of the total cost of all the features. Then ask them to buy the features they want.
- Prune the Product Tree: Draw a big tree. Thick limbs represent core product areas and the outermost branches represent current features. Write potential features with sticky notes as the leaves in relevant branches. This will help you to understand if areas are growing disproportionately, and if some areas are becoming underdeveloped. The tree doesn't always have to be balanced, but eventually you may need to make adjustments by prioritizing other “branches” and features.
- Speed Boat: Draw a speedboat (the product) that is being held back by anchors (features that people are dissatisfied with). Ask a group of customers to tell you what the anchors are and how much faster the boat could go without it. The speed is the scoring system. This is a way to find out what users want changed without being inundated with complaints that contain a lot of noise with little signal. Seems a little absurd, but people do it. 🤷♂️
- Opportunity Scoring: This one is specifically for improving existing features. Use polls to rate how important a feature upgrade is to users and how satisfied customers are with the feature as it currently is. Then prioritize the features that were voted as the most important with the least satisfaction. Here's the equation: Opportunity = Importance + max(Importance - Satisfaction, 0)
- Financial Analysis: Analyze how many dollars each feature will bring in over a period of time through new revenue, incremental revenue (upgrades), retained revenue (reduced churn), and cost savings. Prioritize what brings in the most money. This can get super complicated when taking the time value of money and other complicated things into account, but that probably isn't necessary for our purposes.
- Ian McAllister’s Framework: This one's pretty similar to Value vs Effort. Here's what McAllister advises. Define important themes for your business (e.g. customer acquisition) then prioritize the themes and decide how much resources you want to put into each. Then estimate the impact and cost of each feature. And prioritize the features within each theme without going over the budget that you set.
- Impact on Business Goals: Assign one of the following funnel stages to each feature: acquisition, activation, retention, revenue, or referral. Decide which one needs to be improved right now, then decide which feature will have the biggest impact on that goal.
- Mike Doom's 70/20/10: Assign each feature a category: proven (expected feature), evolved (feature that is better than the competition), or innovative (never been seen before). Then prioritize your features so that you're doing 70% proven features, 20% evolved, and 10% innovative.
- Prioritize by Constraints: If you're short on specific resources, prioritize based on what you do and don't have. If you can't afford something, it gets delayed and something else is prioritized. This can be used in tandem with other methods.
- Classification Ranking: This is your run-of-the-mill prioritization system. Just select some objectives that are important to you and rate each feature according to those objectives.
- Scorecard: Set a list of criteria to achieve a specific strategy, and assign each criterion a percentage weight (adding up to 100% total). Then rank each feature from 1-100 against the criteria. Prioritize features according to the weighted score.
- Theme Screening: Similar to the Scorecard approach. For each criterion, select a feature that is likely to be included in the next release, and use it as the baseline. Then score each feature with a +1, 0, or -1, according to how effective it is against the criterion when compared to the baseline. Add up the scores to prioritize the features.
- Consistent Customer Feedback: This isn't really a method, but if you keep getting the same feedback from customers, that should probably be the highest priority.
- Gut Feelings: I didn't see this included anywhere in my research, so I'm adding it here. Your gut matters. No, it's not quantifiable. But our bodies (i.e. the subconscious) are very intelligent, and they know things that don't occur to us consciously. The problem is that most of us haven't formed a good relationship with our guts, so we don't trust them and we don't know how to listen. If you're a skeptic, test it. Next time you have a gut feeling, go with it, even if it goes against logic. You can start small. How did it turn out? It probably won't go well at first, because you’ll be listening for the wrong things. But as you start noticing it and listening to it, I bet you'll create a strong and dependable relationship over time. Just my two cents.
Final pointers on prioritizing product features
- Try to include a variety of features in each release — don't just focus on one type. If it helps, put each feature into one of four buckets: metric movers (helps with business goals/metrics), customer requests, delight (innovative features), and strategic (steps toward learning or future goals). Then make sure to include at least one in each release.
- Don't forget about technical debt. While shiny new features are more fun, it's important to fix bugs and refactor code often.
- If you need to prioritize one factor over another, you can add weighted scoring to just about all of the methods above.
- Keep an eye on customer usage and the business impacts of new features. This will help you to course-correct and make better decisions in the future.
- Structure is important, but inspiration is too. Leave room in whatever method you choose for embodied hunches and inspired off-book sprints.
Product feature prioritization tools
There are lots of product management tools out there that include features for prioritizing features. And they'll probably use one of the methods above to do it. You can find a list of these tools in my post on product roadmapping.
I hope this helps you find the right prioritization framework for you. Let me know if I missed any good ones. And good luck! 🙌