Upgrading a software component can take a few seconds: all it takes is changing a version number in a configuration file. Understanding what happens to the system after that change, however, takes engineering. This is the story of an application serving a public sector body that, over the years, had built up postponed upgrades, what in IT is known as technical debt, along with a number of security vulnerabilities. It is an application that now passes its quality and security checks, SonarQube’s Quality Gates, once again, with no disruption to operations.
“Just change the version”
It is often said that upgrading software components is a trivial task. You open the configuration file, change a number, rebuild the program. For those working on young systems, with few dependencies and good test coverage, sometimes that really is the case.
On critical systems that have been running for years, it is a half-truth, and the missing half is the one that costs.
Every component brings other components with it, and each one has a behaviour the rest of the system has learnt to take for granted. Changing a version means changing those assumptions, often in parts of the architecture nobody has looked at in a long time.
The starting point
The application we worked on serves a public sector body. Over the years it had accumulated technical debt: outdated versions of Java, Apache Axis and Spring Boot, the technologies underpinning how it works, kept in place because they “worked”.
The problem surfaced through automated code analysis. SonarQube, the tool that analyses code and flags issues, was reporting security vulnerabilities that prevented the project from passing its Quality Gates, the minimum quality and security thresholds the project had set itself. It was no longer a question of tidy code: the project did not meet those thresholds, and every new feature would have been built on foundations that failed the check.
A methodical plan, not a version jump
We ruled out the idea of upgrading everything in one go. Instead, we built a three-stage remediation plan:
- Automated code analysis, to obtain an accurate map of vulnerabilities and bugs before touching any component.
- Progressive upgrading of the core technologies the software relies on: Spring Boot, Java and the Axis integration framework, one step at a time.
- Systematic resolution of the vulnerabilities and bugs flagged by SonarQube, checking the effect on the Quality Gate at every step.
The difference compared with the quicker alternative is simple: each step was verified before moving on to the next, preserving the ability to isolate changes and intervene if something broke in parts that had previously worked.
The critical moment: when the new is not compatible with the old
The trickiest part was managing the incompatibilities introduced by upgrading central components, Apache Axis and Spring Boot in particular. The constraint was twofold: existing services had to keep working for those who relied on them, and at the same time data security could not be a compromise accepted “until the work is finished”.
At this stage, automated tests, the checks that verify the software still does what it should, stopped being good practice and became the means of deciding whether a step was complete. An upgrade counted as successful only when the tests passed and the quality analysis had not deteriorated.
What changed
The project passed SonarQube’s Quality Gates. The critical vulnerabilities flagged by the analysis were brought down to zero, and the scope for exploiting any flaws in the system has been significantly reduced. The code is now easier to maintain and ready for new development, without starting from a growing debt.
The data comes from SonarQube analysis reports, build logs and the project’s Quality Gate metrics.
What I learnt
Upgrading a system’s core components without checking what happens is an enormous risk. Continuous testing and automated quality analysis are not optional: they are indispensable tools for spotting problems early and preventing an upgrade from compromising existing functionality.
Technical debt and vulnerabilities are not simply items to fix when time allows.
They are factors that shape a system’s ability to evolve, maintain its security levels and support the organisation’s operational needs.
For those managing legacy systems, the useful question is not whether to upgrade, but how well you really know what you are about to change: which part of the system would withstand an upgrade today, and which issues would only surface in production?