Whilst as users we are constantly on the receiving end of bug-fixing app updates, there’s a daily drill in many DevOps teams. Developers are asked to ‘Just try harder’ not to create bugs and testers are expected to catch them before production. However, this age-old strategy doesn’t address the root causes of software bugs and can even be counterproductive. In an era where quality and speed of code means everything, developers should – and can – take a proactive approach to minimise the likelihood of bugs and take a resilience-by-design approach in order to reduce their impact.
With the aftermath of a problem in the coding process varying from slow or unresponsive user experience to business-ending data breaches, taking actionable steps to creating a culture to minimising bugs is essential to build productive development practices. Even if bugs can’t be 100% eliminated, keeping them at a low impact level rather than catastrophic failure will ensure teams find bugs before their customers do.
The importance of finding the root cause of bugs
Today’s development teams are perpetually under pressure – to deliver faster, cleaner, quality code. The impact of a bug is firstly on the team, sucking up time that they don’t have to fix such issues. Secondly, on the client – losing confidence in the development team to deliver great outcomes and putting pressure on CTOs to explain to the board.
The knee-jerk response to tackling frequent bugs might be to check code quality, testing, legacy issues, or poor requirements. However, it’s important first to address some of the root causes that contribute to bug creation which are crucial for creating a more resilient environment.
There are three key approaches to counter the occurrence of bugs, which can significantly help software teams to improve the quality and speed of their software delivery. Building a secure and high-quality coding process is a central goal of this:
Fast continuous feedback loops
The importance of fast, continuous, feedback can’t be over-emphasised as the frontline of defence against bugs. This fast feedback ensures that issues are detected early so that code can be adjusted quickly to accelerate delivery.
In fact, high-performing teams that achieve fast feedback loops are crucial for early bug detection, risk mitigation, and quick recovery. Teams with fast feedback cycles also report better software delivery performance and are more resilient to failure.
When long pipeline build times discourage developers from running tests locally, this can lead to delayed issue detection. By investing in continuous integration/continuous delivery (CI/CD) infrastructure, optimising and streamlining test suites and automating manual processes, pipeline feedback can be cut to less than a minute locally and five minutes end-to-end.
In conducting more frequent testing and identifying issues at the earliest stage, the team can release software with confidence.
Proactive monitoring in development workflows
If we can’t completely eradicate bugs from appearing, at the very least it is essential to find and resolve them before customers do. By using targeted monitoring and observability tools and feature flags in development workflows, particularly with automated alert notifications, teams can spot any issues – and fix these – before they impact users.
Monitoring is the instrumentation (metrics, events, logs, and traces) that can help to explain a system’s health. It might be looking at low-level operational metrics like available disk space, memory, or CPU load, to API response times or user engagement (such as sales or conversion rates). Real-time observability and controlled rollouts will alert the development team to major issues, like a service outage or significant spike in errors, or indicate something more subtle, such as a drop in conversions or slow API responses.
Other benefits of monitoring and observability include spotting long-term trends for capacity planning and identifying unauthorised activity. For instance, if you are migrating a legacy healthcare system while handling sensitive patient data, detecting bugs early during development rather than after deployment, will safeguard patient data and avoid disrupting the user experience.
Streamlining change approval
Another route is to reduce change approval overhead. In development workflows, approvals are often slow, involving multiple sign-offs and manual release candidates. This long process can lead to frequent ‘hot fixes’ that bypass processes entirely, which increases risk.
With an automated approach, teams can avoid bottlenecks, enabling faster releases and reducing the likelihood of bugs reaching production. This strategy involves transitioning to a peer-review-based process for code changes, supported by automated tests. Through implementing automation to build release candidates, teams ensure the tested code matches the code deployed and collaborate with stakeholders to simplify approvals. Using automated tools can more promptly identify regressions, performance problems, and security issues.
In streamlining and automating change approval processes, this reduced friction makes releasing smaller, safer, changes easier. Taking this approach can reduce a shift from releasing every two weeks to every couple of days, dramatically reducing emergency fixes. Other benefits include generating improved stakeholder trust in the process, greater business confidence, and support engineers may have more time to invest in more proactive tasks alongside their role.
Proactive issue detection builds resilience
The key to building quality software that minimises the occurrence of bugs is adopting a resilience-by-design approach. Crucial to this is getting fast feedback on the impact of changes throughout the software delivery lifecycle.
When addressing frequent bugs, development team leads must consider monitoring and observability, the change approval process, and deployment automation and testing to improve the quality and security of code.
Whether they’re developers, testers, or project managers – taking responsibility for building these concrete steps into the software development lifecycle will minimise bugs and build superior software outcomes.
The author
Andy Weir is Technical Consultant at Headforwards
