6 Common Causes for Poor Quality Software and How To Overcome Them

Poor quality software is one of the root causes of software startup failure. In 2018, in the US alone, poor-quality software cost organizations $2.8 trillion, according to the Consortium for IT Software Quality (CISQ). Yet, many companies overlook it, preferring to focus on expansion rather than perfection. 

But this comes at a cost: more than a third of smartphone users delete an app when they encounter a software glitch or bug, and that is just an example of how much poor quality software can hurt your organization.

But how do you measure software quality? What counts as high or poor quality software? In order to reach a high level of quality, software should be:

• Compliant with technical requirements: does the code conform to the specified technical requirements?
• Purposed-focused: does it meet the expectations of the user and offers satisfaction?
• Industry compliant: does it follow industry specific regulatory and technical compliance requirements that need to be met?

There are many reasons why you should build high-quality software. But many projects and organizations fall short on this goal. The 2015 edition of Standish Group’s Chaos Report shows that 29% of all software development projects were successful, 52% were over budget or lacking key features, and 19% were write-offs. 

In this article, we will cover the problems of not aiming for quality, and analyze 6 common causes that lead to poor-quality software, alongside tips on how to prepare your teams and your organization to deliver the best possible value to your customers.

Poor-quality software can lead to serious consequences for the product, project, or even the company producing it. We dive into that topic in more detail in this article.

A common debate in software development is whether you should focus on spending time improving the quality of existing features or if you should invest that time and energy into releasing new valuable features. Normally, the latter argument wins the discussion.

However, this distinction is illogical in the field of software development. A low-quality software product will always end up consuming more time and resources in the future. Compromising on software quality is trading a quick win for a major future loss.

You might be able to quickly release new features that customers demand and even expand your market share in comparison with competitors. But eventually, the defects and the technical debt will catch up. Over time, compromising on quality can actually cost you more, lead to lower user adoption, and take you longer to deliver new features, as you will be so swamped in technical debt that progress becomes a struggle.

Therefore, it’s important to keep best practices in mind in your daily work. Actions such as setting and enforcing code guidelines, conducting static code analysis, implementing automated testing, following domain-driven design, and practicing pair programming can positively impact the outcomes of your teams. On the DevOps side, speeding up your build pipeline, or doing the same to your deployment pipeline will also contribute to a higher-quality outcome.

Poor-quality software is something you want to stay away from. However, it is not always easy. Sometimes, the way companies work and the way teams are set up lead them to shoot themselves in their own feet. Let’s look at actions you can implement to prevent this.

Here are some causes for poor quality software and some tips on how to improve your course of action on those topics.

1. The Software Industry is Recent

In comparison to other industries such as construction and manufacturing, software engineering is still at a young phase of development. Therefore, a lot is still being discovered as companies go along. Fundamental methodologies and practices on which the industry is built have only been around for a couple of decades. Take the example of the Agile Manifesto: it serves as a base for plenty of companies who adopted these methodologies around the world, but it was only written in 2001, a little over two decades ago.

How to Improve: The industry is ever-evolving and so should be the workers’ knowledge. Companies that invest in their teams’ skills and improvement are setting themselves up for success by increasing their chances of refreshing knowledge and staying on top of trends. 

Another way to overcome this is by reaching out for help from external sources. For example, if your organization decided to implement Agile or DevOps and your team members don’t have much knowledge and experience on it, hiring someone specialized will help you navigate the transition and increase your chances of delivering high-quality software.

2. Lack of User Input

The lack of user input into the projects might be due to multiple reasons, such as the users being too busy and having more urgent tasks to accomplish, or the relationships between the user community and the tech team being poor.

The result might be catastrophic: imagine building perfect software from the quality point of view, with everything working well, but not fitting the user requirements. That would render the team’s work pointless.

How to Improve: There is no other way but to involve the user. In game design, for example, this connection with the user is much stronger. A prototype is built and then tested with real users, who provide valuable feedback for the teams to build the right product for their real users. In software development, this doesn’t happen as often but in order to overcome this, teams need Product Owners who spend less time explaining user stories to the Development Team and more time focusing on gathering user input and requirements.

3. Tight Deadlines

The software development industry moves fast. Deadlines are usually set “for yesterday” and the pace is quick and hard to keep up with. Often, pressed by tight deadlines, software teams rush the development process, in order to deliver faster. However, this tends to compromise the quality of the delivered product.

How to Improve: A golden rule to assure software quality is to go slow. Give all your attention to what you are working on, do it slowly but thoroughly. Even though this might feel counter-productive, it pays out in the end because you will end up with a good quality product instead of a mediocre one that you will have to re-work for several iterations.

4. Overlooking Design and Architecture

Related to the previous point, because of demanding deadlines, teams often jump to a working solution without considering the overall architecture design of the product they are building. While this might work at the time being, it will compromise the expansion later on and become a roadblock for possible changes that might be required.

How to Improve: Make sure your design and architectural framework are strong and flexible enough to be able to handle changes in the future. Spend time carefully thinking this through at the initial phase, and keep it in mind whenever you need to make decisions throughout the project. This will require some more investment time-wise, but it will also set you up for success and save you countless hours of refactoring later down the road.

5. Not Fixing Errors When They Emerge

When you come across an error, you should report it and take action for it to be fixed immediately. If it’s your responsibility to fix it, do it. If it’s not in your expertise, then trigger the chain that will get it to the appropriate team member. But make sure something is done on the spot.

The longer you wait to get an error fixed, the harder and more expensive it will be to do so. Remember that errors are not side effects of software development, something you can push under the rug and deal with later. An error stops a piece of functionality from being considered done. And if you’re working to get something done, then you should really get it done.

How to Improve: Fixing the error, or taking corrective action, is only half of the story. The other half is about preventive action. What can you do to prevent the error from happening again? Whatever it is, do it, it will save you and your team many hours and headaches.

6. Not Reviewing and Testing Enough

Good quality software should be subject to peer review. On one hand, this allows developers to familiarize themselves with other aspects of the product and, on the other, it helps to make sure that each developer’s code is readable to someone other than themselves.

Furthermore, all software should be thoroughly tested. Including tests early in the process lays the foundation for code to be far higher in quality. Even simple unit tests applied can catch a great number of errors that, otherwise, would cause trouble further down the line.

How to Improve: Implement processes to make sure the developers in your team review each other’s work. Also, test early and often. The complexity of software development means it is impossible to test every imaginable path but having processes in place and using techniques such as unit testing, smoke testing, and automated regression testing helps improve the quality of the software.

For your company to stay relevant and competitive in the demanding IT market, you need to keep a relentless eye on quality. Delivering great products is the surest way to positively impact your organization’s growth and revenue.

To achieve this, follow our guidelines mentioned above. Focus especially on building as many gates as possible before your software reaches a production environment. Build these gates early on in the process, to make it faster and cheaper to fix the issues. Bet on automation to free your engineers from manual repetitive tasks and improve results by avoiding human error. Favor blocking gates that prevent you from moving to the next stage in opposition to gates that sit on the side.

Overall, quality is the result of every touching point in the software lifecycle, from planning, to management, to QA. If you can’t implement all those changes at once, remember that doing something is better than doing nothing at all. And if you are unsure about where to start, we are here to help.

Søren Pedersen

Co-founder of Buildingbettersoftware and Agile Leadership Coach