Understanding Bug Advocacy – An Instagram Live with Rahul Pawal

When it comes to software testing, bug reports are a highly visible outcome that everyone can see. Testers file bug reports daily, whether they come from customers or from analyzing issues through automation scripts or exploratory testing. The problem, however, is that simply reporting bugs isn’t enough, especially if they sit in a database without being addressed. In such cases, the time and effort spent on identifying these bugs don’t translate into any value.

Having someone who can act as a bug advocate ensures that these bugs get the attention they deserve. It would involve bringing the bug to light and presenting it honestly. Since testing is a social process, it can be challenging to get people to pay attention to these bugs. Especially if they have biases or preconceived notions. 

It’s not enough to simply provide a report. The report needs to be structured in a way that inspires advocacy and motivates people to put the necessary time into analyzing, prioritizing, and fixing them. These reports should put effort to address the bugs. 

This is especially important since time and effort ultimately translate into money. Therefore, it is essential to advocate for the bugs. Doing this would ensure that they’re given the proper attention they deserve.

The process of bug advocacy involves several key steps that must be followed to ensure that bugs are properly addressed. First, testers must check whether the issue is reproducible and consistent. After that, they must investigate the issue to determine its nature and severity. This involves analyzing the problem and distinguishing between generic and specific issues. 

Once the problem has been identified, testers must consider the impact it may have on different personas. It should also assess the risks associated with the issue. This includes determining whether the issue will likely cause customers to report problems or even leave the platform altogether. The information gathered during this process must be carefully documented and presented to stakeholders clearly and concisely. 

In some cases, bug advocacy may be straightforward. Such as in cases where there is a crash or other obvious issue that can be easily demonstrated. However, in other cases, the process may be more nuanced and require additional investigation and analysis.

The importance of selling skills for testers is a subject of debate. Some individuals may perceive selling as a negative aspect or unrelated to testing. But in reality, it is one of the crucial skills for any engineer. This is because the ultimate goal of the products that are being tested is to be sold in the market. Therefore, understanding sales skills and knowing how to advocate for issues that can hinder sales is essential to testing. 

When testers report a bug, they are essentially selling the importance of their case to the person who spends time investigating and addressing it. Effective selling skills can help in negotiating and convincing stakeholders to allocate time and resources to fix the issue. The testers often face time constraints and challenges in selling the importance of the bug. But with effective negotiation and selling skills, they can overcome these hurdles.

When advocating for bugs, the bug-tracking system users can have an impact on a tester’s ability to do so effectively. However, it is important to note that advocacy is independent of the bug-tracking system, as it involves investigation. A good bug-tracking system is important because it helps in finding previously reported bugs. It should also support customization such as adding fields for hardware, OS, or affected parties.

Popular bug-tracking systems like Jira and Polarian support customizations. They also have fields that allow developers to select resolutions when closing issues. While Polarian has a challenging user experience, Jira allows users to directly paste images and videos. This makes Jira an excellent choice for testers. 

Overall, the effectiveness of a bug-tracking system depends on its ability to support customization, search, and resolution selection.

Suppose, a bug is reported by someone other than the tester. For example, a customer or a team from another department. Here, the first step is to investigate the issue and gather as much information as possible. Note that, the initial report may not provide all the necessary details. Once the tester has a better understanding of the issue, they can create a test system to reproduce the bug. Later they can pass it on to the team responsible for addressing the issue.

In testing, there are workflows in which bugs are reported to a PP0 support team or directly to developers. In case the original bug reporter is unavailable, the question of who should advocate for the bug can be unclear. As project management plays a significant role in software development, it may also play a part in determining who takes bug advocacy responsibility.

The skills required for effective bug advocacy in this scenario include the ability to investigate and analyze the issue. One should also communicate clearly with the reporting party, and work collaboratively with the development team. It ensures the bug is properly addressed.

Professional testers differentiate themselves from amateur testers. They actively seek out information and investigate bugs like a detective, rather than just working with the information that they have. They research competitors, guidelines, customers, personas, and feedback from sales and marketing teams. Furthermore, they may also conduct user interviews to gain insight into user expectations.

Persuasion is another critical skill for advocating bugs. One can learn from James Bach that when someone starts doing credible work, it typically takes time to build credibility. It may take one year to one and a half years to build credibility in any organization. Because your previous work adds to your credibility and persuasion more. So, it takes time to build credibility, but once established, a tester’s voice can influence decision-making. In critical cases, a good advocate may seek the opinions of people of influence outside the product requirements. This helps to build support for a particular issue.

Pairing with developers is another way to advocate for bugs. However, this approach has a double-edged sword. As it may lead to finding common ground with the developer or further complicating the issue.

When advocating for intermittent bugs, there are several useful tips to keep in mind. 

First, it’s important to explicitly mark the issue as intermittent or non-reproducible when it is raised. So that the assigned person knows that an investigation is needed. 

Second, providing more test observations can be helpful, including notes on what you plan to do in upcoming test cycles. This can lead to the developer discovering the issue during their unit tests.

Third, it’s worth checking the bug tracking system to see if similar issues have been reported before. Creating a label for inconsistent issues can help with this. Sometimes, a history of similar bugs can provide valuable context for resolving the current issue. 

Fourth, reporting the exact error code or log traces can be helpful in identifying the root cause of the issue. It’s important to look beyond the surface-level pop-up messages to uncover underlying information.

Fifth, it’s important to keep in mind that every bug can be reproduced if you find the trigger point. Sometimes this trigger point is straightforward, but other times it may be more elusive.

For example, in one case, a bug only appeared when the CPU load was high. And the CPU load used to go high when the camera was turned off. Despite efforts to investigate, the root cause of the bug remained unclear. This led to confusion as to why it occurred in certain places or during particular times.

After further investigation, it was discovered that the bug was caused by memory issues. This highlights the importance of identifying trigger points and thoroughly investigating all possible causes when encountering bugs.

When there’s a timeline crunch, testers often have to strike a balance between doing more testing and researching an issue. The amount of investigation done before logging an issue is always a trade-off. If too much time is spent researching a single issue, other important tests might be missed.

To determine whether an issue is a blocker, an impact analysis can be done to identify potential problems. If the issue is minor, it can be raised as a minor with observations and moved forward. For e.g. – basic UI issues.

Testers often rely on their experience and intuition to identify problematic issues. In such cases, testers may need to research the issue. It can be done by changing configurations, performing follow-up work, and raising the issue.

Test notes can be used to document any additional testing that needs to be done later. Making well-calculated judgments is essential to strike the right balance between testing and research.

The significance of testability and observability in identifying, recording, and advocating a bug is often overlooked. Although some may believe that testability only concerns automation IDs or ex-pats, it goes beyond that. Testability is an essential skill for testers that can make testing easier and better. However, this may not be obvious to stakeholders who are not directly involved in the testing process.

In testing, having testability means having access to tools and resources that make it easier to investigate and find bugs. For instance, having access to the database enables testers to quickly create their test data. Having access to code and unit tests done by developers can provide testers with various ideas. For example – testers will know what kinds of things they should test. Additionally, having tools like Postman can help testers quickly find data and trigger requests, making their testing more efficient.

Observability, on the other hand, allows testers to observe what is happening in the software and monitor it for issues. By having visibility into the system, testers can identify potential bugs and advocate for their resolution. Overall, having good testability and observability is essential for effective software testing and bug reporting.

In terms of being an effective bug report writer, three main things are important – 
1. Investigation skills – This will help identify the bug’s root cause and provide a clear understanding of what needs to be fixed.
2. Testing skills –  this will allow the writer to apply different strategies, and check for boundaries and configurations. It overall ensures that the bug report is thorough and accurate.
3. Ability to use tools – Tools can offer assistance in various aspects, and some of them can even expedite the bug report writing process. Commonly used tools are designed to detect and correct grammatical errors, rephrase sentences for clarity, and accurately translate values. This can significantly enhance the quality of a bug report.

Following are the initial skills required to move from manual testing to automated testing–
1. Learning the basics of any programming language to perform automation scripting.
2. Looking for tools that can automate different aspects of testing beyond just automation of scripts. For example, tools like the “Magical” browser extension can help fill templates of bug reports.
3. Finding a good learning source such as Test Automation University.
4. Finding a learning partner, buddy, mentor, or guide and being consistent in learning.

An example situation would be when a bug has already been reported, and it’s currently open and expected to be fixed in the next release. If a similar issue is brought up by the marketing team, stating that a customer is experiencing the same problem, it can be beneficial for advocating the bug fix.

Linking the customer complaint query to the existing bug report strengthens the case. It also emphasizes that multiple individuals are affected by the issue, making it easier to advocate for a timely resolution.