As a product consultant and trainer, I hear a lot of similar questions over and over. Many are what you might expect and are regularly debated on Twitter: “What’s the difference between a product manager and a product owner?” “How should I manage my roadmap?” “Do product managers need to know how to code?”
But beyond these hot topics, there’s one question I think comes up even more consistently: “How should I manage bugs?” Bugs aren’t the sexiest of topics in the tech world, but we’ve all got them. So let’s talk about what to do with them.
An Ounce of Prevention
I live in Texas – land of hot summers and lots of mosquitos. You might say we have a bug problem! One thing we know for certain is that once you have mosquitos, they are nearly impossible to get rid of. And the earlier in the year that you spot your first mosquito, you know the worse it’s going to be as the season goes on. So we focus heavily on prevention – making sure there is no standing water for larvae to grow in, pre-treating spots where we can’t stop water collecting, and other tactics to try and avoid that first mosquito.
What does this have to do with software? Managing bugs is a lot like managing mosquitoes – you should avoid letting them into the environment in the first place. And the earlier you let a bug slip through in a project, the more bugs you’ll probably see as you go, and the harder it will be to clean them up.
This may seem like common sense, but how often have you had a story almost finished at the end of an iteration, but just have a couple bugs left to fix? And how many times has someone suggested “Well let’s just go ahead and close the story and log the bugs for the next iteration.”? Don’t do this! If something is not working properly while you are developing functionality, or something you just built has now broken something else, it’s not a bug. It is unfinished code. Fix it now. (There is obviously some nuance here around edge cases that you might choose not to fix, but that is probably another post in itself.)
There is no Magic Queue
I find that people like to talk about bugs as though they exist in an alternate dimension, where working on them doesn’t detract from anything else. There is a temptation to give bugs a special status, allocate a specific amount of time in each iteration to them, or in extreme cases, put some false timeline on how quickly they should be fixed (“all reported bugs fixed within five days”).
The problem here is one of opportunity cost. At the end of the day, a bug is just another piece of work. Any time that your team spends fixing a bug is time that is not spent working on the next thing up on your roadmap. As product managers, we should always manage our backlog so that the next most important thing is at the top of the list. Many times, the bug you would work on is less important than other things on your backlog. By working on the lower priority bug, you are deferring the more important work that can help you reach your strategic goals.
The flip side of this is also true: sometimes the next most important thing may be five or six bugs that really need to be fixed before adding yet another feature on top of a fragile platform. If you live in a world of separate queues or say you’ll always devote 20% of the team’s time to bugs, you actually lose the opportunity to say “this week, we are squashing these bugs that have been plaguing us before we do another thing.” In reality, you will likely have a mix of bugs and features in your backlog, but the most important thing is that you prioritize strategically and intentionally, not letting a false constraint determine what the ratio of your backlog looks like.
So how do you manage this? I actually do recommend prioritizing bugs in their own queue, putting the highest priority bugs at the top. This keeps things clean for roles like customer support who regularly add to the list or add additional information. I can have discussions about which bugs are really causing the most pain and adjust accordingly. Then I prioritize my roadmap work. Once I have a list of the next several things up in my backlog, I look at my top bugs and start the evaluation – are any of these bugs a higher priority than the things at the top of my list? If yes, I figure out where they should fit, and my prioritized backlog is complete.
To Estimate or not to Estimate
Sometimes I’ll get into discussions with teams about whether or not you should estimate bugs. As with most things in product, my answer is, it depends. Although rather than depending on moving situations, this one depends more on the philosophy of your organization.
There are generally three ways people deal with estimating bugs:
- Estimate bugs like you do stories – give it a story point value by complexity and have it factor into your velocity
- Give bugs some arbitrary point value (3?) and use that in your velocity calculation knowing some will actually be bigger than the assigned value and some smaller
- Don’t estimate bugs at all, and don’t factor them into your velocity calculations
The more a team cares about velocity, the more passionate the estimation debate becomes. Particularly in an organization where development teams get scrutinized over their velocity, the conversation over how to get “credit” for bugs becomes far more important. I am not a proponent of focusing on velocity in general (again, probably another entire post on this one!), so I tend to skew towards method 2 or 3. Chasing perfect estimation is futile in general, but if your reality is that you have to track how much work your team is doing, find some number that feels reasonable and move on. If you come across the mega-bug that ends up requiring a rewrite of an entire part of your system, then turn it into a story and account for it properly. Because as we discussed earlier, a bug is just another piece of work in your backlog, and you’re free to call it whatever you want!
Why not Make a Bug Team?
Some companies attempt to solve the bug problem by setting aside a portion of their budget and creating a standalone “Bug Team”, or more nicely named “Maintenance Team”, whose job is to fix bugs and do all of that pesky platform maintenance that needs to happen. In my opinion, this is the absolute worst of all the ways you could handle bugs.
First, you are still not dealing with opportunity cost or giving yourself the flexibility to prioritize the next most important thing. It may feel like you are in complete control of your backlog because those bugs are no longer intruding. But in reality, it is just hiding the work and still puts you at risk of working on bugs that are far less important than what those team members could be doing elsewhere.
Second, no one wants to work on a bug team. It would be no fun to clean up someone else’s bugs all day long, never getting to put your own fingerprints on what is getting built. It is easier for the development team to let a bug slip by when they know they won’t actually have to fix it. And most importantly, it is hard to motivate a team whose work doesn’t feel like it is actively contributing to the product vision. Doing a “rotating bug team”, where a couple of the regular development team members focus on bugs for a few weeks each, doesn’t work either. It becomes really easy to avoid fixing the messy bugs or work really slowly on one knowing if you can just stall long enough, it will be someone else’s problem soon. A terrible concept all round.
Bugs Aren’t Special
All of this talk about bugs really boils down to one primary concept: bugs aren’t special. We get into so many debates about how to manage them or how they should count or who should work on them, but what we really want is to build products that our customers enjoy using. Bugs can get in the way of that, but so can building the wrong thing, or bad UX, or making inaccessible products. Focus on what your customers really need in order to love your product, and fix the bugs that keep you from accomplishing that goal.