Bug Tracking Guide

Introduction

In the challenging world of software development, efficient bug-tracking and issue management are critical to maintaining the quality and stability of your projects. This comprehensive guide is designed to help you understand the importance of bug-tracking tools, streamline your bug management workflow, and refine your QA processes.

This guide is useful for:

• Software developers: Unsure if their team needs a bug-tracking tool
• Team Leads: Struggling to organize their bug management workflow
• QA Teams: Eager to refine their process

The first part of this guide will go over the basics of what bug- and issue-tracking tools do.

The second and third parts will show you how Backlog can improve your workflow and how to use Backlog for bug-tracking.

The fourth part of this guide will cover some best practices.

Are you ready to learn more about bug-tracking?

Bug-tracking tools

For software development teams, finding, recording, and tracking bugs is an important part of creating a quality product. Bug and issue-tracking tools streamline that process, making it easy for teams to prioritize, assign, and fix bugs quickly and efficiently.

The cost of avoiding the investment

Some software teams choose to use spreadsheets for bug tracking and reporting instead of investing in a quality bug-tracking tool. While this may work as a temporary solution for small teams and projects, this method isn’t sustainable.

Teams end up with a few predictable problems:

• Lack of communication. It’s difficult to have conversations about each bug on a single shared spreadsheet.
• Lack of visibility. Team members end up having conversations via email, and those conversations lack any transparency to other team members.
• Lack of real-time updates. While you can check a shared spreadsheet at any time, there is no formal notification feature for alerting members of new bugs, progress, and updates.
• Lack of fluid priorities. All of the above lead to problems prioritizing and fixing the highest priority bugs first.
• Lack of a central repository. Descriptions, screenshots, feedback, etc., are spread across too many platforms and rarely easily accessible to everyone.
• Lack of insights. Without an organized set of data about your bugs to glean insights from, it can be challenging to discover patterns and trends in your software defects.
• Lack of integration with other work. With spreadsheets or even tools that are only meant for bug-tracking, you’ll always eventually run into the same problem: your bug-tracking workflow is happening in a silo, disconnected from the other tasks and projects your team is working on.

Benefits of bug-tracking tools

Bug-tracking tools provide a transparent, centralized location for all of your bug-tracking needs. They facilitate communication and provide real-time updates. Plus, tools like Backlog create a living archive of every bug your team encounters, so every team member today and in the future can access information about them.

The numerous advantages provided by these tools significantly impact a team’s productivity, collaboration, and overall quality of the software product, not to mention the clear ROI.

Here’s what you’ll see when you start using them:

• Improved communication: Centralizing communication around bugs ensures that all team members have access to the same information, enhancing transparency and reducing misunderstandings.
• Efficient bug management: Automating the process of tracking and prioritizing bugs allows teams to address critical issues promptly and improve response times.
• Enhanced collaboration: Bug-tracking tools support collaboration across various departments, ensuring that everyone involved in the development process is on the same page.
• Historical insights: Maintaining a historical log of bugs helps teams analyze patterns, identify recurrent issues, and improve future projects.
• Integration with development workflow: Seamless integration with existing development tools and pipelines ensures that bug-tracking doesn’t become a siloed activity but is part of the overall workflow.
• Data-driven decisions: Detailed metrics and reports from bug-tracking tools provide insights that allow teams to make informed decisions and continually improve their processes.

Elements of bug and issue tracking

Since 2004, Backlog has been helping software teams manage all aspects of the software development cycle, including tracking and managing bugs. Teams around the world plan, track, and release software using Backlog’s unique feature set. From creation through maintenance, Backlog is built to help teams deliver the best software possible.

Many free bug-tracking tools can capture and track bugs, but Backlog can help your team seamlessly manage the end-to-end development of your products.

Capturing bugs

When your team uncovers a new bug, it needs to be properly documented and understood in order for someone to fix it. Rather than relying on emails or spreadsheets, you need a tool that gives each bug its own living repository of information that can be searched and explored.

Issues in Backlog help you capture everything your team needs to know about a bug to get the problem fixed. Titles, descriptions, attachments, and other fields give you the space you need to fully explain when, where, and how bugs occur.

Prioritizing bugs

All bugs you capture need to be prioritized and assigned based on the bug’s urgency and your team’s current workload capacity. You need more than a tool for tracking bugs; you need a tool that can help you manage all of your separate workflows together. When you can view every moving piece your team is working on within a project, you can easily determine what needs to get done next.

With Backlog, you can set priorities for each bug, assign them to your team, and change due dates as needed to accommodate incoming projects and new bugs.

Tracking bugs

As new bugs are added and taken through your workflow, there are team members who will need to be made aware of these additions, status changes, comments, and updates. Keeping your team up-to-date in real-time is invaluable for efficiency.

With issue statuses, commenting, and targeted notifications, you can keep your issues up-to-date and make sure the right people are notified of important changes.

Releasing fixes

Whenever you can centralize more of your workflow in one place, you’ll see boosts in efficiency. Working on and releasing bug fixes shouldn’t require you to leave your bug-tracking tool.

Once it’s time to actually fix bugs, developers can create a new Git branch directly in Backlog. Backlog automatically updates issues to reflect pull requests, merges, builds, and more, tracking every bug as it moves through your workflow toward completion and deployment.

How to track bugs in Backlog

Now that you know what Backlog can do, let’s give you a brief idea of how to track bugs.

Step 1: Check for duplicate bugs

Before you do anything in Backlog, you need to be sure that your bug hasn’t already been reported.

Depending on how your team sets up their reporting workflow, you may need to bring the bug up in a team chat topic dedicated to bug reporting. Or you might need to submit the bug to a team lead for review. Or maybe you’re the one who needs to filter through your existing bugs using various parameters and search terms to determine if this is the first time the bug has been reported.

If it is the first time, you’ll move on to creating an issue. If it isn’t, you can read through the existing issue describing the bug and see if you can add any new information about how to recreate or fix the problem.

Step 2: Create a new bug issue

By default in Backlog, issues are set as “Tasks.” However, you can easily change the type of issue from Task to Bug, making it searchable as a bug in your database.

You’ll want to create a clear but concise subject for your title that accurately depicts the problem. Try not to be too broad with titles like “Add issue page isn’t working.” Instead, name your bugs according to what happens and when. Like, “Add issue page fails to save despite all required fields filled.”

Obviously, in your description, you want to describe the bug:

• What happens?
• When does it happen?
• Does it always happen?
• Under what circumstances is it happening now?
• What steps can you take to reproduce the event?

Issues in Backlog come with a number of other fields you can select, including:

• Assignee
• Priority
• Milestone
• Category
• Version
• Start Date
• Due Date
• Estimated Hours
• Actual Hours

You may not know what to put in some of these fields, and it’s up to you and your team to decide which ones are required for reporting a bug and how you’ll go about filling in any others throughout the course of your workflow.

Adding attachments, including screenshots and screen-capped GIFs of the bug, can help the assignee immensely in diagnosing the problem quickly.

As a final touch, you can choose who to notify of the bug. This could be your team lead, someone in QA, or another designated member of the team that you want to be aware of the issue’s addition.

With custom fields, you can personalize your issue creation page to include more options you might find useful. Many teams include text or drop-down fields for the environment, browser, or device on which the bug occurs.

Step 3: Prioritize and assign work

As time goes by, you’ll end up with a backlog of bugs that are continually being added, worked on, and fixed. This backlog will likely be organized by a manager or lead of some kind on your team. It is this person’s job to make sure bugs are properly prioritized and assigned depending on their urgency and the workload capacity of the team at a given time.

Luckily in Backlog, all issue types can be viewed together and understood visually with Gantt charts. You can see every task your team is working on in a given project alongside every bug that needs fixing or request that needs to be made.

From there, your team can decide what work it can handle in a given week and divvy that workload up using whatever best practices you’ve adopted from the project management methodology your team subscribes to.

Keeping all issues in one tool enables you to make better delivery estimates, manage your team’s time more effectively, and prioritize your backlog of tasks based on real-time updates from your team.

Step 4: Fix the bug!

Once a bug has been assigned and it comes time to work on it, software engineers can create a new git branch directly in Backlog. As team members begin making pull requests, merges, builds, etc., Backlog will track all changes automatically in the issue.

As your team works, status updates will keep you up-to-date on where each bug is in its workflow. Comments are a great way to ask questions or give feedback. Notifications allow you to select anyone else in the project when you need to inform team members of a vital update. Customizable notifications let you choose who on your team to notify so that you can keep the right people in the loop along the way.

As you work through each bug to your final fix, Backlog automatically tracks every change in real time so your team stays on the same page.

How to customize Backlog to meet your specific needs

Customizing Backlog can help tailor the tool to better fit your workflow and preferences. Here’s how you can make Backlog uniquely yours:

Custom fields

Adding custom fields allows you to capture additional information that is specific to your project needs.

• Add custom fields: Go to Project Settings and create fields like dropdowns, text, or date fields.
• Use cases: Gather extra information like browser type, operating system, or impact level.

Statuses and labels

Defining custom statuses and versions/milestones enables more precise tracking and categorization of issues.

• Custom statuses: Reflect your workflow steps accurately by defining specific statuses.
• Versions/milestones: Create versions/milestones to categorize and filter issues effectively.

Issue types

Adding different issue types helps in organizing not just bugs but also feature requests, improvements, and technical debts.

• Custom types: Add types like “Feature Request,” “Improvement,” or “Technical Debt.”
• Configuration: Set default properties and workflows for each type.

Notifications

Customizing notifications ensures that only relevant team members are informed about updates, reducing unnecessary interruptions.

• Targeted notifications: Customize who gets notified based on actions or updates.
• Configuration: Set up notification preferences to avoid overloading team members.

Gantt charts and burndown charts

Visualize your team’s progress and planning through Gantt charts and burndown charts for effective project management.

• Visualize work: Use these charts to view timelines and track sprint progress.
• Custom views: Filter and customize the charts to focus on relevant issues.

Advanced features and tips

Leveraging advanced features and tips can significantly enhance your Backlog experience and efficiency:

• Automation: Automating routine tasks and integrating with other tools can save time and reduce manual errors.

• • Third-Party Integrations: Connect Backlog with other tools (e.g., Zapier) for automated workflows.
• Advanced search: Utilize advanced search capabilities to quickly locate specific issues and improve the management of your bug database.

• • Search operators: Use advanced operators and filters for precise searches.

• Git integration: Managing git branches and pull requests within Backlog keeps your code and bug-tracking synchronized.

• • Branches and pull requests: Manage these directly within Backlog.
  • Automatic updates: Link commits and merges to issues for automated status updates.
• Open API: Utilizing Backlog’s API can help build custom integrations or extend functionality to meet specific needs.

• • Custom integrations: Build integrations using the API.
  • Automation scripts: Write scripts to automate bulk operations like issue creation or updates.

How to get bug-tracking right

While bug-tracking isn’t always the most exhilarating work a software developer will do, it’s necessary for delivering a quality product. As your product becomes more powerful and sophisticated, your backlog of bugs can grow quite large, and organization becomes increasingly important.

Best practices for tracking and fixing bugs

When tracking and fixing bugs, make sure you follow these best practices.

Be comprehensive

Failing to dot your i’s and cross your t’s might seem harmless for a while. But after a few months of poorly managed bug fixes, subpar work has a way of catching up with your whole team.

When you’re reporting a bug, it’s important to be thorough and follow any protocols set forth by your QA team or team lead. One of the biggest productivity killers when working on bugs is trying to understand and recreate a poorly captured software issue.

For every bug, you need to be sure that it is:

• Valid: Is it actually a bug?
• Complete: Did you include an appropriate title, description, screenshots, etc., in your issue?
• Unique: Has this bug already been reported in another issue?
• Reproducible: What steps can you take to reproduce the problem?

Without this information, chances are your bug isn’t getting properly prioritized or fixed.

Think it through

The problem with rushing through testing is that you can overlook the importance of more subtle bugs. What might seem like a simple error can actually have profound effects on the user if they follow the steps to create it.

Say you realize that you can, in fact, enter an invalid date into your system. You can create your bug in Backlog and then decide to put it at a normal or even low priority because it’s not something that’s crashing the system or preventing any kind of functionality.

Depending on the kind of product you have, something as simple as an invalid birthdate can cause havoc across a user’s profile.

For example, if your product is used by hospitals, elements of patient profiles such as immunizations, recommendations for medicine dosages, and other treatment areas might start displaying incorrect information. While it may seem unlikely that a nurse or administrator will accidentally enter an invalid DOB, the effects of such an error could be dire. When thought through, this simple calendar error is actually a high priority.

Whenever you’re reporting an error, be sure you’re thinking through the worst-case scenario when judging the true impact of a problem.

Keep your eyes peeled

After you’ve meticulously captured and assessed the impact of a bug, you might feel like your job is done. It can be, but your team could be missing out on the types of useful observations one only makes when knee-deep in pesky bugs: opportunities for improvement.

When you’re working with a product closely, you’re bound to come across a variety of circumstances that even the creators haven’t perfectly imagined. If you realize that certain screens are repetitive in a given flow or that adding an input field could ultimately save the user time, say something!

Using issues in Backlog, you can add tasks, bugs, requests, or custom issue types that your team creates. Remember to be respectful when offering improvements, as someone put a lot of time and thought into creating the work that you’re discussing. However, don’t let the fear of hurt feelings stop you from speaking up. At the end of the day, everyone will be happier knowing the result of their work has been thoroughly vetted and works under as many circumstances as possible.

Common mistakes and how to avoid them

Effective bug-tracking requires avoiding some common pitfalls. Here’s how to do that:

• Overlooking proper documentation: Inadequate details when reporting bugs can lead to misunderstandings and delays in fixing issues.
  • Solution: Ensure comprehensive documentation, including reproduction steps, screenshots, and environments.
• Ignoring bug prioritization: Without proper prioritization, critical issues might get overlooked, causing greater problems later on.
  • Solution: Establish clear criteria for bug impact and priority to address critical issues first.
• Inefficient communication: Poor communication can lead to confusion and inefficiencies within the team.
  • Solution: Use commenting features and targeted notifications to keep communication clear and up-to-date.
• Not reviewing duplicate bugs: Duplicate bug reports waste resources and time which could be used to address unique issues.
  • Solution: Review existing bugs before reporting and use search functionalities to check for duplicates.
• Neglecting metrics and reporting: Failing to review and act upon metrics and reports can mean missing crucial insights for improvement.
  • Solution: Regularly review generated reports and use insights to refine workflows and address recurring issues.

Common bug-tracking workflows

Depending on the nature of the project and the team’s methodology, bug-tracking workflows can vary. Here are three common workflows and how they can be effective:

1. Basic workflow

This is a straightforward approach suitable for smaller teams or projects with less complexity.

• Bug reporting: A team member identifies and logs a bug.
• Triage: A lead reviews and prioritizes the bug.
• Assignment: The bug is assigned to a developer.
• Fixing: The developer fixes the bug and updates the status.
• Verification: QA verifies the fix and closes the bug.

2. Agile workflow

This one is ideal for teams that follow Agile methodologies, integrating bug fixes into sprints and daily standups.

• Sprint planning: Bugs are reviewed and added to the sprint backlog.
• Development: Bugs are addressed during the sprint alongside feature development.
• Daily standups: Progress on bugs is discussed daily.
• Sprint review: Bug fixes are reviewed at the end of the sprint.
• Retrospective: Analyze and discuss recurring bugs for future avoidance.

3. Continuous Integration/Continuous Deployment (CI/CD) workflow

This is a dynamic workflow that automates bug reporting and integrates bug-tracking into the deployment pipeline.

• Automated bug reporting: Bugs reported through automated testing tools.
• Integration: Bug-tracking tool integrates with version control and CI/CD systems.
• Branching: Developers create branches to fix bugs and submit pull requests.
• Continuous testing: Automated tests verify bug fixes.
• Deployment: Verified fixes are deployed, and the bug is marked resolved.

Community and support

Engaging with the community and utilizing support resources can greatly enhance your Backlog experience:

User community

Participating in the user community provides opportunities to learn from others, share knowledge, and get help.

• Forums: Join Backlog forums to ask questions, share tips, and learn from other users.
• Social Media: Connect with Backlog user groups on platforms like LinkedIn or Facebook.

Help and support resources

Using the available help and support resources ensures you can resolve issues quickly and get the most out of Backlog.

• Help Center: Access our official Help Center for comprehensive product information and guides.
• Video Tutorials: Watch step-by-step video tutorials on using Backlog features.
• Customer Support: Contact Backlog’s support team for personalized assistance.

Feedback and feature requests

Sharing your feedback and submitting feature requests through our contact form helps improve Backlog and ensures it meets your needs.

• Provide feedback: Share suggestions and feedback with the Backlog team.
• Feature requests: Submit feature requests to influence the development roadmap.

---

Backlog for bug-tracking

While some small teams may be able to get by on spreadsheets and free tools for a while, eventually, all development teams need to invest in a system that works long-term.

Backlog is more than a bug-tracking tool; it’s an all-in one project management solution. Backlog can help you build, improve, and maintain software, and it can integrate your big fixing issues right in with the rest of your team’s work.

Integrations with Nulab’s other cloud-based apps give Backlog the potential to be a collaborative ecosystem for your team. Cacoo, our cloud-based diagramming tool, makes it easy to create and use diagrams in your workflow. Diagram URLs automatically expand in Backlog issues, so your team can review them without leaving Backlog.

With affordable paid plans, Backlog can keep all of your projects organized. Our Premium plan offers unlimited users, unlimited projects, and 100GB of storage.

Plus, you get:

• Subversion/Git
• Subtasks
• Access Control
• Gantt Charts
• Burn-down Charts
• Custom fields

Try it out for yourself with our free 30-day trial. You can create projects, invite your team, and see if Backlog is the right tool for you. No credit card required. No risk involved.

We also offer a Free plan for those who don’t need our more advanced features but are still interested in joining the 6,000+ businesses and teams that depend on Backlog for their bug-tracking and project management needs.

This guide was originally published on December 12, 2017, and updated most recently on October 31, 2024.