.NET 8 is out of support: .NET 10 or .NET 11 – and how to make the upgrade boring
On 10 November 2026, Microsoft released .NET 11. On the same day, .NET 8 and .NET 9 reached end of support. After that date they get no more fixes, and that includes security updates.
If you still run services on .NET 8, you are not alone. It was the long-term support release many teams standardised on. The question now is not whether to move, but where to, and how to make the move boring.
Two targets, one end date
Microsoft now supports Standard Term Support (STS) releases for 24 months, and Long Term Support (LTS) releases for 36 months. That produces an unusual situation:
- .NET 10 (LTS), released in November 2025, is supported until November 2028
- .NET 11 (STS), released this week, is supported for two years, which also takes it to November 2028
So the old rule of thumb, "production goes LTS, STS is for early adopters", carries less weight this time. Both targets give you roughly the same runway. The difference is maturity: .NET 10 has a year of patches and ecosystem catch-up behind it, while .NET 11 has new features and a fresh set of breaking changes.
Our default for most business systems is .NET 10. It is the conservative jump, and the ecosystem has had a year to catch up with it. We would choose .NET 11 when a team has a concrete reason: a feature it needs, or a habit of moving every year anyway.
What is worth knowing in .NET 11
A few changes stand out for people who build and run business systems:
- C# 15 union types and closed hierarchies. A value can be declared as one of a fixed set of cases, and the compiler checks that a
switchhandles them all. This is a good fit for domain states, such as a case that is submitted, approved or rejected, where today we often model them with nullable fields and hope. - AI building blocks in the box. A
dotnet new mcpservertemplate, the Microsoft.Extensions.AI abstractions and Microsoft Agent Framework make it easier to expose your own systems to AI agents through the Model Context Protocol. The abstractions also make it easier to swap model providers, including models you host yourself. - Supply chain controls. The SDK adds a NuGet setting for a minimum package publication age, so a package published minutes ago is not pulled into your build automatically. Container image digests are now reproducible.
- Async validation and OpenAPI 3.2 in ASP.NET Core. OpenAPI 3.2 is now the default, which is worth knowing if you generate clients or test contracts from the spec.
- EF Core 11 requires .NET 11. If your data layer is EF Core, the runtime and data access move together.
How to make the upgrade boring
The runtime change itself is rarely the hard part. What hurts is everything around it: a package that has not been updated, a behaviour change nobody noticed, an image nobody rebuilt. What we do:
- Pin today's behaviour before you change anything. Where tests are thin, write characterisation tests for the paths that matter most to the business. They make an unexpected difference visible as a failing test rather than a support ticket.
- Read the breaking-changes list for every version you skip. Going from .NET 8 to 10 means reading the notes for 9 and 10.
- Make unsupported SDKs visible. Setting
CheckSdkVulnerabilitiesin the project file makes the build warn when it resolves an end-of-life SDK. - Upgrade dependencies deliberately. Update packages in their own commit, then change the target framework, so a failure points to a single cause.
- Rebuild every container image. A service is only upgraded when the image running in production is.
- Treat warnings as work. New analysers in a new SDK find real issues. Fix them, don't suppress them.
Using AI for the upgrade, with care
Microsoft is positioning GitHub Copilot, a .NET Upgrade canvas and new ".NET Skills" for coding agents as upgrade aids. Upgrade work suits agents well: it is repetitive, well specified and checkable. The checking is the point. An agent can change a target framework and fix compile errors quickly. It cannot know that a date now serialises differently for one integration partner unless a test says so.
So the order stays the same with or without AI: tests first, small steps, one concern per pull request, and a human who reads the diff.
Where to start this week
- List every service and job with its target framework, SDK and base image
- Flag what still runs .NET 8 or 9, and anything older
- Pick the target per system, .NET 10 by default
- Start with a low-risk service to establish the pattern, then repeat it
Sources
- Microsoft .NET Blog, "Announcing .NET 11": https://devblogs.microsoft.com/dotnet/announcing-dotnet-11/
- Microsoft Learn, ".NET releases, patches and support": https://learn.microsoft.com/dotnet/core/releases-and-support
- Microsoft Learn, "What's new in .NET 11": https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-11/overview
- Thurrott.com, "Microsoft Releases .NET 11": https://www.thurrott.com/dev/343717/microsoft-releases-net-11