How to Avoid the (Hidden) Costs of Poor Quality Software!

Poor Quality Software. Technical Debt. Both could go hand-in-hand. How can we avoid these costs before it’s too late? In most cases, the solution to minimize costs of poor quality software requires a simple shift in:

• attention
• and responsibility

Software development projects are often driven by the financial and time restrictions of a business. If this happens, most of the time insufficient attention is paid to the quality of the software. As a result, engineers waste a lot of time fixing errors and bugs of poor quality software. You guessed it right; this can be very costly. Microsoft’s Norman Guadagno, Director of Microsoft Corp.’s Visual Studio Team System brilliantly summed it up as follows:

“It is less expensive to build quality in than it is to add quality after the fact.”

Companies often overlook this as customers might perceive poor quality software as the end-user experience. We can measure this through a software’s interface or reliability. But the measurement of quality that can indirectly affect both criteria is the architecture of the software — something end-users can’t perceive. A good software architecture will make it easier for programmers to update the software and add new features in a shorter time-span. Ultimately, enhancing the customer’s experience and benefits of using the software.

The average developer spends a lot of time debugging badly written code: 42% of their time to be exact. The opportunity cost of dealing with maintenance issues and technical debt comes to $85 annually.

Theresa Lanowitz, founder of research firm Voke and Head of Evangelism and Communications at AT&T, states that around “80 percent of an IT budget is spent on maintenance rather than on new development”. Faulty codes that are implemented in multiple software projects cause errors and vulnerabilities (such as security of the entire system).

So, what is good code then?

A well-written code….

… does not take long to debug. This saves time and increases engineer’s result, saving your company money in the long run. The cost of fixing bugs (and having potential bugs) decreases.

… can be tested. A good code should not be strictly monolithic as developers would have to manually test all paths, taking more time and productivity away.

… has fewer duplications. This in turn reduces the probability of engineers having to change the same code in multiple places when a feature needs updating. This means, you’ll gain time, effort, and productivity.

So, what are the action steps you can take to reduce poor quality software?

Focus on (internal) quality:

The effort of focusing on quality will make it easier to enhance the software when it needs updating. Customers do care that new features come quickly!

New features can be easily implemented with a clean and well-structured code. If the focus is not on quality, the time it takes to add new features over-time could be longer than the initial phase. Trust us when we say, you do not want to go there (see chart below). And this is just one of many costs of poor quality software you will eventually run into.

Link: https://martinfowler.com/articles/is-quality-worth-cost.html

Give Responsibility

As each individual is held accountable for the work they do, one of the consequences is more frequent User Acceptance Testing (UAT) prior to product release.

Many organizations have suffered losses due to incomplete UAT. The cost of fixing software defects post-release is often greater than fixing the issues prior to release.

For example, the individual in charge of architectural ownership will make sure that the components (of code) made, interact well with the design; thus keeping the vision aligned.

To optimize and streamline your software development lifecycle, Guadagno praises the agile wok methodology. It has a great effect on quality as frequent feedback loops and the agile work system allow for changes at the early stages.

It’s easy to overlook the factors that create good software quality. Most of the work can be done from within (sounds familiar huh? 😉). Focus on the non-surface level of software development to minimize future bug issues and software glitches. Managers can assert responsibility, time, and attention on good quality software and maximize their opportunities for improving it. In turn, we can eliminate a few bumps on the road ahead!