Roadmap prioritization is hard but so important.
It’s hard because there are many factors to consider — other priorities, product strategy fit, customer needs, internal stakeholder input, metrics, goals, and more. Prioritization is a huge balancing act and why many people consider it more of an art than a science.
It’s important because resources are always limited. Building a great product relies on delivering the most value as soon as possible. Given a backlog of features, the best product teams can identify the most impactful ones to build.
So, if it’s so hard and important, how do you prioritize features?
Let’s look at that in more detail. We’ll also share an example — how we prioritize features here at Canny.
Table of Contents
What is feature prioritization?
At a high-level, product feature prioritization is the process of deciding which features should be developed first.
There are a lot of ways to do that, and it can get really technical.
You ultimately evaluate the potential impact and value each feature offers, and weigh that against what it would take to build it.
Impact could include factors like revenue potential, customer feedback, market demand, fit with strategic vision, etc. Resources most commonly are staff time and money required.
By applying a feature prioritization framework to all your ideas, you’ll build a ranked and prioritized list of features that guide your product development process. Essentially, this gives you a product backlog. All of your ideas are ranked and you can focus on building the most important and impactful features first.
A product team typically plans their product roadmap by pulling ideas from the top of the list.
While that’s the gist of feature prioritization, there are several different frameworks commonly used in product management.
Let’s look at them now.
Popular feature prioritization frameworks
There are several different prioritization frameworks that product managers commonly use.
At Canny, we use the weighted scoring method. We find it the most straightforward and easy to use. It does the job – helps us quickly see which projects are the most impactful.
In basic terms, it helps with opportunity scoring – calculating the score by dividing the potential impact by the required effort.
We’ll look at how we do this more in the next section.
That’s just one framework, though. Here’s a quick look at some other popular ones.
RICE
This model looks at 4 factors: reach, impact, confidence, and effort. You multiply reach, impact, and confidence together. Then, divide them by the estimated effort. This gives you a score to work with.
Impact/Effort Matrix
In this model, you have a 2X2 grid with impact on one axis, and effort on the other. This gives you four quadrants – low-effort & low-impact, low-effort & high-impact, high-effort & low-impact, and high-effort & high-impact. You place each idea on the grid, and you can quickly see what the biggest opportunities are.
Feasibility, desirability and viability scorecard
This model looks at if the feature is something users want (desirability), if it’s likely to succeed (viability), and if it’s actually possible to build (feasibility). You score ideas based on each factor, and those with higher total scores are the ones you should pursue.
MoSCoW method
This prioritization framework categorizes ideas in four groups: must have, should have, could have, will not have. That lets your team focus on the most critical features first, moving onto less critical ones when you’re able to. You’ll still need to score these ideas with a different model, but MoSCoW helps you understand an idea’s importance from there.
Cost of delay
This framework tries to place a value on each idea. You first estimate what the expected revenue from the idea is in a given time (say, monthly), and then multiply that by the time it will take to ship the feature. This lets you know how expensive waiting to ship the feature is. If the number is high, you’ll want to prioritize it. If the number is low, it’s unlikely your company will see a revenue impact and you might want to deprioritize it.
Kano model
This is a way of figuring out what features are most likely to satisfy customers, and weighing that against the investment to build the feature. It helps companies figure out which specific feature is most important to their customers, so they can make sure to build the right features in their product.
You can learn more about these frameworks in our detailed guide on prioritization frameworks.
This is just a sampling of prioritization frameworks, and there are a lot more that you can explore. Product prioritization needs to make sense for your team, so make sure you choose one that suits your team’s needs and provides relevant opportunity scoring.
How we prioritize features at Canny
There are so many different ways teams can approach prioritization. At Canny, we previously used a spreadsheet to prioritize. We were able to quickly and easily score and rank projects.
Where a spreadsheet fell short was:
- Not integrating well with the rest of our stack (eg. user feedback, customer satisfaction, project management, etc.)
- Data is static while real-world data is always changing (eg. potential revenue, reach, etc.) so spreadsheets quickly become stale
After doing a bunch of research, we learned many teams were feeling similarly. Since Canny is already a home for user feedback, prioritization was a natural extension. Our team set out to build a feature request solution that aims to work for a variety of approaches.
We now use our own prioritization feature to prioritize.
How we prioritize: general overview
Our team does planning on a quarterly basis. To start, we put together a list of around thirty items that we should consider working on. Thirty works for us so far based on how big our product team is.
These items are a combination of:
- Big company initiatives
Where do we see Canny headed? Are there big bets we want to take? - Popular customer requests
Our customers use Canny to solve a problem for them. They will give us feedback if that isn’t the case. With popular requests, we consider the problem at the source of the feedback. From there, we come up with a solution that may or may not be exactly what the request asked for. - User experience improvements
We care a lot about product quality. This means reserving time to improve existing experiences and building features that improve UX. A lot of these are quick wins.
Once we have thirty items pulled from the larger backlog, we use a weighted scoring method. At its simplest, the formula is impact divided by effort.
Frameworks like RICE build on top of that basic formula. Weighted scoring gives us an objective final score for each potential project.
Understanding impact
Every quarter, we reconsider what our key metrics are. They’re usually business indicators like ARPU or product indicators like admin sessions. These metrics align with non-product company efforts as well. The important thing is that they’re all measurable so we can see the lift quarter to quarter across the whole team.
We aim to have around three key metrics each quarter. From there, we set a “type” and assign weights depending on importance for each metric.
We prefer using stars for impact scoring. They’re very easy to assign and still output a granular-enough score. Canny squares stars so, behind the scenes, the values are exponential. If you’re curious about the score formula, we break it down here .
We also have a “priority” column using the checkbox type. This means we’re manually bumping the priority of a feature. We usually bump things that we’ve promised to customers, projects that other features depend on, or simply things we really want to do.
Prioritization in Canny is flexible so you can adjust weights or add/remove factors anytime.
With the formula all ready to go, we’re ready to prioritize product features.
Scoring thirty items is a quick task. We make our best guess at impact and score each item relative to each other. From there, we can loop in engineering to talk about effort scores.
Determining your impact factors
We’ve discussed some of the factors we use to determine what impact a potential feature could have. They work for us, but it’s important you know what factors will have impact for your business.
Here are some common impact factors:
- Potential revenue – the associated deal value, ARR or MRR, based on customers interested in the new feature
- Popularity – how many user votes does the idea have?
- Churn impact – can it help drive customer satisfaction, boost net promoter score, reduce churn, etc?
- Customer segment – is the feature really important to a particular customer segment?
- Competitive landscape – does this feature make our product more competitive?
These are just examples. Make sure you’re prioritizing features that have the most impact on the metrics that matter to you.
Understanding effort
For effort, we use a 1-10 scale which maps to:
1: 1 hour
2: 2 hours
3: 4 hours
4: 1 day (8 hours)
5: 2 days (16 hours)
6: 1 week (40 hours)
7: 2 weeks (80 hours)
8: 1 month (160 hours)
9: 2 months (320 hours)
Canny’s prioritization feature also supports assigning effort with Fibonacci numbers. Many agile teams and teams who use Jira story points are familiar with this.
These time estimates include both engineering and design time. We try to over-estimate here because things almost always take longer than we think.
To do this accurately, it’s important for us to understand scope. We usually have a very good idea of what this should be just by looking at our Canny posts. Customers often chime in to elaborate on their use case or problem they’re facing.
If we need more information, we add a comment to the post requesting insights from people who have voted . Additionally, since we have a list of people interested in the feature, we can reach out to them directly. This is very handy compared to annoying people with a wide email blast.
Once both effort and impact are in, we have the final score.
Using the score
After scoring every item on our roadmap, we have something that looks like this.
From here, we’re off to execution mode and work our way down the list.
That said, we still make some room for flexibility here. We try to balance our team’s preferences and strengths.
Our engineers are free to pick projects near the top of the list that sound most appealing to them. They might be looking for a project that will challenge them technically or just looking for a quick, fun project.
Everything we score is important, but there is flexibility in the order we build things. If a feature is high up on the list, we’ll get to it eventually!
Focus on impact
We think our method of prioritizing can work well for companies of all sizes. Small companies can do just like we have with a new roadmap per sprint, month, or quarter. Bigger companies should have product teams broken up into smaller groups, each operating like a small company with their own roadmap.
We’re making sure to introduce integrations that make prioritization a more streamlined step in product development. We want to make sure relevant information is constantly updating to help with decision making.
Priorities are ever-changing and a prioritization tool should support that.
We try to reserve most of our time on execution and make planning quick. We built Canny’s prioritization functionality to be a simple way to understand what priorities should be. The ultimate goal is to focus on impact.
We always enjoy hearing how other teams prioritize features, so I hope this was helpful. We’d love to hear your thoughts on what works for your team. Reach out to me on Twitter @SarahHum or leave us a comment here!
