Bugs aren’t the hottest topic in the tech world. However, every team will encounter bugs in their dev process and needs an adequate manner to deal with them.

There is nothing special about bugs that makes them automatically more important than everything else. The real challenge is one of opportunity costs. Overall, a bug is just another piece of work and any time that your team spends fixing a bug is time spent not working on the next thing up on your roadmap. Since roadmaps imply ruthless prioritization, picking a task of a lesser priority can prevent you from reaching your goals.

The reverse side of this is also true: sometimes the next most important action could be a couple of related bugs that really need to be resolved before adding yet another functionality on top of a delicate platform.

So how can we do it properly?

I first recommend you add all the bugs in their own queue and prioritize them based on importance and urgency.

Importance refers to how much the bug impacts the app’s vital functionalities. It should also consider the availability of workarounds and how many users are overall affected.

Urgency refers to how long a bug can wait until fixed. Once you have a good understanding of its importance, urgency comes naturally.

Now do a heuristic comparison of your main roadmap with the bug list and try to get a feel of how to prioritize what accordingly. This is not a fixed science since you are comparing apples with oranges so “heuristic” is the main keyword.

If a bug is a big enough pain in the ass then go ahead and convert it into a full-scale project.

Small, lesser bugs can be fixed in the intermission between projects. Or, if the list gets real heavy then schedule a bug fixing cycle where everyone in your tech team does nothing but this.