What is new in .NET 11, and should you move from .NET 10?
A fair tour of .NET 11 and C# 15 as released on 10 November 2026, the breaking changes to read first, and a decision guide for production teams on .NET 10.
· 7 min readA week-by-week plan for your first month with an inherited .NET application: access, a clean build, backups, tests, releases and monitoring.

You have been handed a .NET application. Perhaps you are the IT manager who has inherited it, the one developer left in the building, or the support company that has looked after the server for years and has now been asked to look after the code as well. There is little or no documentation, and the person who understood it has moved on.
It is a common position, and a manageable one. The temptation is to start reading code and fixing things. A better first month is quieter than that: get control of the code, prove you can build and restore it, put a safety net around the riskiest parts, and make sure you hear about problems before users do.
This is the order we follow when we take on a system through software care. Tool details are as of November 2026.
By the end of week four, aim to be able to say yes to each of these:
None of these involves changing what the application does. That comes later, and it goes much better once these are in place.
Start with access. List every place the application lives: the code repository, the servers or Azure subscription, the database, DNS, certificates, third-party services such as email or payment providers, and any scheduled tasks. For each one, note who holds the login and whether it belongs to the organisation or to a person. Credentials held by the previous developer should be moved to accounts the organisation controls and then rotated. Our earlier article on the first week after a developer leaves covers this from the business side.
Get the code into source control. If it is already in Git, make sure the repository sits in the organisation's own account. If it is not, the first commit is whatever is running in production, which may differ from the copy on someone's machine. Where you have both, compare them before choosing.
Build it on a clean machine. This is the single most revealing exercise of the month. A fresh virtual machine or container, the documented tools, and nothing else. Every time the build fails, write down what was missing. Those notes become the start of your build instructions.
For modern .NET (Core, 5 and later), the SDK version matters. A global.json file in the repository pins it, which saves a lot of "works on my machine" confusion. The global.json documentation explains the roll-forward options; a typical choice for an application on .NET 10 is:
{
"sdk": {
"version": "10.0.100",
"rollForward": "latestFeature"
}
}
Older .NET Framework applications often use the pre-SDK project format, and usually need Visual Studio or the Visual Studio Build Tools on Windows rather than the dotnet command alone. That is fine. Just record it.
Take an inventory. You want to know, on one page:
<TargetFramework> in modern project files, <TargetFrameworkVersion> in older ones; it may also be set once for the whole solution in a Directory.Build.props file)The .NET CLI does much of the package work. From the .NET 10 SDK the command is dotnet package list; on the .NET 9 SDK or earlier it is dotnet list package. The command documentation lists the options. An illustrative first pass on a modern solution:
# Find target frameworks, including any set in shared Directory.Build files
grep -rhoE "<TargetFramework(s|Version)?>[^<]+" \
--include=*.csproj --include=Directory.Build.props --include=Directory.Build.targets . \
| sort | uniq -c
# Packages with known vulnerabilities, including transitive ones
dotnet package list --vulnerable --include-transitive
# Deprecated packages, then outdated ones
dotnet package list --deprecated
dotnet package list --outdated
Then check each target framework against Microsoft's .NET support policy. As of November 2026, .NET 8 and .NET 9 reached end of support on 10 November 2026, and .NET 10 (long-term support) and .NET 11 (standard-term support) are both supported until 14 November 2028. If you find an older version, our articles on what out of support means and upgrading from .NET 8 to .NET 10 are the next reading. For .NET Framework, see still on .NET Framework?.
Build a production-like environment. Same framework, same hosting model, a copy of the configuration with production secrets replaced, and a database with realistic structure. If you copy production data, think about UK GDPR first: mask or remove personal data unless you have a clear reason and the right controls to keep it.
Restore a backup. Most systems have backups. Fewer have had one restored. Take the most recent production backup, restore it into your new environment, point the application at it and check it works. Time the whole thing. That number is your realistic recovery time, and it is worth more than any statement in a contract.
While you are there, check what the backup covers. Databases are usually included. Uploaded files, certificates, configuration and scheduled jobs are often forgotten.
Add characterisation tests. With no tests and no specification, you cannot easily say what the application should do. You can record what it does today. Characterisation tests do exactly that, and our article on adding tests to code nobody dares change walks through the technique in C#.
Do not aim for coverage. Aim for the paths where a mistake costs most: money calculations, integrations with other systems, and whatever users rely on daily. A few dozen well-chosen tests are a real safety net.
Make the build and release repeatable. Put the build steps you wrote in week one into a pipeline: GitHub Actions, Azure Pipelines or whatever the organisation already uses. (We are a Microsoft partner and supply Microsoft licences, but the right tool here is usually the one the team already has.) Every change should build, run the tests and produce one versioned artefact. Releasing should mean deploying that artefact, ideally to your new environment first and then to production, with a written way to roll back.
If releases currently involve copying files to a server by hand, do not try to automate everything at once. Write down the manual steps exactly, follow them for the next release, then automate one step at a time.
Make sure you hear about failures. At a minimum, something outside the application should check every few minutes that it responds, and alert a named person if it does not. For ASP.NET Core applications, the built-in health checks give a monitoring service something reliable to call:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHealthChecks();
var app = builder.Build();
app.MapHealthChecks("/healthz");
app.Run();
That basic check only confirms the application can answer. Microsoft's documentation shows how to add checks for the database and other dependencies. Add error logging and alerts on unusual error rates too, and keep personal data out of the logs. Our article on monitoring and alerting goes further.
Write a short runbook. How to build, release and roll back. How to restart the application. Where the logs are. Who to call for each external service. Keep it in the repository, next to the code, so it changes when the code does.
Rank the risks. By now you will have a list: an unsupported framework, vulnerable packages, an untested integration, a certificate expiring in March, a scheduled task nobody understands. Rank each by likelihood and impact, and give each a proposed action. This is the document the organisation's management will actually read, so write it in plain English.
The exception is security. A known vulnerability that is exposed to the internet, or a credential that a former developer still holds, is dealt with straight away.
Keep a running notes file in the repository from day one. Every surprise, every missing step, every "why does it do that?" goes in. By the end of the month, much of your documentation is already written.
Some questions will not have answers yet. Perhaps nobody knows what a particular nightly job does, or whether a data export is still used. Say so, in the risk list, rather than guessing. "Unknown, being investigated" is an honest and useful status.
AI coding assistants, such as GitHub Copilot, Claude Code, Cursor and others, can help here: summarising an unfamiliar class, tracing where a method is called from or drafting the first characterisation tests. Treat what they produce as a draft that a person checks. Before you use one on inherited code, check the organisation's policy, and keep secrets and customer data out of what you share with it.
This week, try to build the application on a clean machine, and write down every step and every missing piece as you go. Alongside it, start an access list: every system the application touches and who holds the login. Those two documents will tell you more about where you stand than a week of reading code.
If you would like an independent view first, our software health audit is a fixed-price, one-week review of one system, and our software care service takes systems on in this same order.

A fair tour of .NET 11 and C# 15 as released on 10 November 2026, the breaking changes to read first, and a decision guide for production teams on .NET 10.
· 7 min read
As of 10 November 2026, .NET 8 and .NET 9 no longer get security fixes. What has changed, what has not, and a calm 30-day plan for software on them.
· 4 min read
How a non-technical owner can decide what comes first on a product roadmap: plain criteria, simple scoring, outcome-based thinking, and saying no with reasons.
· 6 min read