IT expert Jason Coyne revealed he warned the Post Office of 'significant discrepancies' in its Horizon IT system 20 years ago but his report was ignored. 

Subsequently, over 700 sub-postmasters were wrongly convicted of fraud and theft between the years of 1999 and 2015 after an unaddressed fault in the software created discrepancies in their accounts. Rishi Sunak said they were victims of "one of the greatest miscarriages of justice in our nation's history".

Although this is an exceptional case, choosing not to fix issues lurking within a software system at any scale, can have knock-on implications down the line leading to increased costs, poor user experience, and compromised security. They can also damage a company's reputation and hinder further development.

There are multiple reasons why a bug may occur

• Human coding errors
• Miscommunication about the desired outcome
• Misunderstanding the requirements and designs
• Complexity of code, design, architecture
• Changes in the software development team

Short-term cost-saving, long-term expense

Software bugs can occur at any stage of the software development life cycle. If an issue is found at an earlier stage and not immediately addressed, the cost to fix it is likely to increase as development continues. That’s because a bug can have a knock-on effect that leads to additional problems and delays.

IBM’s Systems Sciences Institute reports that:

• The cost to fix a bug found during implementation is around six times higher than one identified during design
• The cost to fix an error discovered after product release is then four to five times as much as one identified during design
• The cost to fix a bug found during maintenance costs 100 times more than one discovered during design 

What’s more, beyond these direct costs, there are also related expenses incurred due to missed release dates, dissatisfied users, or product recalls.  

While identifying and fixing bugs requires an investment of time and resources, it is a cost-effective approach in the long run, reducing maintenance costs and helping to keep software development projects on schedule and within budget.

The impact on functionality, performance and compatibility

A bug can alter the behavior of the software, impacting its expected function. Bugs can be functional, behavioral, cosmetic or compatibility-related.

• Functional bug: e.g. a user cannot log onto a website or the search option is not functioning
• Cosmetic bugs: such as screen alignments, section divisions, translation issues, the colour of the texts
• Performance bugs: e.g. when the application takes too long to load a screen, or the screen navigation is very slow
• Compatibility bugs: such as inconsistent software behaviour among different operating systems and browsers

Software is increasingly relied upon by users to perform tasks efficiently and accurately. A bug can result in crashes, data loss, and other issues that undermine this trust, leading to frustrating, inefficient, insecure and even unsafe experiences.

Bugs and security

Even if they seem small or insignificant at times, identifying and fixing bugs is paramount for safeguarding the security of software and data and, in some cases, operating within the parameters of the law.

From personal information to financial records, software often deals with sensitive data, where unresolved bugs can lead to data corruption or loss.

Some bugs can even be exploited by malicious actors to gain unauthorised access to a system, leading to security breaches and data theft. In some industries, such as financial services, bug identification and resolution are essential for meeting regulatory obligations.

Protecting your reputation

Quite simply, software riddled with bugs can significantly damage any company’s reputation and tarnish its brand image, and it can take a very long time and financial resources to rebuild trust with stakeholders and customers once it’s been lost due to software issues.

Workarounds - or time-wasting?

When an issue is discovered, a quick resolve is sometimes the best cause of action to swiftly minimise the impact on the end user. However, wherever possible, a workaround should be seen as a short-term fix - not a long-term solution. 

A permanent solution is one that resolves the underlying root cause to the problem, with a view to preventing any more incidents from being caused, and freeing up the IT team to concentrate on innovation and business growth, rather than ‘fighting fires’.

A ‘test-fix’ business mindset is a must

A ‘test-fix’ mindset is one where the overall business, not just the IT team, is bought into an ethos where bugs must be addressed, and wherever possible, fixed. So it stands to reason that small bugs that can be fixed quickly should be dealt with right away. 

Other bugs that may require a more complex, expensive fix, could be tempting to suppress, but - like The Post Office discovered - leaving them unchecked can lead to losses that go way beyond the price of fixing them in the first place. 

Another example of this is an NHS glitch that was discovered in 2018, which was found to have risked more than 10,000 patients being given the wrong medication, potentially posing a genuine risk to the public’s health. 

Of course, many bugs simply result in highly inconvenient, frustrating and costly scenarios for a business and its users. For example, hundreds of Sainsbury’s customers were recently unable to pay for their shopping when the payment system went down on a busy Saturday, and a software malfunction caused the E-gates to stop working at the UK’s major airports causing huge delays for passengers this month. 

But as technology becomes more responsible for life-or-death scenarios, from self-driving cars and smart motorways, to MedTech and nuclear energy - a blanket ‘test-fix’ mindset amongst business leaders, on every kind of software development programme, is a must.

Testing isn’t just about finding bugs

Testing is often seen as something that ‘must’ be done in order to tick a box, particularly by business leaders who are not close to the day-to-day delivery of IT. This is where it can become squeezed in at the end of a process with less than adequate planning, resulting in things going live or into production with perhaps some bugs that could have been avoided given more time. 

However, a shift-left approach to testing, AKA, testing software early in the development process, can preempt issues and add value to the outcome by looking at the functionality requirements from a different point of view. This can lead to improvements in processes, or identifying where there may be issues further down the line. That’s because experienced testers think from a usability viewpoint, which sometimes development cannot see.

Combining the efforts of the developer, analyst and tester from the start of a project gives it the best chance of success.

The Propel Tech approach to testing

Propel Tech’s team of experienced testers create structures within each project, allowing us to test more effectively and efficiently. Direct collaboration with developers also helps everyone’s understanding of a requirement

We take a strategic approach to software testing, and kick off each project by developing a bespoke guide to give clients insight as to areas they maybe haven’t considered. It’s also designed to reassure clients that testing will be carried out to a high level and not just an add-on. 

Discover more about Propel Tech’s software testing capabilities here.