Quite often software testers get the blame for bugs that get leaked to production and management think that the testers have done a poor job. Testing should not be only the responsibility of testers, rather it should be embraced by all people involved in development, developers, UX and Product Owners.
Software development is one of the most complicated tasks an individual or group of people can undertake. In the software development cycle, testing is usually at the end just before implementation or shipping of the end product to the market. During development, there are bugs which may be present in the software compromising the security of end users. As a result, testers have had to face tough decisions when it comes to post-ship bugs. What are post-ship bugs? This refers to bugs that escaped testing and now are visible to live customers. Normally, a blame game begins with testers on the front line.
In a software development company, there are instances where people responsible for testing, have been summoned by management in regards to a bug which has leaked to production. The one question management often ask is how the bug escaped even when the people responsible are skilled and experienced. Every tester dreads this moment especially when a single look from management says it all – rage and anger.
It is common for the team – programmers, testers, analysts and management – to celebrate once they have shipped the end product to customers. Every team member is finally able to breathe with ease and anticipates the future where they will create new and exciting projects. But often what many testers fear is that in the case of any severe bugs experienced by live customers following a production release, fingers will be pointed at them and the accusation is simple – negligence. The main question remains, whose fault is it?
Who is to blame?
While testers are tasked with the job of testing and debugging, they cannot be a safety net to catch all bugs present in the application. The truth is there is no way to catch all bugs in software which means the end product will ship out with bugs. It is the responsibility of the testers to catch the important bugs by using a risk-based approach. Regardless of this, a few bugs will sneak past the development team into the end user’s hands.
It is important to note that not all blame can be placed on the development team especially when it comes to bugs. Developers are humans just like testers, so they are bound to make mistakes.
Part of the blame may be placed on analysts or program managers who developed ambiguous requirements but this will fail too. This is attributed to the human factor and that bugs occur in different forms. The responsibility for bugs can be placed on everyone. Yes, bugs will exist as a result of a mistake but pinning the blame on an individual or group of people is not fair. So, a bug found its way into the customer’s end product and now everyone is angry especially the C-level management. The only logical route is to seek measures to resolve the problem.
This is where every member of the team takes the blame for the bugs and with that in mind, focus should be emphasized on what went wrong and appropriate measures developed to resolve the problem. It is important for the execs to acknowledge that the team did their best and an agreement was made before shipping was done. The experience should be a lesson and not an opportunity to create a blame game. It is important to note that there may be a reason why the bug(s) was not discovered and now that it has been discovered; it’s time to learn and prevent future incidents.
How to eliminate blame
One important question everyone needs to ask is how to eliminate blame? For starters, it is wise to eliminate the safety net feature. This does not mean you stop testing the software before you ship it out but you can make progress by communicating and explaining what is happening during testing. This means everyone involved should do the same – from programmers to analysts. If you want to shift the culture of blame to one of shared ownership, it is wise to incorporate transparency and shared goals. Once everyone on the team learns of their responsibility, the blame game will cease.
To achieve high quality, collaboration and sharing are needed. Bugs may occur in areas where testers don’t test fully which may be done on purpose or not. Failing to communicate your strategy and approach results in bugs in the final product.
Learning from mistakes
As a professional, developing software allows the team to learn from each other, from the customer and from mistakes done. Playing the blame game when mistakes occur after shipping of the end product will not resolve the problem(s). But moving past it and entering the world of knowledge and working together will improve the testing quality. It is of utmost importance to remember this always. But hey, you are a tester at the end of the day…why didn’t you find that damn bug? 🙂