Users Pricing

articles

Home Articles How to Plan a Legacy .NET Framework to Modern .NET Migration – MindStick
How to Plan a Legacy .NET Framework to Modern .NET Migration

How to Plan a Legacy .NET Framework to Modern .NET Migration

Sofia Rodriguez 11 19 Nov 2026

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

BenefitWhat it means in practice
PerformanceModern ASP.NET Core is significantly faster, often reducing server costs
Hosting flexibilityRun on Linux, in containers, or on cheaper cloud instances
SecurityCurrent libraries and frameworks receive active updates
Developer hiringNew developers learn modern .NET, not Web Forms
Modern featuresMinimal APIs, built-in dependency injection, better tooling, AI libraries
Long-term supportA 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.Web dependencies (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.

StrategyRiskTime to valueTypical use
In-place upgradeMediumMediumMVC, Web API, libraries
IncrementalLow–mediumFast, continuousLarge business-critical apps
RewriteHighSlowWeb 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

  1. Underestimating Web Forms complexity. ViewState, code-behind logic and third-party UI controls take time to replace.
  2. Ignoring hidden dependencies, like COM components, scheduled tasks or registry settings.
  3. Big-bang releases. Migrating everything at once multiplies risk.
  4. Skipping performance testing. New code paths can behave differently under load.
  5. Not upskilling the team. Dependency injection, middleware and configuration in ASP.NET Core are different from classic ASP.NET.
  6. 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

PhaseDuration (indicative)
Assessment and planning2–4 weeks
Test coverage for critical paths3–6 weeks
Shared libraries ported2–4 weeks
Incremental migration of modules3–9 months
Decommission legacy app2–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.


Sofia Rodriguez

Staff Software Engineer at Adobe

Staff Software Engineer at Adobe with 10 years of experience in backend services and distributed systems. Before that I was a Software Engineer at Apple. B.S. in Computer Science, Stanford University. Based in San Jose, California. In my spare time you will find me reading.


Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md