Taking over someone else's .NET application: a first-month plan

A week-by-week plan for your first month with an inherited .NET application: access, a clean build, backups, tests, releases and monitoring.

Two engineers talk across a long oak desk with two plain grey laptops in a bright first-floor office, a market-town street of brick houses visible through the sash window behind them

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.

What "done" looks like after a month

By the end of week four, aim to be able to say yes to each of these:

  • The code is in source control the organisation owns, and nobody depends on one person's laptop
  • You can build it from scratch on a clean machine, by following written steps
  • There is a production-like environment where you can try things safely
  • You have restored a backup and know how long it took
  • The riskiest behaviour is covered by tests that run on every change
  • A release is a repeatable process, not an afternoon of remembered steps
  • Someone is alerted when the application fails
  • There is a short runbook and a ranked list of risks

None of these involves changing what the application does. That comes later, and it goes much better once these are in place.

Week 1: access, source control and a clean build

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:

  • each project and its target framework (<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 NuGet packages, including those pulled in indirectly
  • where it is hosted, how it is configured and where its secrets are kept
  • what it talks to: databases, file shares, APIs, email

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?.

Week 2: somewhere safe to work, and a backup you have restored

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.

Week 3: tests on the riskiest paths, and a repeatable release

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.

Week 4: monitoring, a runbook and a ranked list of risks

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.

What to leave alone in the first month

  • Refactoring. However tempting, wait until the tests are in place
  • Framework upgrades. Plan them now, do them next month, with the safety net ready
  • Odd-looking code that works. It is often a fix for a problem nobody wrote down. Record it, and ask about it later
  • New features. If something urgent comes up, make the smallest change you can, test it and release it through your new process

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.

Write it down as you go, and be honest about unknowns

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.

A sensible first step

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.