Bug Tracking: A Go-to Guide

As noted above, bugs are unavoidable. Your best bet to ensure that your solution works as intended and keeps customers happy is to proactively track and resolve bugs. But what exactly is bug tracking? Below we answer this question and give several other FAQs related to the process.

5 FAQs about bug tracking

1. What is bug tracking?

Bug tracking, also called defect tracking, is the process of identifying, reporting, and following software bugs — errors or flaws that produce an undesired result — from the initial encounter to an acceptable conclusion, typically a fix. The purpose of bug tracking is to ensure the solution behaves as intended.

Bugs can be identified by a number of relevant parties, including product owners, end users, testers, QA analysts, and developers. The bug tracking process persists as long as the software solution is supported.

2. What’s the difference between a bug and a defect?

The terms bug and defect are typically used interchangeably, and they often refer to the same concept. However, Steven McLintock, full-stack software developer at Kilt & Code, notes that the terms do have distinct meanings to developers.

“A bug occurs when a piece of code results in the application crashing or otherwise causes a negative result,” he says. “A defect occurs when the software’s behavior or performance does not adhere to acceptance criteria.”

3. Why is it important to create and manage a bug tracking workflow?

Regardless of the project management methodology your development team uses to build software, bug tracking ensures that issues within the application are reported, resolved, and retested in a systematic manner. “This includes prioritizing bugs appropriately, and documenting them in a bug tracking system,” McLintock says.

By following a formal bug tracking process, development teams can ensure all bugs — even if not fixed immediately — are identified. Appropriate personnel can then assign priority and severity levels, and deal with the bugs accordingly. Without a bug tracking system, bugs are bound to be forgotten or lost in the daily shuffle.

4. Why is bug tracking important to development teams?

The bug tracking process typically produces a fix. This eliminates the issue, meaning end users can use the software as intended.

However, if bugs aren’t properly identified and tracked, they will persist, and end users will be forced to deal with the issue or figure out workarounds. In a worst-case scenario, end users could abandon the product altogether and seek out an alternative solution.

5. What is the bug life cycle?

Bug tracking follows a bug through its life cycle, which generally consists of nine distinct states.

“Product owners and/or QA analysts usually report the bug formally and log it into the project management or bug tracking system,” says McLintock. They then assign the bug to a developer based on the bug severity level and the developer’s availability and corresponding skill set.

The developer compares the current incorrect behavior to the expected behavior and works to resolve the discrepancy. After the developer comes up with a fix, the bug is reassigned to a tester or QA analyst to verify that it has been resolved. Only then is the issue considered closed and the fix introduced into the production environment of the software.

Now that you have a foundational understanding of bug tracking, let’s move on to collecting bug reports.

The issue-tracking process starts once a bug is identified and reported, whether by an end user or a member of the development team. Your first instinct may be to create a single reporting system for all bugs, but different types of software issues may actually warrant different methods of reporting.

Jon Quigley, principal of Value Transformation and a software development expert with more than 30 years of experience in the industry, says having a variety of reporting options helps streamline bug and defect movement through the bug tracking process.

You may have different departments that deal with specific issues. “For example, in the automotive industry, you typically have teams that deal with software, hardware, electrical, mechanical, and so on,” he says. “You need a variety of reporting options to assist with sending those issues to the right team.”

Below are several use cases and the specific types of bug reporting forms that would be most helpful for each.

Use cases and bug reporting forms 

Technical support requests

First, you need a way for end users to request technical support for time-sensitive or pressing issues. For example, an end user may need to pay their bill for your subscription-based product, but may be unable to because the billing portal isn’t working. To avoid losing access to the service, the end user needs timely technical support. Designating a specific form to deal with these issues will help you resolve them more quickly.

You can use a technical support request form like this one from JotForm. It includes contact information for the user, the urgency level of the request, and a place for the user to describe their problem. You can also customize the form to include additional fields relevant to your product.

Product defect reports

Quigley says product defects in the automotive world tend to be identified internally through different testing methods:

• Specification testing takes a defined set of requirements and runs tests to verify that those requirements are met. For example, does a dashboard light come on under certain conditions?
• Exploratory testing tries to identify defects by going outside prescribed specifications using different conditions. For instance, what happens when different communication traffic is sent to the system at the same time, or the traffic is sent in a different order?
• Stress testing takes the product beyond the limits of the specification. For example, how does the product perform when voltage is two times the prescribed amount?

Software in different industries requires similar approaches to ensure the product is fully functional for the end user. Whatever approach your development team uses, you can ensure your team is in the know about product shortcomings with a defect report form.

General bug reporting

Software users or testers also need a way to report bugs. For example, your software may have the capability to show users’ past bills. If this functionality doesn’t work, users can complete a bug reporting form like this Jotform Bug Tracker to alert your team about the issue and convey all the relevant details, such as contact information, the type of bug, bug priority (which your team may adjust), contextual aspects like browser and operating system, a description of the bug, and a screenshot of the error.

The final chapter of this guide walks through the next logical step after bug reporting — creating a sheet to keep track of reported bugs.

Once bugs have been reported to your team, it’s important you have a method for tracking them. A bug tracking sheet is a great tool for bug management because you can ensure your team knows about existing bugs and their resolution progress.

“By far, the simplest way to keep track of bugs is in a spreadsheet accessible to the entire team,” says Cristina Escalante, COO of The SilverLogic. A bug tracking spreadsheet, or table, allows the entire team to easily view and update the list of bugs, associated tasks, their status, and their priority. You can color-code this sheet to make the information easier to visualize, display it on a shared screen as a team dashboard, or use it to generate a chart that enables the high-level analysis needed for decision-making.

Below are the added benefits of a bug tracking sheet, and why your team should use one.

How a bug tracking sheet benefits your development team

1. It improves team productivity and product functionality

If your team commits to using the bug tracking sheet — either everyone contributes to it directly or a designated team member is in charge of the sheet — Escalante says your team can improve both productivity and product performance by

• Spending less time investigating the same bug multiple times. If someone finds a bug, they can check the sheet to see if someone has already reported it or has started working on it. This prevents two people from working on the same bug at the same time.
  
• Spending less time figuring out workarounds. Instead of wasting time figuring out how to work around an existing, low-priority bug, team members can leave notes about accepted and unaccepted workarounds until the bug is resolved.
• Identifying gaps in documentation and user experience. If team members frequently report bugs for a particular feature or workflow, this may be a sign the feature is confusing, better documentation is needed, or there are deeper issues with the product. The team can then plan ways to remedy these issues in future releases. This is where a summary report would come in handy for wider analysis of the product.

2. It helps identify bug severity

A detailed bug tracking sheet that includes descriptions, environments, attachments, and so on goes a long way in determining bug severity levels. 

For example, consider the environmental element. Assume you have a solution users access from their browser, and your users come from Internet Explorer (10 percent), Safari (40 percent), and Chrome (50 percent). All else being equal, a bug that impacts only Internet Explorer will likely be considered less severe than one that affects Safari or Chrome users. 

The ability to customize columns within your sheet or table allows you to more easily organize descriptions, attachments, and environments and can lead to better management of information. 

3. It assists in prioritizing bug fixes

Since a solid bug tracking sheet requires detailed information, your team can take a data-driven approach to determine bug priority levels. Not only can they use what they know about the bug in question, but they can also refer to information about other queued bugs to set relative bug priority. 

Escalante says one of the biggest strengths of bug tracking spreadsheets is that users can quickly assign values to rows and sort the data according to that value. “There are many strategies stakeholders can use to prioritize bugs,” she says. “For example, you can assign levels with phrasing such as low, medium, high, and critical. You could also use a numbering scheme. Either way is easy to implement with a spreadsheet.” 

In this “no-code” era, your team can leverage advanced tables by using formulas to automatically calculate totals, combine text and numeric entries, and more. 

4. It enables progress monitoring

Escalante notes that, as long as your team commits to revisiting the bug tracking sheet during a daily or weekly meeting and updating the status of each open bug, this tool can easily serve a dual purpose as both a to-do list and a metric of bug resolution progress. 

In addition, using Jotform Tables, you can roll up the data into a polished report on trends/progress and share that report with leadership on a monthly basis, or even present it annually to customers to demonstrate the organization’s efficiency. 

These benefits show why creating a bug tracking sheet is the way to go for your development team. Jotform has a bug tracking form to help you get started. Customize it to fit your needs, adding whatever fields you require.

Meet your bug tracking guides

Cristina Escalante

Cristina Escalante is COO of The SilverLogic, a custom software company in Boca Raton, Florida. Although The SilverLogic has been a Jira customer since 2012, its team continues to use bug tracking spreadsheets to easily communicate with internal and external stakeholders about the status of their work and to quickly prioritize items for discussion.

Jon Quigley

Jon Quigley is a principal of Value Transformation and a software development expert with more than 30 years of experience in the industry. He’s been developing software for industrial and automotive applications since 1990, serving in development, testing, and managerial roles. He also teaches software certification testing.

Steven McLintock

Steven McLintock is a full-stack software developer at Kilt & Code. He specializes in Microsoft languages and platforms such as .NET, C#, and Azure, and has been working as a developer since 2006.