Measure Twice Cut Once: The Secret to High Quality Software Development
Summarize With:
You've undoubtedly heard the old proverb: 'An ounce of prevention is worth a pound of cure.' It's true.
Nowhere is this time-tested axiom more true than in the context of software development. It's a simple concept to understand. Do it right the first time and you'll end up saving a lot of money in the long-run not having to fix mistakes.
But mistakes in any endeavor are, practically-speaking, inevitable. There is no perfect process of creating something new and not having to refine and polish that thing before it is finished. And the cost of fixing mistakes are exponentially relative to how early in the process the mistake is identified and rectified.
Picture a carpenter building a house. If a carpenter cuts a board too long and it doesn't fit where it needs to go, they have to cut the board again to the right length, and that wastes the carpenter's time, who most likely gets paid by the hour. If a board is cut too short, and perhaps is in a load-bearing wall, where such a mistake could lead to improper load support, warps or squeaks in the structure above, those problems are more serious.
Assuming the short-board mistake is found right away, the carpenter must cut a new board, wasting both their time and needing to use more wood material. If the mistake isn't detected until later, walls may need to be torn out, or ceilings, or upper floorings to fix the issue — obviously even more expensive to do.
The same idea applies in the software world.
This chart should look familiar, for it is based on a great deal of research and analysis. Finding mistakes when you are still at the idea stage, may just be a matter of updating a plan. Bugs in initial code, may be found during programmer unit testing. Other defects might not show up until a Quality Assurance tester runs tests in the integration and operational test phase. Most people understand that process. What isn't commonly understood is that the later in the software development lifecycle that a bug is found, the more expensive it is to eliminate.
Some bugs are the result of bad logic in the earlier coding stage (not just fixing typos), and once such an error is discovered, then more than just the bug itself may be affected, and other portions of the code might have to be revised to account for the defect. Again, more expensive.
The worst case example, unfortunately (and an industry dirty little secret) is that a lot of software shops, mostly in-house organizations, don't tend to place a sufficient priority on Quality Assurance testing during the development process. Beyond basic unit testing, the thinking is along the lines of, 'We'll just put the code into production to meet our deadlines and then let the users find the bugs, report them, and then we'll assign a severity level, and eventually fix them.'
The logic of this mentality is one of: That's cheaper than hiring full-time QA technicians. But is it really cheaper? Besides direct costs of debugging your software, what's your company's reputation worth if you are known to your users for releasing bad code?
According to the chart above, finding and fixing bugs post-release can be thirty-times, or more, more expensive than finding and eliminating those mistakes much earlier in the process. And yet, so many organizations are often ready to roll the dice and take on the risk of fixing bugs after-the-fact than being proactive in the process. And the rationale for doing so is that QA personnel are just too expensive.
It may come as a surprise to many software development leaders, but this line of thinking is a false choice. There aren't just two options: debug post-release or increase personnel headcount prerelease.
There is a better third option available: QA as a professional service.
Quality Assurance Services enjoyed via a business partner have two critical benefits:
- It can be obtained on a fractional basis. If there isn't 40 hours or more per week worth of tests that need to be performed, a 3rd party service provider can fulfil that need on an exact Time & Material basis, with no personnel recruiting fees, health benefits or taxes to be paid for an internal employee, supervisory management overhead, etc. It's affordable!
- An objective set of eyes. Allowing the developers who wrote your code to objectively judge their own performance might be a big ask, and is certainly a serious risk. Are they really the best people in the world to tell you if they think they did a good job or not? If the goal really is to produce high-quality software that doesn't have a lot of expensive bugs down the line to identify and repair, then having an honest evaluation is certainly the best approach.
Talk to ThinkSys
ThinkSys' foundation, from over a decade ago, was in providing world-class Quality Assurance programs and all levels of organizational maturity. If you've refrained from having the depth of QA expertise really needed as part of your development process, believing it was too expense — you need to talk to ThinkSys. It's a lot more affordable than you might think.
And above all, with such a service as part of your development lifecycle, the money you'll save in debugging late the process will more than pay for itself. And it will also go a long way to helping your customers believe that your software is something they can trust and rely on to do their jobs.