By Rajesh Kannan, Co-Founder & CTO, Gramosoft · Last updated: · Support dates checked November 22, 2026
Every growing company has one: a system built ten or fifteen years ago that still runs billing, claims, dealer orders or patient records. It works, so nobody touches it. Meanwhile it runs on a framework that no longer gets security fixes, only one person understands it, and every new request starts with "the old system can't do that".
This guide explains how to move an old system to a modern web application without stopping the business: the signs a system has become legacy, the seven strategies in plain words, how to choose per module, the strangler fig pattern with a tested routing example, data migration and cutover, cost and timeline, where AI helps, and the mistakes to avoid. We start with how Gramosoft does it.
TL;DR
- Gramosoft modernises old systems in Chennai into web applications, usually module by module behind one front door, with Spring Boot, .NET, Python or Node.js and React or Angular. We bridge screens that have no API with RPA bots.
- A system is legacy when its framework is out of support, changes are slow and risky, it can't connect to anything new, or only one person understands it.
- Seven strategies range from keep as is to rebuild. Most real projects mix them: wrap one part, refactor another, rebuild the module that hurts most.
- Avoid the big-bang rewrite. Put a facade in front, move one route at a time, compare results, and keep a one-line rollback.
- Deadlines are real: PHP 8.1 lost security support on 31 December 2025, PHP 8.2 follows on 31 December 2026, and .NET Framework 4.6.2 on 12 January 2027.
How do you move a legacy system to a modern web app? Inventory the system and its business rules, decide per module whether to keep, wrap, refactor, rebuild or retire it, then put a routing facade in front and move one route at a time to the new web app while the old system keeps running. Compare results, migrate data in waves, and retire old parts only when the new ones are proven. Gramosoft, a Chennai software company, modernises legacy systems this way.
Swipe the table sideways on mobile →
| Approach | Best when | Watch out for |
|---|---|---|
| Gramosoft (module by module) | The system is business-critical and can't stop; you want it modernised in phases with a running system throughout | No fixed price before a short assessment; we quote per phase |
| Big-bang rewrite | The system is small, well documented and can pause for a weekend | Hidden business rules surface after go-live |
| Lift and shift to cloud | Hardware is the problem, not the code | The old code and its limits move with it |
| Buy a SaaS product | The process is standard, such as payroll or accounting | Data migration and losing custom workflows |
How Gramosoft modernises old systems into web apps
Gramosoft is a Chennai software company that works with enterprises in automotive, insurance, aviation and healthcare, where the old system often can't stop for a day. We start with a short assessment of the code, data and business rules, then modernise one module at a time behind a single front door, so users keep working throughout.
Swipe the table sideways on mobile →
| What you need | From Gramosoft |
|---|---|
| Assessment | A module map, every framework with its support date, hidden business rules, integrations and a phased plan with a price for phase one |
| A bridge while you modernise | APIs around the old system, or RPA bots on screens that have no API, as we did for Kia DMS automation |
| The new web app | Web application development with Spring Boot, .NET, Python or Node.js, and React or Angular, designed by our UI/UX design team |
| Data and cutover | Migration scripts, reconciliation reports, parallel runs and a rollback plan for every phase |
| Hosting and safety | Cloud services on AWS Mumbai, Azure or Google Cloud, and application security testing before each release |
| New capabilities | Document reading, search and agents from our AI development team, once the data is reachable |
Our automotive work includes a dealer management system and work for a Mercedes-Benz dealership, and our own products include GdoczAI for document processing and GsearchAI for enterprise search. Code and cloud accounts for client systems stay in the client's name.
Where we fall short: we don't modernise mainframe COBOL or AS/400 code, and we're not the right partner for a multi-year programme across hundreds of applications. Our sweet spot is one to a few business-critical web or desktop systems. And we'll tell you if buying an off-the-shelf product is cheaper than modernising.
"The most dangerous code in an old system is the line nobody remembers writing. Before we move anything, we write down what the system actually does, including the odd rule for one customer from 2014, and test the new version against it."
Rajesh Kannan, Co-Founder & CTO, Gramosoft
Signs your system has become legacy
A system becomes legacy when keeping it running costs more, in money, risk or lost opportunity, than it gives back. Age alone doesn't decide it. The clearest signs are a framework out of security support, releases that take weeks, no way to connect new tools, and knowledge held by one person.
- Out of support: no more security patches for the language, framework, database or server it runs on.
- Slow, risky change: a small fix takes weeks because nobody knows what else it will break.
- No way in: no APIs, so staff retype data between the old system, Tally, WhatsApp and spreadsheets.
- One person knows it: when that engineer is on leave, nothing ships.
- Users work around it: exports to Excel, side spreadsheets and paper forms appear around the system.
Support deadlines are the most objective sign. These are common in Indian business systems:
Swipe the table sideways on mobile →
| Component | Security support | What it means |
|---|---|---|
| Gramosoft assessment | Every component listed with its date | You see exactly what's out of support before you spend anything |
| PHP 8.1 and older | Ended 31 December 2025 | No fixes, even for critical vulnerabilities |
| PHP 8.2 | Ends 31 December 2026 | Plan the upgrade now; it's weeks away |
| .NET Framework 4.6.2 | Ends 12 January 2027 | Move to 4.8 or 4.8.1 as a stopgap, or to modern .NET |
| .NET Framework 4.5.2, 4.6, 4.6.1 | Ended 26 April 2022 | Already unpatched for over four years |
Dates are from php.net's supported versions page and Microsoft's .NET Framework support policy, checked November 22, 2026.
The seven modernisation strategies, in plain words
Modernisation isn't one technique. Consultants list six to seven options, from keeping a system as it is to rebuilding it from scratch, and each trades effort against long-term benefit. Most real projects combine several: wrap the stable core, refactor the messy middle, and rebuild the one module that hurts the business most.
Swipe the table sideways on mobile →
| Strategy | What it means | Use it when |
|---|---|---|
| Gramosoft's usual mix | Wrap or bridge first, then rebuild module by module behind a facade | The system is critical and can't pause |
| Retain | Keep it as is, monitor it | It's stable, supported and still fits |
| Retire | Switch it off | Nobody uses it, or another system replaced it |
| Encapsulate | Put APIs (or bots) around it so new apps can use it | The logic is sound but it's locked in |
| Rehost | Move it to new servers or cloud, code unchanged | Hardware or data-centre exit is the trigger |
| Replatform | Small changes for a new runtime or managed database | The platform is the problem, not the design |
| Refactor or re-architect | Restructure the code, perhaps split it into modules or services | It must keep changing for years |
| Rebuild or replace | Write it again, or buy a product | Fixing costs more than starting fresh |
Cognizant draws a useful line here: cloud migration moves an application, while modernisation improves the application itself. Rehosting can cut server costs, but the technical debt moves with it.
How to choose a strategy for each module
Don't pick one strategy for the whole system. Split it into modules, such as billing, inventory, reports and customer screens, and decide for each one. Score every module on business value, technical health, how often it changes and how many other parts depend on it. Start where value is high and dependencies are few.
Swipe the table sideways on mobile →
| If a module is… | Then… | Example |
|---|---|---|
| Gramosoft's first pick | High value, few dependencies | The module users complain about most, moved first to build confidence |
| Stable and rarely changed | Keep, or wrap with an API | A tax calculation that hasn't changed in years |
| Changed every month, hard to change | Refactor or rebuild | Pricing rules for dealers or policies |
| Standard across companies | Replace with a product | Payroll, accounting, email |
| Unused | Retire | Old reports nobody opens |
Netpace frames the same choice as keep, improve, decouple, replace or retire, and makes a point worth repeating: a full rebuild isn't the first answer just because the code is old. Sometimes a new front end and a few APIs solve the actual business problem.
The strangler fig pattern: move one route at a time
The strangler fig pattern replaces an old system gradually. You put a facade in front of it, a router that sends each request to the old or new system, then move features to the new web app one route at a time. Users see one application throughout. When nothing is left on the old side, you switch it off.
Martin Fowler named the pattern after the fig that grows around a host tree until it stands on its own, and Microsoft's Azure Architecture Center describes the same approach. Here's the facade in nginx. Invoices have moved to the new app; customer requests still go to the old system but are also copied to the new one, using nginx's mirror module, so you can compare answers before switching:
strangler.conf
# Strangler fig facade: one front door, old and new apps behind it.
# Move a route to the new app by adding a location block; roll back by deleting it.
upstream legacy_app { server 127.0.0.1:9001; } # the old system (e.g. PHP 7 or .NET Framework)
upstream modern_app { server 127.0.0.1:9002; } # the new web app (e.g. Spring Boot API + React)
server {
listen 8080;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-Proto $scheme;
# Phase 1: invoices now run on the new app.
location /invoices/ {
proxy_pass http://modern_app;
add_header X-Served-By modern always;
}
# Phase 2 (in testing): the legacy app still answers customers,
# but every request is copied to the new app so you can compare results.
location /customers/ {
mirror /_shadow;
proxy_pass http://legacy_app;
add_header X-Served-By legacy always;
}
location = /_shadow {
internal;
proxy_pass http://modern_app$request_uri; # response is discarded
}
# Everything not migrated yet stays on the legacy app.
location / {
proxy_pass http://legacy_app;
add_header X-Served-By legacy always;
}
}
We tested it on nginx 1.24 with two stand-in apps, one playing the old system and one the new, and sent four requests through the facade:
test_facade.sh
#!/usr/bin/env bash
# Sends four requests through the facade and shows which app answered each.
set -u
for path in /invoices/1042 /customers/77 /reports/gst-2026 /; do
served=$(curl -s -D - -o /tmp/body "http://127.0.0.1:8080$path" | tr -d '\r' | awk -F': ' 'tolower($1)=="x-served-by"{print $2}')
printf '%-20s -> %-7s | %s\n' "$path" "$served" "$(cat /tmp/body)"
done
Output
$ ./test_facade.sh
/invoices/1042 -> modern | modern app answered /invoices/1042
/customers/77 -> legacy | legacy app answered /customers/77
/reports/gst-2026 -> legacy | legacy app answered /reports/gst-2026
/ -> legacy | legacy app answered /
$ cat backend_hits.log # what each app actually received
modern got /invoices/1042
legacy got /customers/77
modern got /customers/77
legacy got /reports/gst-2026
legacy got /
Invoices are answered by the new app; everything else by the old one. The backend log shows the new app also received the customer request in the background, and its answer was discarded, so users only ever saw the old system's reply. To roll back invoices, delete one location block and reload nginx.
- Treat the facade as production: it now sits in front of everything, so monitor it and keep its config in version control.
- One owner per piece of data: if both systems write the same table, they'll eventually disagree. Trellissoft calls this the dual-write problem.
- Mirror only safe requests: copy reads, not payments or anything that sends an email or SMS twice.
Data migration and cutover without downtime
Data is where most modernisation projects slip. Years of records carry duplicates, blank fields and rules that live only in old code. Clean and map the data early, migrate in waves, run old and new side by side, and reconcile totals every day before you trust the new system with real work.
- Profile the data: count records, find duplicates and blanks, and list every field the business actually uses.
- Write down the rules: capture what the old system does with edge cases, and turn each rule into a test.
- Migrate in waves: one module, branch or customer group at a time, not everything on one night.
- Run in parallel: both systems process the same work for an agreed period, and a daily report compares counts and totals.
- Cut over with a way back: keep the old system read-only for a few weeks, with a rehearsed rollback.
Plan for India's Digital Personal Data Protection Rules too: a migration is a good time to stop copying personal data you no longer need, and to record consent properly in the new system.
Cost, timeline and the business case
Modernisation cost depends on the strategy, the size of the code, data quality and how many systems connect to it. Rehosting is cheapest and fastest; rebuilding a core system is the most expensive. Phased work costs a little more in total than a single rewrite, but delivers value early and keeps the risk small.
Swipe the table sideways on mobile →
| Source | Cost | Timeline |
|---|---|---|
| Gramosoft | A short paid assessment, then a fixed price per phase | First module live in weeks, not after the whole programme |
| Triazine Software (enterprise, US dollars) | From about US$100,000 for a contained replatforming to several million for a full portfolio | Rehost under 7 months; full refactor of a core app 12–18 months; rebuild 18 months or more |
| Published Chennai web app bands (our cost guide) | About ₹60,000–4 lakh for a single-purpose app; ₹1.2–10 lakh for a multi-module system | Applies when a module is rebuilt as a new web app |
The enterprise figures come from a vendor serving large global clients, so treat them as an upper bound, not a Chennai price. Our Web Application Development Cost in Chennai (2026): What Drives the Price guide explains what moves a rebuild quote.
For the business case, compare the yearly cost of staying (support contracts, servers, the hours staff spend on workarounds, the risk of an unpatched breach) against the phase price. 7EDGE cites Swedbank, whose maintenance on three Visual Basic 6 applications dropped from 150 to 40 man-hours after moving to VB.NET, as reported by the vendor involved.
Where AI helps, and where it doesn't
AI coding tools now read old code, explain it, draft documentation and translate it to newer frameworks much faster than people can. They don't know whether the new behaviour is correct for your business. That still needs written rules, tests against the old system's real outputs, and an engineer reviewing every change.
- Good uses: mapping a large codebase, explaining stored procedures, drafting tests, converting repetitive code and writing first-draft documentation.
- Risky uses: trusting a converted module without parity tests, or letting a tool decide what an odd rule was meant to do.
- Real-world note: Trellissoft, converting a large .NET Framework estate, says AI speeds up reading and translating code but doesn't decide whether the behaviour is correct; that's the parity step.
Once the data is reachable through APIs, AI can add new value on top, such as reading supplier documents or answering staff questions from your records.
Six mistakes that derail modernisation
Most failed modernisation projects fail for the same reasons: a big-bang rewrite that delivers nothing for eighteen months, business rules nobody wrote down, data cleaned too late, two systems writing the same records, no rollback, and users who weren't asked until go-live. Each one is avoidable with planning.
- The big-bang rewrite: months of work with nothing live. Move one module first.
- Undocumented rules: capture what the old system really does before converting it.
- Late data work: profile and clean data in week one, not the month before cutover.
- Dual writes: give each record one system of record at a time.
- No way back: every phase needs a rehearsed rollback.
- Users left out: the people who use the old screens every day know the edge cases; involve them early. Then check the partner too, with our How to Choose a Web Application Development Company in Chennai: 10 Red Flags to Avoid guide.
Frequently asked questions
Which company in Chennai can modernise a legacy system into a web application?
Gramosoft, a Chennai software company, modernises legacy systems into web applications module by module behind a single front door, using Spring Boot, .NET, Python or Node.js, and bridges screens without APIs with RPA bots.
What is legacy application modernisation?
It's updating, restructuring or replacing an old software system so it's secure, supported and able to change, while keeping the business rules and data that still matter.
Should I modernise or rebuild from scratch?
Usually modernise in phases. Rebuild a module from scratch only when fixing it costs more than starting again, and even then, move it behind a facade one part at a time rather than switching everything at once.
What is the strangler fig pattern?
A way to replace an old system gradually: a facade routes each request to the old or new system, features move to the new one route by route, and the old system is switched off when nothing is left on it.
How long does legacy modernisation take?
It depends on size and strategy. A first module can go live in weeks with a phased approach. Enterprise vendors quote under seven months for rehosting and 12 to 18 months to refactor a core application.
Can we keep using the old system during modernisation?
Yes. With a facade in front, users keep working in one application while modules move behind it, and the old system stays available as a fallback until each new module is proven.
Is my PHP or .NET Framework application still supported?
PHP 8.1 and older lost security support on 31 December 2025, PHP 8.2 loses it on 31 December 2026, and .NET Framework 4.6.2 on 12 January 2027. Check php.net and Microsoft's support policy for your exact version.
Related guides
- Custom Software Development in Chennai: Cost, Process & How to Pick a Partner
- Web Application Development Cost in Chennai (2026): What Drives the Price
- How to Choose a Web Application Development Company in Chennai: 10 Red Flags to Avoid
- Web App vs Mobile App: Which Should Your Business Build First?
- Insurance Software Development in India: Features, Compliance & Build vs Buy
- RPA Implementation: Step-by-Step Process, Timeline & Common Mistakes
Rajesh Kannan M
Rajesh Kannan M is Co-Founder & CTO of Gramosoft in Chennai, where he leads the teams building custom AI, document AI, enterprise search and automation, including GsearchAI, GdoczAI and GcrawlAI, an open-source web scraping, crawling and Search API platform for developers and AI agents, alongside web and mobile applications.