There are lots of great ideas, but ideas don’t always turn into successful software products. Sometimes, the idea itself just wasn’t good enough, and the marketplace didn’t have any use for it. At other times, poor user experience (UX) is the reason for the lack of success.
Research suggests that global app abandonment (after only one use) has stood steady at 25% for almost a decade. This makes it crucial to engage in proper research and choose the right features that resonate with your target audience.
Successful digital product development projects demand that you choose the right product features that require prioritization. You have to cut down your long list of ideas and narrow it down to what’s important to the end-user.
Sounds easy, right?
But it’s not. Most product managers will probably state that this is one of the most challenging parts of the process. As such, it’s an integral part of your product development process and your product development strategy.
You have to take the time and carefully decide which features deserve the company’s time and resources.
What Is Feature Prioritization?
Product feature prioritization or product backlog prioritization describes the process of building a stack of features, but it’s also so much more. For example, you have to consider the stakeholders’ feedback and opinions, the target audience’s needs, and more.
You have to narrow down their list of demands and features for the whole product roadmap or specific sprint backlog.
Your backlog will also include bug fixes, a list of new features, existing features improvements, or changes to the overall infrastructure. It also consists of any effort exerted to achieve a predefined outcome.
What are the most common things that are influencing feature priority? Of course there should be business value, but what else?
In most cases a Product manager will also consider the level of effort that this feature requires in order to be done and risk level. When I say risk I mean both types of risks: negative (threats) and positive (opportunities). Now let’s take a look at how different product feature prioritization methods combine that into solid techniques of feature prioritisation.
What Is the Most Common Type of Feature Prioritization?
A good project prioritization framework helps unite all stakeholders with quantitative evidence like charts, rankings, and a feature prioritization matrix.
There are numerous prioritization frameworks, and the most popular ones are as follows:
- Buy a Feature Method
- Lean Prioritization (Value/Effort Matrix)
- Opportunity Scoring
- RICE matrix
- Scoring Card/Weighted Scoring
- Walking Skeleton
This post will focus on the prioritization methodologies listed above and explore their related concepts, features, and pros and cons.
1. Buy-a-Feature Method
The buy-a-feature prioritization method is essentially a “game” that involves both customers and stakeholders. The way you approach it is really up to you and your product requirements.
In this scenario, you engage both customers and stakeholders and agree on a “price” for each feature, and compare it against the cost of developing it. The more effort it takes the higher the price it is. When it comes to your customers, this exercise will quantifiably highlight how much a particular feature or idea is worth to the end-user.
The game is played by handing out a certain amount of money and then asking the participants (no more than eight people) to buy the features that are important to them. At the end of the game, you’ll have your feature prioritization list.
- You get real-world insights into what your customers actually want.
- It’s much more fun than conducting a questionnaire.
- The drawback with this startup feature prioritization method is that it can only contain the features you have included in your feature prioritization roadmap. It can only tell you what the target market values the most from the list you have come up with and leaves other potential opportunities in the dark.
- Each customer has to buy their own list of features and select what is top rated. You will need to combine this data afterwards and calculate the overall priority.
2. Kano Model
The Kano model (named after the Japanese researcher, Noriaki Kano) is a collection of ideas and task prioritization techniques plotted on two sets of parameters (on horizontal and vertical axes).
The horizontal axis represents the implementation values. This reflects to what degree the customer’s needs are satisfied.
These are classified into four categories:
- Basic features: or the must-haves to get the user to consider your product.
- Performance features: where your investment has a direct impact on UX.
- Features that delight: is your secret weapon where the end-user is surprised and delighted.
- Indifferent: as customer values aren’t affected by the presence or absence of a specific feature.
The vertical axis reflects the customers’ or end-users’ satisfaction values. The right axis represents customer demands that are met by the product. The left axis represents customer needs that are left unsatisfied.
These range from meeting customer demands on the right to none of the requirements being satisfied on the left.
You have to develop a survey that has questions that try to ascertain how users feel about having or not having a specific feature. For example, “how do you feel about not having an hourly alerts feature?”
The main idea here is that the more time and resources you invest in the process, the more satisfied your customers will be. Once the survey is complete, the best approach is to include 80% “must haves” and 20% exciters in each updated release.
- Developing the questionnaire brings teams down to reality and ensures that they don’t overestimate the features that delight or underestimate the basics.
- Helps rank product features based on value.
- The results help development teams make better product decisions and make better predictions about how certain features will satisfy customer expectations.
- Sometimes, it’s difficult for participants to understand the features about which you’re questioning them.
- The Kano model doesn’t account for the time and resources required to build the product.
- Completing a survey is often time-consuming because you need to carry out an extensive survey that accurately represents your target market.
3. Lean Prioritization (Value/Effort Matrix)
Lean Prioritization nicely complements the lean product development approach. Also known as the value vs. effort quadrant, this method is a basic grid where values are plotted against complexity.
Value: is the benefit your customers get with your feature. It’s your core value that solves a problem or improves their lives in some way.
Effort (or complexity): is the work you put into it to deliver the feature. The feature should not only work for you but also satisfy the end-user’s needs. Can you afford to build it? The objective here is to get more value with less effort. The result is your priority feature.
Value/Effort = Priority
The ideas that attract the highest value and the lowest effort are your low-hanging fruits in the feature prioritization roadmap. This approach is suitable for small development teams with limited time and budgets.
- When you align both in several quadrants, you’ll know what to build first, second, and so on.
- It’ll shed light on what you should scratch-off from the overall product plan.
- You don’t need detailed calculations.
- This method is highly flexible, and you can make changes as needed.
- Without a concrete scoring formula, the results are highly subjective.
- The quadrant can quickly get busy and difficult to digest.
- If you have extensive product features, this approach will be difficult to quantify effort and the object value of each feature.
4. MoSCoW Method
The MoSCoW method helps ascertain what’s most important to both customers and stakeholders by classifying your product features into categories of priority.
Having no relation to the city, MosCoW stands for:
- Must-Have are non-negotiable features like your login.
- Should-Have are the important features to work on, but they are not on a time-sensitive schedule.
- Could-Have are the features that aren’t important to deliver within a tight timeframe. But these features can greatly boost UXs.
- Won’t-Have are the least critical features or tasks often set aside for future releases.
The “Os” was added to create the undoubtedly memorable word.
- It’s easy to schedule as it’s quick and transparent.
- It’s an agile prioritization method with no strict time limits, except for the first “must-have” category.
- The MoSCoW method is quite simple and easy to follow.
- Doesn’t take the “big picture” into account.
- Lacks clear consistency when it comes to implementation.
- It might put time-to-market at risk.
- It has the potential to create an imbalance between what’s required and what’s somewhat desirable.
5. Opportunity Scoring
Opportunity scoring or opportunity analysis is a theory that states that customers only purchase products and services to satisfy specific needs. The primary thought process here is that while customers aren’t good at finding solutions to their problems, their feedback is still vital.
The development team uses customer feedback to formulate desired outcomes of the features or the product itself. In this scenario, opportunity scoring takes the form of a Satisfaction and Importance chart.
Once you formulate your list of ideal outcomes, you survey your customers and ask them questions about the importance of a specific feature and their satisfaction levels with existing solutions.
You plot the answers on a graph, and the features that matter the most with low satisfaction scores make your iteration or scrum prioritization list.
- It’s easy to categorize and visualize what’s important and what’s not.
- It’s a straightforward approach to quickly determine the most feasible and innovative solution to a customers’ pain points.
- Surveys aren’t often a clear indication of what a customer believes is essential to them. They may overestimate or underestimate the importance of a particular product feature.
RICE is an acronym that stands for “Reach, Impact, Confidence, and Effort.” These factors help estimate each individual feature separately. It’s a product improvement method that’s often time-consuming, but it’s one of the best feature prioritization techniques for prioritizing improvements.
Reach: is the number of people who use your part of the product this feature relates to over a predefined time period (assessed quarterly or monthly).
Impact: shows the level of contribution of the feature to overall product and promotion.
Confidence: is what you need when you think your product will have a massive impact but don’t have the data to confirm it. This approach helps you estimate the benefit of any given feature. There are different approaches for estimating confidence. The only thing you need to keep in mind is that it should not change during the time.
Effort: reflects the amount of time it takes for the development team to achieve their objectives. You can use T-shirt estimation, story points or expert estimation. However, the more high-level estimates you have, the less confident you should give to C component.
In this scenario, each proposed feature is ranked based on the following (RICE) formula:
Reach x Impact x Confidence / Effort = Rice Score
We also use the FRICE (F+RICE) technique for experiments prioritization:
You can also employ an extended version of RICE known as FRICE(F+RICE), which is ideal for prioritization experiments. In this scenario, the only difference is the addition of the “Funnel.”
This process is supported by the Funnel Step Value model that measures the impact based on:
- The impact on the acquisition stage
- Activation stage
- Retention stage
- Revenue stage (or Acquisition, Activation, Retention, Revenue, Referral or AARRR)
Funnel x Reach x Impact x Confidence / Effort = FRICE Score
- It helps teams see the whole “picture.”
- Reduces inherent biases.
- Makes UX critical to the development process.
- Only focuses on relevant metrics and numbers.
- Helps make better decisions by measuring the impact on revenue.
- It’s certainly time intensive.
- It relies on a lot of data you might not even have and doesn’t take dependencies into account.
- You have to do a lot of calculations.
7. Scoring Card/Weighted Scoring
A score card or weighted scoring is a feature prioritization technique that leverages the Value versus Complexity matrix. This approach helps product owners decide what to add to their feature prioritization roadmap.
When you follow this approach, the weighted aggregated prioritization score quantifies the importance of specific features. This means that each feature is calculated using a weighted average across all potential drivers (out of 100%) and determines its relative contribution to the final score.
You can create your own scorecard, spreadsheet, or even a product management tool to automate and visualize the scoring process. This feature prioritization model helps teams start a conversation and decide what features to work on first.
- Weighted scores are useful during the design phase.
- Once you define scoring matrix it can be re-used for future prioritisation of any new feature you are facing.
- It’s relatively simple and easy to do.
- Teams might end up “scoring” the wrong things that don’t align with your overall product strategy.
- You might end up with unfocused USPs and fragmented products.
- Weight scores can be manipulated easily to suit the objectives of specific stakeholders.
8. Walking Skeleton
The Walking Skeleton method is one of the best prioritization techniques to rank features for a minimum viable product (MVP). It’s an agile prioritization method advocated by Dr. Alistair Cockburn, an agile software development expert.
The Walking Skeleton method is often used to prioritize features in an MVP and helps teams choose what’s absolutely critical to work on.
Walking Skeleton is a form of proof of concept or your basic architectural concept. Where a proof of concept typically focuses more on single functionality, a “Walking Skeleton” takes a minimalistic approach to end-to-end implementation.
A “Walking Skeleton” is not an outline of your concept (only a “skeleton”) but it is really executable and shippable (it can “walk”) and should be accompanied with tests.
- This method focuses only on key functionality.
- Defining core features happens quite quickly.
- It puts your MVP to the test and checks its validity.
- It helps initiate rapid feedback loops.
- Although this method helps initiate rapid prioritization, it often leads to late releases.
- There’s always a temptation to cut corners and release the product as fast as possible.
- Sometimes, your MVP will lack some important functionality.
Prioritization Mistakes to Avoid
Each method listed above has its own advantages and disadvantages, and you have to choose the right one that aligns with your present circumstances and business objectives. Priorities tie into more comprehensive business strategies, so it’s crucial to think about the long-term and avoid personal biases.
Here are some smart and easy ways to avoid mistakes and make better product decisions:
Avoid Choice Paralysis
Avoid choice paralysis by placing your features into themes. This method helps quickly align your feature themes with your product goals, business objectives, and product strategy.
Avoid Focusing on the Wrong Features
Regardless of the approach you choose, there’s always a risk of focusing on the wrong feature. To avoid these types of mistakes, break down your features based on feasibility, desirability, and viability.
Avoid Prioritizing Features by Present Limitations
Instead of focusing on what you have right now, concentrate on what you don’t have. Start looking at your people and processes and make decisions accordingly.
It’s a mistake to think that all feature prioritization techniques will work for your product. For example, established businesses that already have a product need an approach like RICE as this method nicely fits into their existing lifecycle.
For startups building an MVP, the best models are Kano and Walking Skeleton. You can also use the Kano model to prototype and get feedback on UXs. MoSCoW is one of the best product backlog prioritization techniques to help figure out which feature to work on first. Lean Prioritization will also work well in these situations.
It’s always exciting to build new products and features, but it’s not always easy to bring ideas to life. Using the appropriate product feature prioritization methods discussed above, you can concentrate on your long-term strategy and not get distracted by short-term benefits.
As such, keep an eye on the bigger picture throughout the development lifecycle. Feature prioritization should also be a collaborative exercise that gets everyone on the same page quickly.