Skip to content
XpansionIT
All Blogs
Custom Software and SaaS Development9 min read

Legacy Application Modernisation in Australia: 5 Options, Costs and How to Choose

There are five ways to modernise a legacy system, and picking the wrong one is how projects blow out. The options, the 5 Rs, legacy PHP, real costs, and how to keep the business running while you do it.

Afif Alamgir

Engineering lead

  • legacy application modernisation
  • legacy system modernisation
  • 5 Rs of modernisation
  • legacy PHP modernisation
  • legacy application support
  • application modernisation Australia
Legacy Application Modernisation in Australia: 5 Options, Costs and How to Choose

How to Modernise a Legacy Application Without Blowing the Budget

There is not one way to modernise a legacy system, there are five, and most failed projects come from picking the wrong one for the situation rather than from bad engineering. We at XpansionIT modernise business systems for Australian companies, and this is our practical guide to legacy system modernisation: the approaches, what each costs, and how to choose between them.

The problem is real and local. In its December 2025 report, the Queensland Audit Office found that half of the systems it audited for financial reporting are legacy systems used well beyond their expected lifespan and no longer supported by their technology providers (Information systems 2025). That isn't a government quirk. It's the everyday reality for thousands of Australian businesses.

This is general information about building software, not legal or financial advice.

What Are the Options for Modernising a Legacy System?

There are five, from least to most invasive: document and stabilise, rehost, replatform, refactor or rearchitect, and rebuild. The right one depends on how long the system needs to last, how well it's understood, and how much the business depends on it. Most successful projects mix approaches across their systems rather than applying one to everything.

The Real Cost of Standing Still

Legacy systems survive because they look cheap. The bill is small and familiar, so the system feels like a solved problem. It isn't. The real cost is scattered: developers writing workarounds, vendor fees for software past its end of life, the occasional outage, and new ideas that stall because the old system can't connect to anything.

That cost also grows over time. The people who understand the old code move on and take the undocumented business rules with them. Security risk climbs, because unpatched software is exactly what attackers look for. And plans to add a modern tool, better reporting or AI quietly die because the old architecture can't support them. If you've ever been quoted a fortune just to make two systems talk to each other, you've already paid this cost.

The Five Approaches, Plainly

Think of these as a ladder. The higher you climb, the more you gain and the more you risk, so climb only as far as the situation needs.

Document and stabilise. For a system that will live another three to five years and mostly needs its risk reduced, the job is to understand and document it so it no longer depends on one person's memory. It's weeks of work, not months, and it buys you time and safety cheaply.

Rehost. Lift and shift the system to modern infrastructure with no code changes. Lowest risk and cost, quick to deliver, and it cuts hosting and support pain, though it doesn't fix the software itself.

Replatform. Move to current, supported foundations with light changes, for example shifting a database to a cloud equivalent and adding a proper deployment process. Low risk, real operational gains, still no deep rewrite.

Refactor or rearchitect. Improve the code structure, or change the fundamental design, so the system can grow again. Medium to high risk, and where the lasting improvements usually live.

Rebuild. Replace the system, but incrementally using the strangler pattern: wrap the old system and replace one piece at a time. A full big-bang rewrite should be a last resort, kept for systems that can't be understood or tested. If you're not sure which path your system needs, start with our guide to assessing a legacy system: repair or replace.

The discipline that separates success from failure is scoring each application against these five before touching any code, rather than defaulting to the most dramatic option. It's the same thinking as in our guide to low-code versus custom software: match the tool to the situation, and don't over-build.

How This Maps to the 5 Rs of Legacy Modernisation

You'll often see modernisation described as "the 5 Rs", a framework that originally came from Gartner: rehost, refactor, revise (sometimes called rearchitect), rebuild and replace. Cloud providers extend it to six or seven Rs by adding options like replatform, retain and retire. They're the same ideas as the five approaches above, with different labels:

Our approachMatching R
Document and stabiliseRetain
RehostRehost
ReplatformReplatform
Refactor or rearchitectRefactor, revise or rearchitect
Rebuild, piece by pieceRebuild or replace

Whichever labels a vendor uses, the useful question is the same: what's the smallest change that fixes the real problem?

Why Incremental Beats Big Bang, Every Time

If there's one thing worth taking from this guide, it's this. Big-bang rewrites look faster and cleaner on a project plan, which is exactly why businesses keep choosing them. In practice, they often run for a year or two, drift from what the business needs, and get scaled back or abandoned, leaving the business further behind than when it started.

The incremental strangler pattern avoids this by running the old and new systems side by side and switching over one part at a time. If a new part misbehaves, you send traffic back to the old one in minutes instead of facing a crisis, and downtime stays short because nothing switches off all at once. It's slower on paper and far safer in reality, which is the trade every sensible business should make for a system it depends on. It's the same phased approach we use when taking software from prototype to production.

Five Habits That Keep a Modernisation Safe

A few habits separate the projects that go smoothly from the ones that become horror stories.

Start with a cost and risk map, not code. Work out which systems cost the most to run, carry the most compliance risk, and are understood by the fewest people. Start there.

Treat data migration as its own project. Agree what "complete and correct" means before you move a single record. Data mistakes are expensive and hard to undo.

Turn tribal knowledge into tests. Where the only documentation is someone's memory, write those business rules down as automated tests. Run them against the old system first, then the new one, to prove nothing was lost.

Plan for rollback from day one. Every step should be reversible, so a problem means switching back, not a crisis.

Measure outcomes, not milestones. "We migrated the billing module" is a milestone. "Billing errors fell and support calls halved" is an outcome. Outcomes tell you whether it worked.

Modernising a Legacy PHP Application

A lot of Australian business systems built between about 2008 and 2018 run on PHP: custom-built portals, older Laravel or CodeIgniter apps, and heavily customised WordPress sites. Many still work well. The risk is what they run on.

PHP 8.1 and older no longer receive security fixes, and PHP 8.2 stops receiving them on 31 December 2026 (PHP supported versions). An application stuck on an old version, often because its code or packages won't run on a newer one, is exposed to security holes that will never be patched.

There are four common ways forward:

  • Upgrade in place. Move the application and its packages to a supported PHP version. Tools such as Rector can automate much of the code change. This is often the cheapest fix when the code is in reasonable shape.
  • Move into a modern framework gradually. Shift an older custom or framework-light app into Laravel or Symfony one section at a time.
  • Keep the PHP core, modernise around it. Add an API to the existing system and build a new front end or mobile app on top of it.
  • Rebuild piece by piece. Where the code is beyond saving, replace it section by section using the incremental approach above, in PHP or another language.

The right choice depends on how healthy the code is, how well it's understood, and how long the system needs to last. A short code review usually makes the answer obvious.

What It Costs in Australia

The real figure always comes from looking at the system, but here's how our fixed-price legacy work is structured:

StageWhat you getStarts fromTypical time
Modernisation auditWhat you have, what it's costing you, and the cheapest safe way forwardA$8,0001 to 3 weeks
Re-platformThe same system on current, supported foundationsA$20,0008 to 14 weeks
Rebuild and migrateA proper replacement, with the old workarounds designed outA$48,00016+ weeks

Large systems with many connections across a business cost more, and enterprise programmes can run into hundreds of thousands of dollars. Two warnings the vendor demos leave out. Legacy projects often run over their first estimates, so a quote with no allowance for surprises has been written to win the work, not to be accurate. And the biggest hidden cost is undocumented business logic: the rules buried in old code that nobody wrote down. A realistic plan budgets for finding those rather than pretending they don't exist. Our breakdown of what custom software costs in Australia covers the general cost drivers.

Keeping It Running While You Decide

Modernising doesn't have to start tomorrow, but an old system still needs looking after in the meantime. Legacy application support usually covers security patches, monitoring, backups, small fixes and documenting how the system works, so it stays safe and nothing depends on one person's memory.

A support arrangement can be the most sensible first step: it lowers the risk now and gives you time to plan the right modernisation. Our software maintenance and support plans start from A$350 a month.

Where AI Helps, and Where It Overpromises

AI does speed parts of this up. Automated dependency mapping, code translation and test generation can shorten a modernisation noticeably, and AI is especially useful for finding and documenting the business rules hidden in legacy code. That's real, and we use it.

The overpromise is believing AI does the whole job. AI speeds up the work; it doesn't replace the architect who decides what the system should become, or the person who knows what must not break. Treated as an accelerator with people in charge, it's a real advantage. Treated as autopilot, it's how you get a fast, confident, wrong migration.

It also works the other way. A modernised system with clean data and modern APIs is what makes AI useful later. You can't add meaningful automation or reporting to a system that can't share its data, which is why so many AI projects stall at the trial stage. We cover this in our guide to AI integration for Australian businesses.

A Note on Where You Are

Modernisation isn't tied to a location. The work is done wherever the right team is, and a good partner runs it remotely with clear stages and checkpoints. Whether your ageing system sits in Brisbane, Sydney, Melbourne or Adelaide, what matters is the approach and the safety net, not the postcode of the developer. We're an Adelaide team and we work with businesses across Australia the same careful way, wherever the system lives.

When You Should Not Modernise Yet

Since we do this work, we'll be straight about when to wait. If the system works well, is cheap to run, carries low security and compliance risk, and the people who maintain it aren't leaving, document it and leave it alone. Not every old system is a liability. The real test is whether it's costing you more than it returns, in money, risk or missed opportunity, and whether that gap is growing. And if a builder proposes a two-year, all-or-nothing rewrite as the only option, get a second opinion. There's almost always a smaller, safer first step.

Why This Matters to Us

We're a small Adelaide team, and modernisation is a large part of what we do, so we've seen both the good version and the wreck. The wreck is the big-bang rewrite that ran for two years and quietly fell apart. The good version is unglamorous: assess the systems, pick the least invasive approach that solves the problem, wrap the old system, replace it a piece at a time, and keep the business running throughout. We'd rather ship a working improvement every few weeks than ask anyone to hold their breath for a year and hope.

A Quick Word From Our Own Experience

"The most expensive modernisation is the big-bang rewrite that runs for two years and then quietly gets cancelled. Replace one piece at a time and you never bet the business."

Not sure where your system stands? Read our guide to assessing a legacy system: repair or replace.

Talk to Us

If you have an ageing system you're nervous about, we're happy to look at it, tell you which of the five approaches fits, and roughly what it would cost, before you commit to anything. Tell us about your system and we'll give you a straight answer, not a two-year sales pitch.

Whether your system needs a few careful repairs, a gradual rebuild, or no changes yet, we'll help you choose the safest next step. We improve one part at a time so your business keeps running while the work is done. Explore our legacy system modernisation service, or tell us what's happening and we'll explain your options in plain language.

FAQ

Questions readers ask

  • What are the approaches to legacy application modernisation?

    Five, from least to most invasive: document and stabilise, rehost, replatform, refactor or rearchitect, and rebuild. You assess each application against them rather than applying one approach to everything, and most businesses use a mix.

  • What are the 5 Rs of legacy modernisation?

    The 5 Rs, originally from Gartner, are rehost, refactor, revise (or rearchitect), rebuild and replace. Cloud providers extend them to six or seven Rs by adding replatform, retain and retire.

  • How much does legacy modernisation cost in Australia?

    Our fixed-price legacy work starts from A$8,000 for a modernisation audit, A$20,000 to re-platform a system, and A$48,000 to rebuild and migrate it. Large systems with many connections cost more, and a short audit gives the only reliable figure.

  • How do you modernise a legacy PHP application?

    There are four common paths: upgrade it to a supported PHP version, move it gradually into a modern framework like Laravel, keep the PHP core and build a new front end on an API, or rebuild it piece by piece. A short code review usually shows which one fits.

  • Is it better to rebuild or modernise incrementally?

    Almost always incrementally. Big-bang rewrites often run long and get scaled back. Running the old and new systems side by side and switching over one part at a time keeps the business running and makes every step reversible.

  • Can you support a legacy application without modernising it?

    Yes. Legacy application support covers security patches, monitoring, backups, small fixes and documentation, keeping an old system safe while you plan whether and how to modernise it.

Share