QASymphony / Blog / 3 serious (but common) misconceptions about software testing
3 serious (but common) misconceptions about software testing
One of the most important aspects of software development – software testing – is often misunderstood. Software testing has been around since the mid 1900’s and it has had a lot of time to accumulate plenty of misconceptions and myths about how it works. Some of these myths make sense, but they’re the kind of misconceptions that, if software testers believe them, can really impact the quality of software testing and the amount of time spent on them.
And everyone wants to know the truth, so this blog post will cover all of the common myths and misconceptions that plague the software testing world, and debunk them once and for all.
#1 Testing is a Cost Center
This is probably the single most common misunderstanding regarding software testing, shared by executives across all sectors. In their minds, testing is and always will be a cost center. As a result, their primary goal is to keep these costs down as much as possible.
“Software testing can deliver significant financial benefits – directly and indirectly.”
Why is this a mistake? Because software quality assurance and testing can actually deliver significant financial benefits, both directly and indirectly.
This is most obvious when you consider the costs of fixing software defects. You’ll end up paying four or even five times more when addressing a software bug after product release than you would if you’d caught that same software bug during the design stage, according to the Systems Sciences Institute at IBM. And the higher quality the enterprise software testing tools a company utilizes, the better the chances that the business will find bugs earlier, rather than later.
It’s also important to take into account the potential damage a software defect can cause. As our earlier blog highlighted, software failures can seriously tarnish a company’s reputation, leading directly to decreased stock prices and diminished customer loyalty.
With that in mind, software testing isn’t a cost center – it’s a way to save the company tremendous amounts of money!
#2 Legacy Tools are Good Enough
Another major, common misconception in this area is that legacy tools can do the job when it comes to software testing. Most significantly, a lot of businesses have moved away from the waterfall methodology, and yet, they have not embraced agile software testing tools.
That’s a problem. Waterfall-based software testing solutions will not be able to integrate with agile testing tools, such as JIRA and Selenium. What’s more, such legacy software will not be designed with agile workflows in mind, which will create complications and inefficiencies among your software testing teams, hurting productivity.
Similarly, a lot of organizations continue to rely on spreadsheets for their test case management needs. The issue here is that enterprise test management is a complex endeavor. If you’re depending on spreadsheets, documentation is going to become overwhelming, and it’ll be very difficult for your testing team to find the data it needs when it needs it.
This is a surprisingly widespread belief – and one which software testers themselves naturally aren’t too fond of. As agile has taken root, many software development leaders have come to embrace the notion that everyone’s a tester, which therefore suggests that the job of the dedicated tester has become less critical and less demanding.
That’s hardly the case, though. As we covered in this blog, the best agile software testers will still play key roles, but those efforts will certainly prove challenging. For example, software testing is no longer limited to running through rote processes – testers are expected to exercise value judgments and offer guidance and recommendations regarding the bigger picture.
Additionally, new software testing tools and strategies are emerging on the market, and testers need to learn about and adapt to make use of these new solutions. Company leaders must recognize these inherent challenges and do their part to support testers as they take on greater responsibilities and play a bigger role in software development efforts writ large.