Select Page

Release analysis · November 12, 2026

.NET 11 shipped on November 10, 2026. For an existing application, the useful question is which changes you can deploy together with a recoverable release. This checklist turns the release into a sequence of decisions: lifecycle, dependencies, hardware, build, behavior and rollout.

Checked November 12, 2026. This is a planning guide, not a report of an application migration we executed. Microsoft’s release announcement confirms general availability; experimental capabilities within the release still need separate evaluation.

Choose the supported destination

Microsoft’s support table lists .NET 11 as STS and .NET 10 as LTS. Both currently have a November 14, 2028 end date. .NET 8 and .NET 9 reached end of support on November 10, 2026. Keeping current with servicing patches is part of remaining supported.

Write down why the application needs 11: a specific API, a language feature, or a measured runtime benefit. If the dependency stack is ready for 10 but not 11, assess 10 as an interim destination. A runtime lifecycle decision should include the database provider, hosting environment and workload lifecycle. A missing compatible provider is a concrete blocker; a general desire to stay current is not a substitute for resolving it.

Capture a baseline that another developer can reproduce

Before editing project files, record the deployed commit, SDK selection, target frameworks, direct and transitive package versions, container image identity and deployment mode. Save the release artifact you would restore if the upgrade fails. Record normal startup behavior, representative request latency, memory under load, and error rate using your existing monitoring.

Choose a small set of real business journeys. For a shop, that might be login, product lookup, checkout, payment reconciliation and order export. Include background jobs and command-line maintenance utilities: an HTTP smoke test can pass while a scheduled worker is broken. Set acceptance criteria before collecting new measurements so an attractive headline benchmark does not redefine success.

Check hardware before the first deployment

The runtime documentation raises the x86/x64 minimum baseline to x86-64-v2. It separately changes ReadyToRun targets on Windows and Linux to x86-64-v3, which can affect startup on supported machines with fewer instructions. Windows Arm64 also has an updated baseline; Linux and Apple have different rules.

Inventory actual production machines and the CPU features exposed by virtual machines. A successful build on a new laptop says little about an older host or a restricted virtual CPU configuration. A container shares the host CPU: changing its base image cannot supply missing instructions. Include disaster-recovery hosts and spare worker machines in this check, since they are often older than the primary fleet.

Upgrade the build environment as a unit

Update SDK selection, development tooling, CI agents, project targets and deployment runtime in a controlled branch. Preserve platform-specific target suffixes. Installing an SDK alone does not retarget an application, as Microsoft’s announcement explains. Review workload requirements separately for mobile and desktop projects.

Restore from a clean checkout on CI before trusting a developer machine’s result. Check generated source, analyzers, private package feeds, build tasks and publish tools. Keep package-resolution evidence with the build artifact. When a dependency fails, isolate the smallest project that reproduces the failure rather than changing several unrelated packages and losing the cause.

Treat behavior changes as test cases

Use the .NET 11 compatibility catalog as one triage input. Microsoft marks this catalog as incomplete. Also review the separate ASP.NET Core 11 breaking changes and EF Core 11 breaking changes for applications using those components. Assign entries to components you actually use, record irrelevant entries as such, and link relevant ones to a test or an explicit review decision. Read changes for intermediate releases too when moving from an older framework.

For a data-heavy service, compare returned results and generated SQL on representative data. For a web API, compare status codes, response shapes, authentication flows and generated client behavior. For command-line programs, compare exit codes and stdout/stderr separately. Exercise timeouts, cancellation, malformed input and shutdown paths, not only successful requests.

Keep optional experiments in separate changes

A framework upgrade already changes many moving parts. Introduce optional compiler flags, publishing modes and newly experimental packages through separate branches with their own acceptance criteria. That makes failures attributable and rollback smaller. Document who owns removing an experiment if a later servicing update changes its behavior.

Performance claims need the same workload, hardware, dataset, warmup and publishing configuration on both sides. Record the distribution of results rather than one best run. If the goal is startup, measure a fresh process. If the goal is server throughput, ensure the database or load generator is not masking the effect.

Make the rollback cover data too

Deploy to a small traffic slice first and watch the agreed signals. Keep schema changes backward compatible while old and new application instances overlap. Restoring an old executable will not reverse a destructive migration or recover discarded data. Test the restoration process before relying on it during an incident.

The release is ready when the team can identify the exact artifact, explain compatibility decisions, demonstrate its critical journeys and restore service. Follow this with a scheduled servicing review; a successful major upgrade does not finish runtime maintenance.

Share This