An ounce of prevention is worth a pound of cure, and bug and issue tracking is your last line of defense before the cost of finding and fixing bugs skyrockets. If you’re creating software, good testing is just good business. It can help cut customers, create happier customers, and let your developers stay focused on improving software rather than putting out fires.

Let’s dive in and look at some of the benefits of software testing…

  1. Happier Customers Bug-free software isn’t just nice-to-have. It’s expected. If bugs distract or inconvenience your customers, they’ll move on. Even basic testing can reduce the number of bugs that slips through and have a measurable impact on customer satisfaction.
  2. Lower Support Costs With fewer bugs in production, your support team can spend more time helping customers fall in love with your software instead of coordinating fixes with developers and customers to track down, reproduce, and fix bugs.
  3. Lower Cost of Fixing The best time for a developer to fix a bug is when the code is fresh on their mind. The later in the process a bug is discovered, the less likely that it’s fresh on the their mind and the longer it will take them to fix it. It’s kind of like burning money.
  4. Fewer New Bugs Developers are more likely to introduce new bugs while fixing an existing bug than when they originally wrote the code. Finding and fixing bugs during development is not only cheaper, but also less error-prone because the code is fresh on developers’ minds.
  5. Less Time Spent Fighting Fires Fixing buggy code that is actively affecting customers creates unnecessary time pressure to fix the bug quickly. That often leads to incomplete or even incorrect solutions because developers didn’t have enough time to really think through the problem.

It’s cheaper and faster to do it right the first time, and even the simplest testing processes can generate great results. With software, quality is effectively free. By making a small up front investment, you cut costs, save time, and increase customer happiness. Who wouldn’t want that?

Despite the benefits, testing is still one of the most popular places to cut corners for budget or scheduling purposes. However, removing time or budget for testing—and fixing—only shifts the effort to after it’s released. Unfortunately, after bugs make it into production they’re more expensive and time consuming to fix. Let’s take a look at some of the most common rationalizations for cutting back on testing…

  1. “Our developers test their own code as they write it.” That’s great, and they should. But that’s not enough. Writing code and actively testing it require two different mindsets, and it’s very difficult for a developer to catch bugs in their own code. Moreover, if the bug is the result of a misunderstanding by the developer, they won’t even see it is a bug. A good manual testing process ensures that you have a second set of eyes on everything.
  2. “We don’t need manual testing because we use automated testing.” Automated testing is also great, but it isn’t a cure all. First and foremost, automated testing relies on developers testing their own code and has all of the associated problems. It’s also just as possible that the automated tests will include bugs themselves. Most importantly, there are many aspects of software testing that simply can’t or shouldn’t be be automated because they’re subjective and need a human to look at them.
  3. “We don’t have time/budget for a testing phase.” It’s not the testing that’s important. It’s the fixing. Testing only helps you discover the bugs. Would you say you don’t have time or budget to fix bugs? Probably not. They say ignorance is bliss, but in this case it’s just downright expensive. Those bugs are there regardless. The only difference is that fixing them after you ship is going to be much more expensive. Cutting back on testing may look nice on the surface, but it’s only kicking the can down the road. The ghosts of the undiscovered bugs will inevitably return to haunt you.
  4. “We don’t have the budget for testers.” Having dedicated and experienced testers is great. In an ideal world, you’d have hem, but if the alternative is no testing at all, you can get by without dedicated testers. Even a half day with your team dedicated to testing and fixing can make a world of difference. If everyone on your team, both developers and non-technical team members, tests for an hour or two each week, the results will surprise you.
  5. “We don’t have the experience to run a proper testing phase.” It’s easy. We promise. You can start simple and then slowly expand and improve your process as you start to see the benefits. We’ve even put together a guide for starting your own quality assurance process.

Fortunately, there are degrees of testing. You can gain a lot of the benefit with just a little testing. Then, as you start to see the benefits, you can improve your process. Don’t worry about starting out with a fully-developed quality assurance process. Start by setting aside a half day for testing and fixing each week, and you’ll quickly see the returns on your investment. Then, when you’re ready, you can work on perfecting your testing strategy as your team grows.

Related articles… Never miss new articles…

Receive our blog posts in a consolidated monthly email. Don't worry, we hate spam too and make it easy to unsubscribe.

Alternatively, you can subscribe to our blog feed or follow us on Twitter at @sifterapp.