The strangler fig is a tree that grows around its host, branch by branch, until the original withers away and the fig stands on its own. It's also the safest known way to take back control of an expensive ERP, a big-ticket licence, or a runaway SaaS bill: not all at once, but one function at a time — with the old system still running underneath as your safety net, until the day its contract covers nothing and you cancel it. This briefing is the strategic case — what it means for your cost base, your risk, and your freedom to move — in plain terms, for the person who has to make the call.
You don't have to choose between paying a vendor forever and a terrifying all-at-once replacement. There's a third path: put a thin layer in front of the expensive system, then replace it piece by piece with open-source software you own — each piece proven in real use before you move to the next, the old system always there to fall back on. Modern AI coding tools build those pieces in a fraction of the old time. You shrink the licence steadily until it's covering nothing, then you cancel it.
When a licence renewal lands and the number has gone up again, most boards believe they have two options. They actually have three — and the third is the one with the best track record by a distance.
Renew, absorb the increase, stay locked in. Easy this year; the bill and the dependency only grow, and your negotiating position weakens every cycle.
Buy or build a whole new system and switch over in one big cutover. The classic "ERP project." Famous for blown budgets, slipped dates and the occasional company-threatening failure.
Replace the system gradually, one function at a time, behind a façade — old system live as a safety net the whole way. Small, reversible steps instead of one giant leap.
A thin layer — think of it as a switchboard — sits in front of the old system. Every request goes through it. At first it sends everything to the old system. As each new piece is built and proven, the switchboard quietly redirects that one function to the new system. The old one keeps shrinking until it's doing nothing.
There's no magic to it. It's the same loop, run once per function, each lap small enough to undo if it misbehaves.
A thin layer routes every request. For now it sends everything to the old system — nothing changes for users yet. This is what makes every later step reversible.
Start where the vendor hurts most and the danger is least. Reporting and dashboards are the classic first target: read-only, so you can't break anything live.
Build that one piece on open-source foundations you own — and use AI coding tools to do it in a fraction of the usual time. It runs alongside the old system, not instead of it yet.
Point the switchboard at the new piece for that function only. Everything else still runs on the old system. If anything's wrong, you flip it straight back.
Let it run in real use until you trust it. Then pick the next function and go again. The expensive system quietly shrinks with every lap until it's covering nothing.
Strangling a big system used to be a luxury only large engineering teams could afford. Three things changed that — and together they put it within reach of an ordinary organisation.
Mature, free, self-hostable systems now exist for the things you used to pay six figures for — ERP, databases, business intelligence. No per-user licence, and the data stays yours.
Every replacement piece — its code, settings and customisations — lives in a vault your organisation controls, with a full history. You're building an asset, not renting another one.
AI coding tools turn weeks of bespoke development into days. The per-function cost that made strangling uneconomic has collapsed — which is exactly what the method needs.
Strangler fig only works if each small piece is cheap and fast to build — otherwise the gradual path takes forever and stalls. Open source removes the licence cost of the replacement, ownership turns every piece into a durable asset, and AI collapses the build time. None is new on its own; together they're what makes replacing an expensive system one function at a time genuinely affordable in 2026.
There's an honest cost to be clear about: for a while you pay the vendor and invest in the replacement. That overlap is the investment. On the other side of it, the licence falls away and you're left running something you own at a fraction of the old cost.
Illustrative — the shape is the point, not the scale
Two real costs. First, the overlap: for a stretch you carry both bills at once. Second, owning means someone has to run it — in-house or via a partner — so this is predictable cost, not free cost. The case for doing it is that the green line ends far below the red one, you stop the annual increases, and you can never be held hostage at renewal again.
The reason boards fear replacing core systems is the big-bang cutover — the weekend where everything changes and something breaks. Strangler fig simply doesn't have that weekend.
Nothing flips all at once. You move one function at a time, so the worst-case failure is one function — not the whole business.
It stays live underneath until the very end. If a new piece misbehaves, you switch that one function straight back and carry on.
First targets are read-only, like reporting. You prove the approach on something that can't break a live transaction before you touch anything that can.
If a phase shows the replacement isn't ready, you pause. You've still cut some cost and you've lost nothing — the old system is still there.
1. The never-ending strangle. The biggest failure mode isn't a broken step — it's stopping halfway and running two systems forever, paying for both. The fix is a board-level commitment to a finish line: set the date you intend to cancel the licence, and treat it as a target.
2. Keeping data in step. While both systems are live, the same information has to stay consistent across them. That coordination is the real engineering work of a strangle — budget for it, and lean on owned, open data systems that make it tractable.
3. Save the core for last. Don't start with the crown-jewel finance ledger. Strangle the periphery first, build trust and capability, and move the core only once everything around it is already proven on the new stack.
You don't commit to the whole journey on day one. You take the first safe step and let the results make the case.
Pick the one expensive system that hurts most — the ERP, the big licence, the runaway SaaS bill — and the one low-risk function you'd move off it first. Usually: reporting.
Fund a small, time-boxed first move: switchboard in, that one function rebuilt in open source with AI, proven in real use. Cheap enough to be a pilot, real enough to prove the model.
If the pilot lands, commit at board level to a date for cancelling the licence, and strangle toward it function by function. Make ownership the destination, not a someday.
You don't have to keep paying, and you don't have to gamble on a rewrite. Wrap the expensive system, replace it a function at a time, and let the licence wither. Start before the next renewal.