// Service · Legacy System Upgrades
Legacy System
Upgrades
Your system works. Throwing it out costs money. Not upgrading it — is a gamble.
You have a system. It works. It handles customers, money, the core processes of the business. Even if it's built in AngularJS (not Angular), PHP 5, .NET Framework, or Java EE — it gets the job done.
Until today.
Developers who know the tech are retiring or moving on. Adding a new feature takes two months instead of two weeks. Libraries with known vulnerabilities that no longer get updates. A system burning 10x the resources it should. And a customer complaining that the UI looks like 2010.
One day, something will break. The question is: are you driving the upgrade on your terms — or is it driving you when the system collapses?
We do smart upgrades. Without breaking what already works. Without a two-year "big bang."
// 01 · Why not just rebuild
Why not just "rebuild from scratch"?
It's the tempting option. It's also why most full-rewrite projects fail.
- 01
Massive cost
An existing system carries thousands of business decisions you can't recover from a spec doc.
- 02
Time
A rebuild takes 2 to 3 years. Meanwhile, the competition didn't wait.
- 03
Risk
A new system is all-or-nothing. If it doesn't work — you're 3 years behind.
- 04
The old team gets abandoned
The developers who know the business logic aren't on the new project. The knowledge gets lost.
There's a third way: gradual modernization. One system, upgraded component by component, with the business running through most of the stages.
// 02 · What we do
What we do
From audit to CI/CD — through frontend, backend, database, cloud and UI. Everything needed to bring a system into 2026.
- 01
Initial audit
A comprehensive review of the system. Technologies, dependencies, architecture, weak points, security risks. What's urgent, what's important, what can wait.
- 02
Modernization strategy
Strangler Pattern, gradual refactoring, or a full rewrite — we decide together. Based on risk, budget, and timeline.
- 03
Frontend upgrade
From AngularJS / jQuery / Backbone to modern (React, Next.js, Vue). Without throwing out the backend, without stopping ongoing development.
- 04
Backend upgrade
Old PHP → modern Laravel/Symfony, or Node.js. Java EE → Spring Boot. .NET Framework → .NET 8+. Old Ruby/Python → modern versions.
- 05
Database migration
Old MySQL → modern PostgreSQL/MySQL. SQL Server → a newer version or PostgreSQL. With minimal downtime.
- 06
Cloud migration
On-prem to cloud (AWS, GCP, Azure). Or between clouds. Or optimizing what's already in the cloud.
- 07
Microservices migration
Breaking a monolith into services, at the right pace. Not because it's trendy — because it solves real problems.
- 08
CI/CD setup
From a manual deployment that takes a day, to automated deploys in minutes. With tests, monitoring, and automatic rollback.
- 09
UI/UX modernization
A 2010 interface → a 2026 interface. Responsive, accessible, fast. Without changing the business logic.
- 10
Adding tests
Legacy systems usually lack tests. We add them — so future changes are safe.
// 03 · Our approaches
Our approaches
- 01 · Recommended
Strangler Pattern
We build the new pieces around the old one. Every new feature gets written in the new tech. Over time, the new "strangles" the old. Disruption to operations is small and planned — not zero, but known in advance.
- 02 · Rare
Big Bang
A full rewrite all at once. Reserved for cases where there's really no other option — a system so broken it can't be worked on.
- 03 · In-between
Refactor Hybrid
Targeted fixes while the system stays in operation. Structural improvement without swapping the tech stack.
We recommend the right approach for each case — after we've seen the system and understood the business.
// How an upgrade is planned
Diagnosis, alternatives, and a transition plan you can roll back from.
'The system is old' is not a diagnosis. Before deciding what to upgrade, you need to know exactly what is blocking the business, what depends on what, and which parts can be replaced without touching the others. This is our order of work.
What is actually blocking the business?
The diagnosis starts from the symptoms the business feels — not from the technology version. Each symptom has a likely technical cause, and each cause has a fix of a different size.
| What the business feels | Common technical cause | What the diagnosis checks |
|---|---|---|
| Every small change takes weeks | No automated tests; code where everything depends on everything; manual deployment | How long from fix to production, how much of that is waiting, and where things break after a change |
| Hard to find developers willing to touch it | A technology no longer taught; versions without support; knowledge held by one person | Which components are end-of-life, who in the organisation knows each part, what happens if that person is unavailable |
| The system is slow or falls over under load | Inefficient queries, a single server, no monitoring that shows where the time goes | Measurement before assumption: which screens and actions are slow, when, and in which component |
| New tools cannot be connected | No API; data is reachable only through the screens or straight from the database | Which integrations the business needs in the coming year, and the shortest way to expose data without rewriting |
| Worry about security or compliance | Libraries with known vulnerabilities, old encryption, blanket permissions, no audit log | A dependency scan, a map of who can access what, and which regulatory requirement actually applies |
Every small change takes weeks
Common technical cause: No automated tests; code where everything depends on everything; manual deployment
What the diagnosis checks: How long from fix to production, how much of that is waiting, and where things break after a change
Hard to find developers willing to touch it
Common technical cause: A technology no longer taught; versions without support; knowledge held by one person
What the diagnosis checks: Which components are end-of-life, who in the organisation knows each part, what happens if that person is unavailable
The system is slow or falls over under load
Common technical cause: Inefficient queries, a single server, no monitoring that shows where the time goes
What the diagnosis checks: Measurement before assumption: which screens and actions are slow, when, and in which component
New tools cannot be connected
Common technical cause: No API; data is reachable only through the screens or straight from the database
What the diagnosis checks: Which integrations the business needs in the coming year, and the shortest way to expose data without rewriting
Worry about security or compliance
Common technical cause: Libraries with known vulnerabilities, old encryption, blanket permissions, no audit log
What the diagnosis checks: A dependency scan, a map of who can access what, and which regulatory requirement actually applies
Map before you change
- 01
Dependency map
Which components call which, which libraries and versions are in use, and which of them are end-of-life. The order follows from it: what can be replaced first without breaking the rest.
- 02
Data map
Which tables and documents exist, who writes to them and who reads them, and which data is the 'source of truth'. Data migration is usually the riskiest part of an upgrade — so it is planned first.
- 03
Business-logic map
The rules the business runs on that nobody wrote down: calculations, exceptions, 'we have always done it this way'. Some live in the code, some in one person's head. They are documented before the code is touched.
- 04
User and usage map
Who uses what, how much, and when. A screen nobody has opened in a year does not need upgrading — it needs retiring. This usually saves a meaningful share of the work.
Staged upgrade versus full rewrite
Both routes are legitimate. The difference is what you risk, when you see a result, and what happens if something goes wrong halfway.
| Comparison | Staged upgrade | Full rewrite |
|---|---|---|
| What happens to the existing system | Keeps running; parts of it are replaced one by one | Keeps running unchanged until cutover day, then is retired |
| When the first result is visible | After the first component — usually early | Only when the new system is complete enough to replace the old one |
| The main risk | A long period of two technologies side by side; the temptation to stop halfway | Forgotten business logic surfaces only after cutover; a single cutover day on which everything hangs |
| What happens if it goes wrong | Roll back the one component; the rest of the system is unaffected | Roll back to the whole old system — if the data created in the meantime can be restored |
| When it is the right call | When there are parts worth preserving, when the business cannot stop, and when the existing team needs to keep working | When the diagnosis shows nothing worth preserving, or the platform itself is ending |
What happens to the existing system
Staged upgrade: Keeps running; parts of it are replaced one by one
Full rewrite: Keeps running unchanged until cutover day, then is retired
When the first result is visible
Staged upgrade: After the first component — usually early
Full rewrite: Only when the new system is complete enough to replace the old one
The main risk
Staged upgrade: A long period of two technologies side by side; the temptation to stop halfway
Full rewrite: Forgotten business logic surfaces only after cutover; a single cutover day on which everything hangs
What happens if it goes wrong
Staged upgrade: Roll back the one component; the rest of the system is unaffected
Full rewrite: Roll back to the whole old system — if the data created in the meantime can be restored
When it is the right call
Staged upgrade: When there are parts worth preserving, when the business cannot stop, and when the existing team needs to keep working
Full rewrite: When the diagnosis shows nothing worth preserving, or the platform itself is ending
The transition plan — what is in it
Every stage of the upgrade gets the same one-pager: what moves, when, who is responsible, how it is verified, and how to roll back. Without that page there is no stage.
| Item | What is defined | Example (illustrative) |
|---|---|---|
| Stage scope | The component or process that moves, and what is explicitly not touched | The orders screen moves to the new frontend; the API and database stay |
| Data migration | Which data moves, how fields are mapped, and how arrival is verified | A trial run on a copy; record counts compared; an exceptions report |
| Testing | What is tested automatically, what is tested by users, and what counts as 'pass' | Regression tests on the existing calculations; two users from the team run a full process |
| Owners | Who signs off on your side, who is responsible on ours, and who decides whether to stop | The operations manager signs off; our team lead is responsible; either can stop |
| Transition window | When the cutover happens, how long it should take, and what users will notice | Outside working hours; users notified in advance; the form changes — the data does not |
| Rollback | What triggers a rollback, how it is done, and what happens to data created in the meantime | If the order flow fails for more than one user — the old screen is restored the same day; the data is shared, so nothing is lost |
Stage scope
What is defined: The component or process that moves, and what is explicitly not touched
Example (illustrative): The orders screen moves to the new frontend; the API and database stay
Data migration
What is defined: Which data moves, how fields are mapped, and how arrival is verified
Example (illustrative): A trial run on a copy; record counts compared; an exceptions report
Testing
What is defined: What is tested automatically, what is tested by users, and what counts as 'pass'
Example (illustrative): Regression tests on the existing calculations; two users from the team run a full process
Owners
What is defined: Who signs off on your side, who is responsible on ours, and who decides whether to stop
Example (illustrative): The operations manager signs off; our team lead is responsible; either can stop
Transition window
What is defined: When the cutover happens, how long it should take, and what users will notice
Example (illustrative): Outside working hours; users notified in advance; the form changes — the data does not
Rollback
What is defined: What triggers a rollback, how it is done, and what happens to data created in the meantime
Example (illustrative): If the order flow fails for more than one user — the old screen is restored the same day; the data is shared, so nothing is lost
What happens after the upgrade
- 1
Documentation that stays
The dependency, data and logic maps written during diagnosis are updated at the end of every stage. They are handed to you — not kept by us.
- 2
Automated tests and deployment
The upgrade leaves a mechanism behind: tests that run on every change, and deployment that does not depend on one person. That is what stops the system from drifting back into legacy.
- 3
Your team inside the work
The people who know the business logic are part of the project from day one, and the people who will maintain the system learn it along the way — not from a document at the end.
- 4
Ongoing operations
Monitoring, security updates and incident handling after the cutover are a separate service, within the scope and service hours set in the agreement. What is included and what is not — defined before starting, not after the first incident.
// 04 · Technology
Our stack
Known migration paths — from old frontend to modern cloud. With the tools that make the transition smooth.
- Frontend migration
- AngularJS → React
- jQuery → Modern JS
- Backbone → Next.js
- SSR → SPA
- Backend migration
- PHP 5/7 → Laravel
- .NET Framework → .NET 8+
- Java EE → Spring Boot
- Old Ruby/Python → modern
- Database migration
- Old MySQL → PostgreSQL
- Oracle → PostgreSQL
- MongoDB upgrades
- Cloud migration
- On-Prem → AWS
- On-Prem → GCP
- On-Prem → Azure
- Heroku → Vercel/Railway
- Tools
- AWS DMS
- Azure Migrate
- Strangler Frameworks
- Feature Flags
- Blue/Green Deploy
- Architecture
- Monolith → Microservices
- Event-driven
- API Gateway
// 05 · How we work
How we work
- 01STEP 1
Comprehensive audit
Not just the code — processes, documentation, team habits too. The whole system.
- 02STEP 2
Risk report
What's the biggest risk? Security? Operations? Maintenance? You decide what's most urgent.
- 03STEP 3
Modernization plan
A clear roadmap: what to upgrade, in what order, on what timeline, in what budget. With checkpoints along the way.
- 04STEP 4
Gradual upgrade
Sprints of 2 to 4 weeks. Each sprint — one component upgraded, tested, and shipped to production.
- 05STEP 5
Tests at every step
Not just that the new works — that the old doesn't break. Automated regression testing.
- 06STEP 6
Knowledge transfer
Your developers learn along the way. By the time the project ends — the internal team knows how to maintain it.
// 06 · Who it's for
Who this is for
- 01
Orgs with old core systems
Finance, insurance, government, healthcare — systems that need to survive another 10 years.
- 02
Companies losing developers
Whose developers leave because they don't want to work with old tech.
- 03
Businesses that can't add features
Features customers are demanding — that the current code can't support.
- 04
Anyone with a security report
That shows vulnerabilities from outdated dependencies.
- 05
Orgs with growing maintenance costs
Where maintenance costs of the existing system keep climbing.
- 06
Businesses in due diligence
Funding round, acquisition — knowing the system won't pass technical review.
// 07 · Why us
Why us
- 01
Real modernization experience
Seven years of projects behind us. We know where the landmines are.
- 02
Old and new — both sides
Our team works on AngularJS and React. On PHP 5 and Next.js. We're not stuck on one side.
- 03
Gradual improvement, not a gamble
We don't say "throw it out and start over." We help you reach 2026 without stopping the business.
- 04
Long-term partnership
Modernization takes time. We don't disappear after two months. With you to the end.
// 08 · FAQ
Frequently asked questions
01.We're on AngularJS / jQuery. Is there still hope?
Yes. Those are two of the most common cases we see. There are ways to migrate gradually to React/Next.js without breaking the existing system.
02.How much does a legacy system upgrade cost?
Depends on size and complexity. A focused upgrade (UI, backend, or DB) — $14K–$56K. A full mid-sized system upgrade — $56K–$280K. A large enterprise upgrade — $280K and up, spread over months or years.
03.How long does it take?
The upgrade timeline depends on the system's condition, the scope of the changes and its dependencies. After the assessment, we define a work plan and milestones based on the findings.
04.Is there downtime during the upgrade?
In most cases, no. We use feature flags, blue/green deployment, and the Strangler Pattern — changes roll in gradually without disruption.
05.Do we have to stop new development?
Not required. We can run in parallel — new features on the new stack, fixes on the old. Both slow down a little, but neither stops.
06.Which technologies are you strongest at migrating to?
React/Next.js for frontend, Node.js/Python/Go for backend, PostgreSQL for DB, cloud (AWS/GCP). But we adapt — sometimes staying on Java/Spring is the right call.
07.What if the internal team doesn't want the change?
It's part of the challenge and we handle it. Training, mentoring, explaining the value. Your team is brought into the project — not pushed aside.
08.We need to move to the cloud. Where do we start?
From an audit of what you have: services, dependencies, data, sensitivity. From there — pick a strategy (Lift & Shift, Replatform, or Refactor).
09.I have a system on SAP / Oracle / a niche tool. Do you handle that?
Depends. SAP, Oracle, Salesforce and the like — we work on integration and upgrades, not always full replacement (that's a specialized domain). Happy to assess.
10.If it takes a year, how do we check you're on track?
Checkpoints every sprint (2 to 4 weeks). Each sprint — a component upgraded, shipped to production, visible. No "surprises at the end."
11.We don't know if our system is "legacy" — how do we tell?
Built before 2018? Dependencies that don't update? Hard to hire developers for it? Fixes that take months instead of weeks? Probably legacy. Book a meeting — we'll look together.
12.What about documentation? There usually isn't any.
As part of the project — we create documentation. Sometimes it's the first real documentation the system has ever had. An asset in itself.
13.We want an AI-driven upgrade — replacing manual processes. Is that possible inside an upgrade?
Absolutely — and it's one of the strongest justifications for modernization. Adding AI into old workflows can save thousands of hours. We do this work.
14.What is the difference between a staged upgrade and a full rewrite, and how do you decide?
A staged upgrade replaces the system piece by piece while it keeps running; a full rewrite builds a new system beside the old one and swaps it in at once. The decision follows from the diagnosis: how much of the problem sits in parts that can be isolated, how much undocumented business logic there is, and how long the business can live with two systems. A rewrite is not our default — it is chosen when the diagnosis shows there is nothing worth preserving.
15.What does the transition plan include?
For every stage: what moves, when, who is responsible on your side and on ours, how it is verified, and how to roll back if it is not. Without the rollback clause there is no plan — only hope.
Last reviewed:
Related reading
Comparison
Vibe Coding vs production engineering — when each one fits
MVPs from Cursor/Lovable/Bolt vs production-engineered code. What AI tools handle, where they break, and how to migrate between the two.
Case study
Case study: Michrazit — order in the private-construction jungle
A two-sided tender platform: transparent comparison, vetted suppliers, digital contract. Modern web architecture with a clear path from tender to signed deal.
Service
Technology & product consulting — the decision before the build
A one-off consultation, a professional audit with a recommendations document, or ongoing CTO advisory. Architecture, code review, development and AI strategy — with no commitment to build with us.
// 09 · Let's talk
From legacy
to 2026.
A 30-minute intro call. No strings attached. We'll look at the system together, tell you what we see — and how to upgrade without taking the business down.
Straight. To the point. On time.