Skip to main content

In the dynamic world of software development, ensuring the quality and reliability of applications requires a well-structured testing process. This article delves into the critical components of effective testing, including bug tracking, workflow management, bug advocacy, and the creation of test matrices. By understanding and implementing these essential practices, testers can significantly contribute to the delivery of robust and user-friendly software. Whether you’re a seasoned tester or new to the field, this guide offers valuable insights into optimizing your testing strategies and responsibilities.

Bug Tracking

As a tester, staying organized is essential. Any level of disorganization can cause problems, especially as the project grows in size and complexity. It’s the tester’s duty to properly handle issues and track bugs that have been discovered. This can be done in various ways.

Methods of Bug Tracking

For smaller teams, a simple spreadsheet might be enough to track bugs. Bug tracking software could be too complex or expensive for their needs. However, larger or distributed teams might need more sophisticated bug tracking software. This software can offer features like easy queries, project grouping, and organized workflows in swim lanes. Agile teams can determine what works best for them. While verbal communication or spreadsheets can work, most teams will need some form of electronic assistance.

Evaluating Your Bug Tracking Method

Once a bug tracking method is chosen, it’s important to evaluate its effectiveness. Here are some questions to consider:

  • Naming Conventions: What is our naming convention? Issues need highly specific and descriptive names to quickly identify what’s going on.
  • Priority: What is the priority of the bug? Consider the severity of the bug, how many people it affects, potential financial loss, and the cost and time required to fix it. Discussions with stakeholders can help determine the priority.
  • Description: What is the matter? Clearly state what is failing in the description. Including screenshots or simulations can be critical for identifying whether an issue is within scope.
  • Reproduction Steps: How did you find the bug? Document the steps needed to reproduce the issue. Being able to recreate an issue consistently helps confirm its existence and prioritize it correctly. It also aids in tracing logs and identifying warnings and failures, which can reduce the time needed to fix the issue.
  • Location of the Bug: Where was the bug found? Software often runs on multiple platforms like desktop web, mobile web, and mobile native apps. It may behave differently across different browsers and devices. Including this information helps determine if an issue is unique to a specific device or client, aiding in better prioritization.

Workflow and Record-Keeping

Establish a workflow for assigning and delivering bugs through development and back to testing. Maintain a living record of how each issue was found, fixed, and deployed. This record serves multiple purposes, such as identifying when a feature is complete and providing additional information for audits.



Production teams consist of various roles, such as designers, developers, analysts, copy editors, and testers. Each role contributes specific expertise that, combined, helps complete a project. However, simply having the right roles on a team doesn’t guarantee a successful outcome. There must be a clear order of operations so that each contribution is received at the right time.

Structure of a Project

A project is divided into several components, collectively known as epics. Each epic contains a number of actions needed to build the product’s functionality, which are called stories. Stories are assigned to developers who create the basic structure to accommodate contributions from other team members, known as tasks. For example, a task might involve a copy editor providing text that must be approved before it can be included in a story. Thus, having approved copy is a prerequisite for publishing the story.

Importance of Conditions and Testing

Given the numerous components involved in building a product, understanding the conditions required to complete stories and tasks is crucial. These conditions define when components can be tested. Collaborating as a team to set clear expectations enhances the ability to deliver quality work. At this stage, testers engage with all components as they are completed by their respective owners.

Definitions of Ready and Done

The terms “Definition of Ready” and “Definition of Done” are essential for setting clear expectations. The Definition of Ready outlines what is needed to start developing, while the Definition of Done specifies what needs to be accomplished for a task or story to be considered complete. These rules help the team make informed decisions about task requirements and story handoff stages.

Establishing a Workflow

Once the team agrees on these definitions, they can establish a workflow—a consistent pattern of completing work. A common understanding of what each task and story entails makes the testing process much easier and more efficient.

Bug Advocacy

It’s one thing to find a bug in software; it’s another to ensure it gets fixed. Not all bugs are created equal, and their importance varies.

A Personal Experience

I recall an experience from when I was a young tester. I found a bug in newly-deployed code that was barely noticeable to users. Still, I knew it existed. I spent several days digging into the code and finally pinpointed the issue. I created a detailed ticket and submitted it, eagerly awaiting recognition for finding such a difficult bug. I was proud and advocated strongly for its correction, hoping my effort would be validated by someone fixing it.

The Reality of Bug Priority

However, the bug was never fixed. I learned an important lesson: the effort spent discovering a bug does not determine its priority. The impact of the bug on the business and product is what matters. This was a valuable lesson I only needed to learn once.

The Role of a Tester

Finding bugs is just one part of a tester’s job. Understanding a bug’s importance to the business is another crucial aspect. While the decision to fix a bug shouldn’t rest solely with the tester, it should be well-documented to assess its impact on the project. The bug should spark discussions about the quality standards to maintain.

Communicating Bug Impact

A tester’s responsibility is to find issues and help the team understand their impact. If a bug is likely to cause significant problems, it should be communicated clearly. The team should then decide whether to fix it based on the issue’s behavior and description. The tester’s role is to advocate for the bug’s progression through the workflow until it is resolved.

Understanding the business’s priority and ensuring the issue gets corrected is a key part of a tester’s job. This involves not just finding bugs but also advocating for their resolution based on their impact on the overall project.

Test Matrices

The secret to completing work quickly isn’t speed, but efficiency. As a tester, it’s crucial to develop the skill of planning tests to cover all areas of a product. To test a product thoroughly for an organization, you need to know what to test, where to test, and on which devices to test.

What to Test

When building an application, it’s essential to ask questions like, “What are we building? Why are we building this? And who are we building this for?” These questions help gather general information to create a test plan. A test plan is a guide that defines the scope of work for testing the application. It can be written or mind mapped and includes information to track all the product’s components. As each functionality is built, the tester can outline the requirements and plan the testing approach to ensure quality.

Where to Test

Once the test plan is established, the next step is to determine where the testing will take place. This involves understanding where users are using the product, not just what is being built. Tools like Google Analytics, Looker, or Fabric can help assess data such as the percentage of users on different browsers. Based on this information, testers can prioritize which browsers to test, focusing on those with the highest usage or business revenue.

Which Devices to Test

In addition to browsers, testers need to consider the devices on which the product is used, especially for design-heavy UIs. Different devices have various screen sizes and breakpoints, which can affect how the product is displayed. Knowing the most common devices helps build a realistic test plan that covers the highest percentage of usage. Operating systems are also a consideration, as they can introduce issues independently of the device.

Creating a Testing Matrix

Combining all this information creates a comprehensive list of testing requirements. To streamline the process, testers can set up a testing matrix, which identifies the most important combinations of browsers, clients, devices, and platforms. For example, if Safari is widely used across different devices, a tester can decide to test it on the device with the highest usage. Since Safari runs the same on both iPads and iPhones (with the same OS), it might be redundant to test on both. Using a testing matrix helps document the necessary tests, ensuring efficiency and reducing redundant testing.

Testing matrices are an efficient way to focus on the most important platforms, helping testers cover the product effectively without wasting time on unnecessary tests.


In software testing, understanding the nuances of bug tracking, workflow, bug advocacy, and test matrices is essential for ensuring quality and efficiency. Each aspect plays a critical role in the overall process, from identifying and prioritizing bugs to planning comprehensive tests that cover all necessary areas of a product. By mastering these skills, testers can not only find and report bugs but also advocate for their resolution based on business impact and use efficient strategies to cover the most important scenarios. 

Key Takeaways

Bug Tracking

  • Accurate Identification: The first step is to accurately identify and document bugs.
  • Prioritization: Not all bugs are equally important; prioritize based on impact and urgency.
  • Documentation: Clear and detailed documentation helps in understanding and resolving bugs efficiently.


  • Structured Approach: Follow a structured workflow to manage the testing process.
  • Collaboration: Effective communication and collaboration with the development team are crucial.
  • Iteration: Continuously iterate and refine your workflow to adapt to project needs.

Bug Advocacy

  • Understand Bug Impact: The importance of a bug is determined by its impact on the business, not just the effort to find it.
  • Communication: Clearly communicate the significance of bugs to the team.
  • Advocacy: Advocate for the resolution of critical bugs by highlighting their potential impact.

Test Matrices

  • Comprehensive Planning: Create a detailed test plan covering what, where, and on which devices to test.
  • Data-Driven Decisions: Use tools like Google Analytics to prioritize testing efforts based on user data.
  • Efficient Testing: Use testing matrices to avoid redundant tests and focus on the most important platforms and devices.

By integrating these principles into your testing strategy, you can enhance the quality assurance process, ensuring that software products meet high standards of reliability and user satisfaction.