logo logo

How to Report Bugs to Developers in a Believable Way

How to Report Bugs to Developers in a Believable Way

It happens often that when a tester reports a bug to a developer, the developer will dismiss the bug report quickly, without analyzing any information they receive from the tester. They will either say ‘they cannot reproduce the issue’ or not even try to. This is usually the case when a bug report does not have enough details or is unclear. Here are my tips on how to report bugs to developers in a believable way:

1️⃣ You should begin with gathering all the relevant information on the bug and reproducing it yourself a couple of times. This helps with clearly identifying the steps one needs to take in order to encounter the bug 🔎

In some cases, when the bug was initially encountered, a whole lot of steps were performed. Sometimes we encounter bugs when testing something unrelated. Some of the steps performed when we initially found the bug might not be required. Therefore, when you report bugs, identify the minimum set of steps that, when performed, will reveal them.

Of course, sometimes the bugs are randomly occurring, or at least they seem to be, since they appear when some rare environment conditions are met. Even in this case, it is good to write down the steps you took when initially reproducing the bug.

If the environmental conditions will again be the same as that initial moment when the bug appeared, having clear steps to perform will be very useful.

2️⃣ Make sure to provide correct and correctly ordered steps to the developers 👩‍🏫 The bug description should be so clear that anyone should be able to reproduce the bug following the steps you wrote. When writing them, consider doing it as if you are writing them for someone who has never seen and does not know your product.

3️⃣ The most important thing: always always always specify what is the expected behavior and what is the actual behavior. Sometimes the person fixing a bug is not the person who wrote the initial implementation, so they might not know what is bad about the behavior, or what it should look like.

Oh, and when specifying the actual behavior, don’t resume to “it doesn’t work” or “it fails”. Provide an exact description of what that means. People can interpret differently the “it doesn’t work” part.

4️⃣ Whenever the bug reproduces, even if it’s random, information on this behavior should be present in the application logs. Therefore, when creating the bug report, make sure to also add the corresponding details extracted from the logs.

If the application is logging information in different files, try to correlate the data in each of them 📂 The more information you can extract from the logs, the more clues the developer has on where the issue is coming from.

Sometimes, because the issue is random, the log can actually tell you if it ever occurred or not. But if you find that no information was logged anywhere, although it should have been, here is the time to improve the quality of your product, by asking for these missing details to be added to the logs.

5️⃣ Now, of course, visualizing things is the easiest way to understand them. Hence, you can take a screenshot of the behavior and attach it to the bug report. But don’t forget to highlight the area where the issue occurs. Otherwise, people can simply stare at a 2560×1440 image without knowing where exactly the issue is.

6️⃣ Make sure to provide any further information that can help to easily pinpoint the root cause or reproduce the issue. Such information might be: the credentials used for testing, the exact time when the issue occurred, the test environment where the issue reproduces, or even the location of the test and how to run it.

This way anyone reading the bug description could run themselves the same test and analyze the results 📊

7️⃣ And last but not least, communication is essential! If for some reason there is a lack of clarity regarding the steps to reproduce or the experienced behavior, make sure to talk to the developer.

In some cases, you could even spend time together doing a real-time debugging of the issues, where the developer runs the code either locally or connects to the server experiencing the issue. All while you are guiding them with relevant data and steps.

Together you can find the problem faster and easier, but don’t forget to create that bug report even so. You need to track the progress of fixing, and deploy the fix until it reaches production.


Since the quality of the product is the entire team’s responsibility, getting those bugs fixed is important for everyone. That’s why it’s important for developers to have all the information they need, and it’s the tester’s role to make sure the way they report them is as clear and explicit as possible. Leave out no important information for a great software 🙏

About the author

Corina Pip

Corina is a Test & Automation Lead, with focus on testing by means of Java, Selenium, TestNG, Spring, Maven, and other cool frameworks and tools. Previous endeavours from her 11+ years testing career include working on navigation devices, in the online gaming industry, in the aviation software and automotive industries.
Apart from work, Corina is a testing blogger (https://imalittletester.com/) and a GitHub contributor (https://github.com/iamalittletester).
She is the creator of a wait based library for Selenium testing (https://github.com/iamalittletester/thewaiter) and creator of “The Little Tester” comic series (https://imalittletester.com/category/comics/). She also tweets at @imalittletester.


2 1 comment
  • Gage Domhoff November 3, 2021, 7:19 pm

    Great write up! I definitely agree that photos are one of the most important aspects. It is usually what developers look at first. Sometimes even skipping the written part!

Leave a Reply