Many Indian businesses still run critical applications on .NET Framework: ERP modules, billing systems, government portals, HR applications and internal tools built with ASP.NET Web Forms, MVC 5, WCF services and Windows services. They work. They’ve worked for years. So why touch them?
Because the platform underneath them has stopped moving forward.
Where things stand (November 2026)
- .NET Framework 4.8/4.8.1 is the final major version of .NET Framework. It’s still supported as part of Windows, but Microsoft has said it won’t receive major new features.
- Modern .NET has moved on: .NET 10, released in November 2025, is a Long Term Support (LTS) release supported until November 2028.
- .NET 8 and .NET 9 reached end of support on 10 November 2026, so teams that migrated earlier to those versions now need to retarget to .NET 10.
The practical message: .NET Framework apps won’t stop working tomorrow, but they’re cut off from performance improvements, cross-platform hosting, containers, modern libraries and a growing talent pool. The longer you wait, the more expensive the move becomes.
Why migrate? The business case
| Benefit | What it means in practice |
|---|---|
| Performance | Modern ASP.NET Core is significantly faster, often reducing server costs |
| Hosting flexibility | Run on Linux, in containers, or on cheaper cloud instances |
| Security | Current libraries and frameworks receive active updates |
| Developer hiring | New developers learn modern .NET, not Web Forms |
| Modern features | Minimal APIs, built-in dependency injection, better tooling, AI libraries |
| Long-term support | A clear LTS roadmap instead of a frozen platform |
Step 1: Assess what you have
Before writing a line of code, take inventory.
Application types:
- ASP.NET Web Forms (no direct equivalent in modern .NET)
- ASP.NET MVC 5 and Web API 2 (map well to ASP.NET Core)
- WCF services (server-side WCF isn’t in modern .NET; CoreWCF is a community option, or migrate to gRPC/REST)
- Windows Services (move to the Worker Service template)
- Class libraries (often the easiest to port)
- WinForms/WPF desktop apps (supported on modern .NET, Windows only)
Dependencies:
- Third-party NuGet packages and whether modern versions exist
- Direct Windows API usage, COM components, registry access
System.Webdependencies (a key blocker)- Old data access approaches (ADO.NET is fine; some older ORMs need upgrading)
- Authentication (Forms Authentication, Windows Authentication, Membership providers)
Tools like the .NET Upgrade Assistant and API compatibility analysis can help identify blockers.
Step 2: Choose a migration strategy
Option A: In-place upgrade
Upgrade project files, libraries and code within the same codebase.
Best for: MVC/Web API apps, class libraries and services with moderate dependencies.
Option B: Incremental migration (strangler fig)
Run the old app and a new ASP.NET Core app side by side. Route specific URLs or features to the new app as they’re migrated, often using a reverse proxy such as YARP.
Best for: large applications that can’t stop for a big rewrite.
Option C: Rewrite
Rebuild the application using modern .NET, often with a new UI.
Best for: Web Forms apps with heavy UI logic, poorly documented systems, or apps whose business processes have changed significantly.
| Strategy | Risk | Time to value | Typical use |
|---|---|---|---|
| In-place upgrade | Medium | Medium | MVC, Web API, libraries |
| Incremental | Low–medium | Fast, continuous | Large business-critical apps |
| Rewrite | High | Slow | Web Forms, outdated designs |
Step 3: Handle the hard parts
Web Forms
There’s no Web Forms in modern .NET. Common paths:
- rebuild pages in Razor Pages or MVC
- move to Blazor for component-based UI
- build a separate front end (React, Angular) with an ASP.NET Core API
Migrate page by page, starting with the least complex or most-used screens.
WCF
- For services consumed only internally, consider gRPC or REST APIs.
- If many clients depend on SOAP contracts, CoreWCF can help preserve compatibility.
- WCF client libraries are available for modern .NET, so consuming existing SOAP services is easier than hosting them.
Authentication
Replace Forms Authentication and Membership with ASP.NET Core Identity, cookie authentication, or an external identity provider using OpenID Connect.
Configuration
web.config app settings move to appsettings.json, environment variables and secret stores. Don’t carry production passwords into source control during the move.
Session and caching
ASP.NET Core session works differently. Plan for distributed caching (like Redis) if you run multiple servers.
Step 4: Port shared code first
Move class libraries containing business logic to .NET Standard 2.0 (if they must be shared temporarily with the old app) or directly to .NET 10. This lets both old and new applications use the same logic during an incremental migration.
Step 5: Build a safety net of tests
Legacy apps often have few automated tests. Before migrating:
- write characterisation tests that capture current behaviour, even if it’s quirky
- add API tests for key endpoints
- create end-to-end tests for critical user journeys: login, billing, reports
- compare outputs between old and new systems for the same inputs
Step 6: Plan deployment
- Decide on hosting: IIS with the ASP.NET Core Hosting Bundle, Linux, containers, or a managed cloud service.
- Set up CI/CD for the new application.
- Plan database changes carefully. Often, the database stays the same during application migration.
- Prepare rollback plans for each release.
Common pitfalls
- Underestimating Web Forms complexity. ViewState, code-behind logic and third-party UI controls take time to replace.
- Ignoring hidden dependencies, like COM components, scheduled tasks or registry settings.
- Big-bang releases. Migrating everything at once multiplies risk.
- Skipping performance testing. New code paths can behave differently under load.
- Not upskilling the team. Dependency injection, middleware and configuration in ASP.NET Core are different from classic ASP.NET.
- Migrating to an out-of-support version. Target the current LTS (.NET 10) unless you have a specific reason not to.
A sample timeline for a mid-sized app
| Phase | Duration (indicative) |
|---|---|
| Assessment and planning | 2–4 weeks |
| Test coverage for critical paths | 3–6 weeks |
| Shared libraries ported | 2–4 weeks |
| Incremental migration of modules | 3–9 months |
| Decommission legacy app | 2–4 weeks |
Actual timelines vary widely with size, complexity and team experience.
Before you decide
Migrating from .NET Framework is less about rewriting code and more about managing risk. Assess honestly, choose the right strategy for each part of the system, build tests first and migrate in small, reversible steps.
Done well, the reward is faster software, cheaper hosting, a modern developer experience and a platform with a clear future through at least 2028, and beyond as you follow the LTS releases.
Leave a Comment