6 most common reasons bugs are missed
Let’s face it: missing bugs is frustrating. It will be even safe to say a missed bug is the worst nightmare of any tester.
Why so? There is a myth and misconception that testers should hunt all bugs. Testers are viewed as goalkeepers who are the first to blame if there is any bug leakage to the production.
Yes, missing bugs is annoying. But there are reasons behind it. Let’s look at the most common ones and offer solutions that can help testers fix the situation and never let bugs appear in the final version for the same reason.
#1. The pesticide paradox: with the course of time test suites wear out
Almost 20 years ago Boris Beizer, American software engineer and author, formulated the Pesticide Paradox:
Plainly speaking, it means that when tests that are launched hundreds of time, they stop being effective. As a result, a number of bugs that are introduced into the system are not detected by existing tests get to end users.
What can be done?
Never assume that you can build an ultimate test suite that will detect all the bugs in all product versions. What you should do to ensure your tests are working well and perform successful testing is to keep track of the product changes, review and update your test suites regularly.
#2. Lack of time to test that area
It’s not a rare case when software testing team gets under time pressure and has to opt either to burn the midnight oil working overtime, or skip some tests. Even if you are diligent enough to select the first option, you will certainly be in a hurry. And it’s quite natural: when people are in a hurry, they overlook things and miss the bugs, even the most obvious ones.
What can be done?
If the deadline is fixed, communicate with your manager to decrease the scope of testing and analyze risks. Prioritizing testing is also a great plan here as you can suggest skipping low-risks area and focus on the business critical functionality. Tell your manager or any stakeholders what you can test, and what you don’t have time to. Also, inform on the risks entailed.
Be transparent and never hide the issue from the customer hoping that the bugs won’t reach end users.
#3. Missing the most obvious bugs
You can’t even imagine how often the bugs that seem to be right in front of your eyes are missed! And they are the most annoying ones. Testers miss them because they get accustomed to them while looking at the app under testing. It may also happen when a tester is too focused on another task and switch off the “bug hunting mode”.
What can be done?
Practice multi-tasking and attention to details. Try to put yourself in the end user’s shoes and click the application from scratch.
#4. Requirements documentation is improper
At times, the root cause of the missed can be found on the earliest stages of testing projects, when testing itself hasn’t started yet. And it’s about poor requirements documentation. If the documentation doesn’t cover all usage scenarios, testers will not cover these scenarios when testing.
It’s very important that both requirement documentation and test cases prepared should be complete and clear, covering all functions and user scenarios. From our experience, we’ll say for sure that it’s less costly to prepare comprehensive documentation than fixing a bug on late stage of the development.
What can be done?
While establishing proper communication with the customer and asking proper requirements documentation is the responsibility by test managers or business analysts (depending on your organization workflow), there is something you can also do to avoid miscommunication errors. Make sure you know the expected system behavior before getting down to testing. Once the requirements change, make sure you’ve reviewed and updated your test suites as well.
#5. The bug was discovered and reported, but it was too costly to be fixed
Testers are responsible for providing developers and stakeholders with relevant information on the system quality. However, it’s not their responsibility to decide on the developers’ work or product’s release.
Actually, there are many factors to decide on going live (much more than bugs presence). And at times it makes sense to ship the product even with minor bugs in it.
What can be done?
Report all the bugs to the developers in a clear and timely manner. Before the release, provide the stakeholders with the most comprehensive feedback you can on the system functionality, performance, usability and security.
#6. This area is intentionally left blank
It’s up to you to fill it: add any other reason for missing bugs.
Welcome to the comments!
