Security & Compliance · 4 min read · 19 November 2026

Upgrading software is not a matter of changing a number

How to upgrade legacy software, fix its security flaws and manage incompatibilities between old and new, without taking services offline.

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:

  1. Automated code analysis, to obtain an accurate map of vulnerabilities and bugs before touching any component.
  2. Progressive upgrading of the core technologies the software relies on: Spring Boot, Java and the Axis integration framework, one step at a time.
  3. 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?

Let's talk about your project

Running a legacy system and unsure what happens if you upgrade it?

Tell us about your technical challenge. A senior engineer will analyze it and respond within 24 business hours.

Let's talk about your project →

Or call us at 0461 1975740 · Response guaranteed within 24 business hours

More articles
Crypto-agility: the problem of hidden cryptographic dependencies
Security & Compliance 12 Nov 2026

Crypto-agility: the problem of hidden cryptographic dependencies

When I talk about security with the people who run an organisation’s systems, one question keeps coming up without a precise answer:…

Read the article →
Managing a vulnerability: the PHP2Shell case
Security & Compliance 29 Oct 2026

Managing a vulnerability: the PHP2Shell case

I receive an email from the client. Just a few lines: at 4 pm a very serious PHP vulnerability will be disclosed,…

Read the article →
ISO certifications: why they matter when choosing a technology partner
Security & Compliance 8 Oct 2026

ISO certifications: why they matter when choosing a technology partner

When a company chooses a software house to develop or manage a critical system, the question rarely asked is “Are they ISO…

Read the article →