How we prioritize feature development at Canny

· 7 min read
How we prioritize feature development at Canny

Roadmap prioritization is hard but so important.

It’s hard because there are many factors involved—other priorities, customers, internal stakeholders, 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 are able to identify the most impactful ones to build. 

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. 

Here’s an excerpt from PM Chats, Canny’s podcast on product management, where we hear from PMs about prioritization, roadmapping, and more.

Where a spreadsheet fell short was:

  1. Not integrating well with the rest of our stack (eg. user feedback, project management, etc.)
  2. 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 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:

  1. Big company initiatives
    Where do we see Canny headed? Are there big bets we want to take?
  2. 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.
  3. 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. 

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.

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, 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! 

Canny free trial

Sarah Hum

Hey there, I'm one of the co-founders of Canny. As a founder, I dabble in pretty much everything but my expertise is in product design. Outside work, I enjoy digital illustration, a cappella, and hanging out with our dog, Emmy.

All Posts · Twitter

Canny is a user feedback tool. We help software companies track feedback to build better products.
Inline Feedbacks
View all comments
© Canny 2023
Privacy · Terms · Security