Using Advanced Aha! Scorecards to Quickly Prioritize Features
At Ricochet, we spend a significant amount of time developing internal products in addition to our billable agency work. We find that in addition to serving as a wellspring of creative energy for our team, internal product development also keeps us on the cutting edge of new technologies—something that is pretty crucial for a technology firm.
This model isn’t without its challenges though. It’s hard to balance the needs of a digital agency and a product company without mental space and available hours getting gobbled up by the “billable beast”.
We’ve been able to navigate these challenges by systematizing our approach to billable and unbillable work in order to free our minds up for creative work, rather than wasting cycles on “holding everything together”. We wrote about this in a previous blog post where we discussed how we use Aha! and JIRA together to make this easier.
One feature we did not mention in that article was the Aha! Scorecard functionality. We believe this is one of the most powerful features in the entire suite as it packs a powerful punch for product managers. I’d like to share more because I feel pretty strongly that the feature addresses one of the missing pieces to modern ad-hoc Product Management.
But first, let’s take a look at why things are so broken right now.
In my experience, unless your organization is of a certain size or your team has a tremendous amount of insight and experience, most places don’t actually have product managers. Rather, you end up with either nobody, or a cohort of cowboys (and cowgirls) that shoot from the hip, make gut decisions, and generally fight fires.
In this case, there is either a void for product managers that the team tries to have fulfilled through project management software (like JIRA, Trello, Asana, etc..), or there is someone through whom all the ideas, bugs, features, etc…must flow. This person attempts to make sense of the onslaught of data with spreadsheets or afor mentioned project management software, and does the best he or she can to prioritize features from the backlog.
Initially, this is actually quite easy as there isn’t usually that much in the backlog. But as time goes on, the backlog becomes impossibly complex, intertwined, and pretty much impossible to navigate. It becomes filled with duplicate issues, crazy hair-brained ideas, dire bugs, not so dire bugs, good ideas that need a little definition...you get the idea. And because of this, it actually becomes incredibly overwhelming to even take a peek past the first few tickets. It’s impossible for the brain to efficiently sort and make sense of all the data on its own.
Raise your hand if you’ve ever experienced the following:
You say to yourself, “I’m finally going to get on top of this backlog and chart a course forward!”. You start going through tickets. As you find ones that are important, you start dragging them to the top of the pile. But as you go along, you start finding a lot of stuff that’s really important.
Eventually, you realize that you’re developing a backlog on top of your backlog. And it is going to require many more rounds, going over the same tickets multiple times in iterations to actually get everything in order.
Once you get to the end of that process, you realize that many more issues have since come in and you’re not sure how those fit with your new order (can you keep the context of 50 user stories in your brain at any one time? If you can, you are my hero).
You give up in frustration, or resort to the default “firefighting mode”, merely squashing bugs as they come in. You endeavor to stay away from the backlog for as long as possible from that day forward because it just takes too much emotional energy to venture into it.
In extreme cases, small ideas, bugs or features might actually be *discouraged* because it’s too hard to navigate them once they are in your project management system.
The brain is meant to fit this much stuff inside on its own
Unless you have some sort of system or technology to manage this process, you could easily use a full-time person just to keep on top of tickets. This is a luxury that many cannot afford, and in fact, it’s not even necessary if you have the right tools.
This is where Aha! Scorecards come in and dramatically reduce the time we spend navigating ideas.
The power behind the scorecard feature is how they are constructed. You are essentially able to define the vectors that are most important to you, then define the “weight” of each of the vectors in line with the priorities of your organization.
So for instance, here’s a scorecard for one of our internal products:
-2 × Complexity + Operational Improvement + 0.75 × Positive Client Impact + 0.5 × Long-term Strategic Company Importance + 2.0 × Impact on New Business
This is the equation that will provide a final score. Notice the numbers in front of each vector? Once you snap out of your flashback from high school algebra, you can immediately see the power of this: When you see a new ticket in Aha!, you can give it a “score” for each one of these vectors on a scale of 0-10. When the final score is calculated, it is passed through the above equation to give you a final “score” for the entire ticket.
So for example, let’s say I gave the user story, “As a PM, I should receive an alert when one of my projects is projected to go over budget” the score below:
- For Complexity, let’s say I give it a 5. This could be a bit complicated, but it wouldn’t be too crazy.
- For Operational Improvement, let’s make that a 7 because as a services agency, this is pretty crucial to us.
- For Positive Client Impact, let’s give it a 7. When we can inform our clients of budget early, we’re all able to adjust quickly and put out fires before they begin.
- Long term strategic importance? Well, it’s more of an immediate term thing, but there is some long term value, too. I’ll give it a 3.
- Impact on new business? This actually doesn’t really impact new business so I’ll give it a 0.
So, what does that bring us to?
-2 × Complexity (5) + Operational Improvement (7) + 0.75 × Positive Client Impact (7) + 0.5 × Long-term Strategic Company Importance (3) + 2.0 × Impact on New Business (0)
This brings the final score to: -10 + 7 + 5.25 + 1.5 + 0 = 3.75.
The power behind this is two-fold. First, I am able to give negative and/or disproportionately larger scores to certain factors like Complexity, for example. When something is more complex, that’s actually a bad thing. So everything else being equal, the more complex thing should be ranked lower since it will be harder to implement.
In fact, given the above equation, something that’s less impactful but is slightly less complex could actually end up having a higher score, and thus get prioritized above something that is complex but more impactful.
Next, because you’re ranking your tickets along these vectors, if the importance of any one of them changes with time, you can change your scorecard and the scores of all tickets immediately change. When you stop and think about it, this is crazy powerful because priorities always change and you shouldn’t have to reassess every user story every time something changes—especially when the backlog is huge.
Know what to do next with a single click
The end result of the above is that when you are looking for the next batch of features to pull into your release, you no longer have to go through and fit everything in your brain. And you aren’t relegated to just dealing with the most recent fires, either. Rather, you can go to your backlog, sort on “weight” and have the cream rise to the top. Always.
As someone who has navigated all sorts of backlogs in my time, that alone is so beautiful that it almost brings a tear to my eye. And if you’ve ever felt the pain of an out of control backlog, it probably does the same for you.
