Tracking issues isn’t easy. It’s tough to discover them, tough to keep them updated and accurate, and tougher still to actually resolve them. There are quite a few challenges that can weigh down a good issue tracking process, but fortunately there are some simple fixes for each. Here are a few we’ve discovered over the years and some ways to solve them.
The team doesn’t participate.
The most basic problem is getting your team to actually use the software. Participation and collaboration are the cornerstones of a good issue tracking process, but that collaboration and teamwork runs smoothest when everyone is using the same system.
If everyone isn’t working together the process will fall apart before you even get started. If your team is using email or littering their desks with sticky notes that’s a pretty sure sign you have a problem.
Solution: Get everyone using the same system and make sure everyone is comfortable with it.
It’s difficult to report issues.
If it’s too hard to actually report an issue, for example, if there are too many required, but irrelevant, fields in your forms, or it’s too hard to upload relevant files, or it’s just too difficult to login and find the “new issue” link, then no one will ever report issues in the first place. And unreported issues are unsolved issues.
Just as bad as unreported issues are issues that get reported in a non-standard way. If your team’s designers hate the issue tracker so bad that they take to using another tool or emailing issues, it’s only a matter of time until issues slip through the cracks. It’s imperative that your tools make it easy for everyone to contribute and participate.
Solution: Keep your forms simple, offer things like drag-and-drop file uploading, and, if all else fails, email integration for those who prefer to report issues via email.
Issues slip through the cracks.
If you can’t find an issue, you can’t fix it. Oftentimes, countless categories, milestones, projects, and buckets of organization create nooks and crannies where issues can hide and be forgotten. Statuses like “On Hold” and “Pending” are great for this. Issues get put on hold without a corresponding process for people to regularly go through and evaluate them. They frequently end up forgotten and overlooked.
This can be exacerbated by inefficient or confusing sorting, filtering, and searching. Sorting and filtering needs to be powerful and yet simple. Over-complicating these tools can mean you’ll accidentally filter out half of your relevant issues and not even realize it.
Solution: Keep groups and options to a minimum and avoid creating buckets for issues to quietly hide in.
Over-engineering the process.
The best way to avoid over-engineering anything is to keep things as simple as possible. The best way to do that is to try to solve your problems with your existing tools before you create new tools.
One example of this we’ve discovered is having too many possible statuses for an issue.
Keeping things simple – we have three choices, “Open”, “Resolved”, and “Closed” – avoids both the paradox of choice and any overlap in ambiguous statuses. If you have ten possibilities with completely custom statuses, you’ve added mental overhead to the process of choosing one and an increased likelihood that they overlap or aren’t clear. Keeping it simple means you don’t have to waste time determining the correct status for a given issue.
Too many statuses creates crevices for issues to hide in and be forgotten when filtering issues. Overly detailed statuses can also confuse non-technical people who will wonder, “what’s the difference between accepted and in progress?” Good question. Avoid it by making statuses clear and simple.
A related problem, and the reason some teams will clamor of more status possibilities, is the tendency to conflate statuses with resolutions. For example, “working as designed” isn’t a status; it’s a resolution. An issue can be marked as resolved, and the comment should clarify why it was resolved. Similarly, “can’t reproduce” isn’t a status; it’s a resolution. You’d never go back and try to find all of the “can’t reproduce” issues. It’s simply not a grouping that’s useful.
Solution: Keep your status options simple and focus on truly different states of work with clear lines between them.
Over-reliance on software for process.
Software is a tool. Tools are wielded by people. The tool alone can only do so much. Without people to guide them even the best of tools will fail. That’s why you need to make people the most important part of your issue process. Trying to offload process wholly onto software is an exercise in futility.
Make room for the human aspects of issue tracking, like regular testing sessions, bug triaging, consistent iteration and release cycles, and dedicated time for fixing bugs.
Solution: Invest time and effort in the human processes that will pair with and support the software.
Tracking issues isn’t always easy, but you can make it easier by simplifying. Cut out the cruft. Make sure you have good software and good processes that help your team wield that software effectively. Let the software do the things software is good at and let your team fill in the parts of the process that people are good at.