Solving Issues Prioritization Nightmare

We don’t wanna sell you a pack of features and integrations.

The prioritization problem is not about features. It’s about collisions, choices, compromises, and conflicts.

Here is our story of fighting prioritization chaos.

Think about it. Sign up if it resonates.

The Problem with Issue Prioritization and Teammates Synchronization

CEO asks to build this, competitors already have this, your biggest customers want to pay more for this, advisors think you should focus on this, your product team wants to build this, and so on. Ask questions before you say “Yes”: Does this fit the vision? Is it a forward step along the way? Will it matter in 5 years?

"Product Strategy is About Saying No" by Des Traynor from Intercom

~ ~ ~ ~ ~ ~ ~ ~ ~

Hiten Shah honestly said that prioritization problems ruined KissMetrics. He would drop “Hiten bombs” on someone in the company. Some new idea, some new direction, some new brilliant thing he came up with. "Good or bad, none of my ideas were based on any kind of framework or filter. I was shooting from the hip. Thinking that I was helping us focus and execute. I was dead wrong." The team was scattered and they lost it all.

"My Billion Dollar Mistake" by Hiten Shah from KissMetrics

~ ~ ~ ~ ~ ~ ~ ~ ~

Steli Efti from Close.io recently wrote a post about the importance of over-communication in remote teams. You have to make sure your team stays in touch with each other, way beyond what's necessary to get the job done. Everybody should get not only Who is doing What, but also Why.

Linkedin post by Steli Efti from Close.io

~ ~ ~ ~ ~ ~ ~ ~ ~

Carrying out useless tasks is the greatest company’s time stealing.

The Fail of RICE: How Internal Prioritization Framework Was Born

We dealt with the same problems too. It's challenging to keep everybody on the same page in a remote team, sometimes working from different time zones. Customers demanded features, managers offered ideas, developers had their own product vision. The list of issues was growing rapidly. Unimportant tasks were randomly taken out of the backlog and transferred to the development unannounced. Product managers kept asking "Why even do this? The priorities have long since changed!"

We tried to discuss all our Jira Issues every week. We tracked important things on Google Keep. Added some fancy Jira plug-ins. None of this was helping. It was a mess.

The reason is that we didn't have common objective criteria for assessing the importance of the issues. Every one of us was pursuing their own interests, and remote working was turning it all into complete chaos. That's when we decided to try the existing prioritization frameworks.

Tasting RICE

We started with the RICE Score—a four-factor prioritization framework for evaluating product ideas: Reach, Impact, Confidence, and Effort.

RICE prioritization model

But it didn't work for us. The teams were confused on the I (Impact). Everybody had their own picture of what is impactful. Should we value an issue for money or reliability impact?

Developers valued code refactoring as crucial for the product. But fixing the help center article layout is just a waste of time. And vice versa for the managers.

The biggest problem of RICE — it doesn't help each team member to keep in mind what exactly is impactful right now.

Fixing RICE: Syncing Teams on Impactful Things

Improving prioritization issues is not about a tool or a framework. It's about fixing the broken collaboration. We discussed what is important and came up with a list of requirements for the evaluation criteria. They must: 

  • Be clear and unequivocal.
  • Reflect relevant company objectives.
  • Consider business, product, marketing, and development goals.
  • Consider developers’ and managers’ points of view.

At the end of the day we ended up with a mix of:

North Star Metric + RICE + AARRR + Business Pain Point:

  • Sales. Influences the money income (Acquisition from AARRR).
  • Activation. Helps to understand how the product works (Activation from AARRR).
  • Retention. Increase user's motivation to use the product again (Retention from AARRR).
  • Service. Helps us spend on customer support less time without quality loss (Our Business Pain Point).
  • FB Ads. Increase the amount of Facebook Ads a user launches via our product. Important for Facebook Marketing Partnership (Product North Star Metric). ‍
  • Time. Time spent on development, complexity (Effort from RICE).
  • Mass. How many customers or product units or how much money this feature will affect (Reach from RICE).

To simplify the evaluation process we borrowed a weighted scoring model: different relative weights are assigned to different criteria. For example, time spent on development should have a multiplier of -3 as we prefer to find quick wins.

You must assign a score from 0 to 3 to each criterion:

  • 3 — must be;
  • 2 — should be;
  • 1 — could be;
  • 0 — won't be.

Jira + Google Sheets: Marriage and Divorce

Then, we had to put it all together. Like many others, we started with Google Sheets. Automate.io helped to pull data from Jira. 5 sheets as databases for calculations. The results were great for the first few weeks.

The first version of our weighted-prioritization framework built with Google Sheets, Jira Cloud and Automate.io

But in two months our shiny new prioritization system became a giant and slow file with lots of problems. 

  • Issue import was constantly crashing.
  • Lots of duplicated data rows.
  • Inflexible calculation.
  • Dozens of browser tabs to read issue context.
  • The team often forgot to evaluate new issues. 

One of our teammates became a spreadsheet admin. His mission was to constantly fix the spreadsheet.

At the end of the day, the team was annoyed with a dull routine nobody wanted to waste the time for.

Building Own Tool for Fast Prioritization

Finally, we decided to stop beating the dead horse and build our own tool.

We tried to make the interface as fast and as simple as possible. Ducalis resembles the usual spreadsheets, only formulas don't fall apart. And you don't need to switch between browser tabs—you assign scores, read the issue context, and see criteria descriptions on a single screen.

Issues sync in real-time. Criteria descriptions appear in pop-ups—no need remembering them or switching to a separate document. The calculation formula won’t crash if you change something, and scores won’t disappear. The whole team can assign scores simultaneously. Ducalis doesn't freeze and the UI works super fast. You can evaluate dozens of issues in a few minutes without taking hands off the keyboard.

Blazing fast UI, Hotkeys, Focus Mode, etc.

Bird-eye View on Team's Priorities

After the evaluation, scores are calculated and issues ranked on the Top Priorities page automatically. You can quickly see the overall picture of the most important project tasks. All necessary details like issue status, sprint, priority, and description are on one screen.

A bird-eye view on team's top priorities

Every Project is Unique

Then, we started using Ducalis boards for evaluating different projects—two product development boards and one marketing plan board. A board is a combination of the What (issues and tasks), the Who (teammates), and the How (criteria).

We realized that we can apply the same approach in many areas. 

  • Feature requests
  • Bug-fixing
  • Marketing tasks
  • Content ideas
We use three Ducalis boards—two for feature ideas and one for marketing tasks.

Overwhelmingly Positive Results

  • The whole process takes only 15-20 minutes if you sort the tasks out weekly.
  • You can see what’s your team’s priority and what’s not.
  • Backlog issues are evaluated by the whole team, not by particular managers.
  • Any number of users can evaluate simultaneously.
  • Settings can always be configured: you can add/remove users and criteria without data loss. 
  • No need to switch the tabs: issue context and criteria descriptions are on a single screen.
  • Real-time synchronization—if the issue changes in the tracker, so does it in Ducalis.
  • Slack and email notifications remind the team about the evaluation and create a strong habit.
  • The whole team understands the company's objectives and priorities.

Here you can read about Ducalis Workflow in more detail.

It does magic to the team when they look at the Top Priorities—not only they see what is important, they also understand why. Yes, everyone perceives the tasks differently. But that’s a cool bonus because you collect diverse opinions.

We've come a long and painful way. After a year of using Ducalis, we came to the conclusion that Google Sheets aren't suitable for collaborative prioritization. The only viable solution is to archive them and replace with a special tool.

First Users Testimonials

We launched on March 16, 2020. The number of applications turned out to be ten times greater than we could have imagined. The Spreadsheet Prioritization was a common pain that could now be cured.

The feedback we received after the first tests:

The best tool for backlog grooming.
Cool thing! Especially, I like the scoring expiration.
As soon as I saw it, I knew—we need it.
I have approached this topic from different angles, and it seems like the best solution so far.
It took me and my other colleague about two and a half hours in total to evaluate 80 features. That's fast.
Ducalis is a ready-made workflow.
Helps the whole team to understand where we're heading.
  1. The Problem with Issue Prioritization and Teammates Synchronization
  2. The Fail of RICE: How Internal Prioritization Framework Was Born
  3. Jira + Google Sheets: Marriage and Divorce
  4. Building Own Tool for Fast Prioritization
  5. Overwhelmingly Positive Results
  6. First Users Testimonials

Start prioritizing today

No Credit card required  ·  Cancel anytime
Secure the exclusive Early Bird pricing now

$5/user/month for all features (email/chat support)

$49/user/month for all features (premium support with video call trainings).