.NET developer CVs carry a platform distinction problem that most candidates handle badly: .NET Framework and modern .NET are not the same platform, and they are not interchangeable on a CV. .NET Framework (versions 1.0–4.8) is Windows-only, has had no new features added since 2019, and represents a legacy estate that a huge number of UK and US enterprises are actively trying to migrate away from. Modern .NET (.NET Core through .NET 6, 7, and 8) is cross-platform, cloud-native by design, significantly higher performance, and is where all active Microsoft investment goes. A .NET developer CV that doesn't distinguish between these two — that lists ".NET" as a single skill — tells the hiring manager nothing about whether the candidate can build on the modern platform or is experienced only with legacy systems. This distinction matters immediately and should be in the headline. The second gap in most .NET CVs is the absence of architecture vocabulary: ASP.NET Core developers who build production APIs using Clean Architecture, CQRS with MediatR, and EF Core migrations are operating at a professional level that is completely invisible if the bullet just says "developed REST APIs using ASP.NET Core." This guide covers the platform, framework, and architecture vocabulary that makes a .NET developer CV accurately communicate the level of work the candidate actually does.

What .NET Developer Job Descriptions Require in 2026

.NET developer JDs split along two axes: the application domain (web API, frontend, enterprise integration, background processing) and the platform generation (modern .NET vs. .NET Framework legacy).

ASP.NET Core web API development: The most common .NET role. Building REST APIs or gRPC services using ASP.NET Core. JDs specify the .NET version (8 for greenfield, 6 for some established codebases), the ORM (Entity Framework Core being dominant, Dapper for performance-sensitive data access), the authentication pattern (JWT, OAuth 2.0 with Identity Server or Azure AD B2C), and often the architectural approach. JDs at product companies increasingly specify Clean Architecture, CQRS, or domain-driven design — these architectural patterns distinguish senior developer positions from junior ones.

Azure-integrated .NET development: .NET and Azure are the natural Microsoft pairing. Azure Functions for serverless compute, Azure Service Bus for message queuing and event-driven integration, Azure Blob Storage for file management, Azure App Service for web hosting, Azure DevOps for CI/CD pipelines. .NET developers with Azure-specific services experience are preferred at enterprise organisations running on the Microsoft stack.

Blazor development: Using C# for web UI via Blazor — either WebAssembly (client-side, runs in browser) or Server (server-side, real-time updates via SignalR). A growing requirement at organisations that want full-stack development in C# without switching to JavaScript frameworks. Relatively rare compared to ASP.NET Core API work but specifically sought where it's needed.

Legacy .NET Framework maintenance and migration: A significant portion of the enterprise .NET market is .NET Framework 4.7.2 or earlier — Windows-only, IIS-hosted, often monolithic. JDs for these roles require .NET Framework knowledge alongside a migration roadmap capability: the ability to assess a legacy codebase for .NET upgrade readiness and plan an incremental migration to modern .NET.

Cross-application requirements: C# proficiency (not just syntax familiarity but language feature depth — records, pattern matching, async/await correctness, span vs. array for performance scenarios), SQL Server and T-SQL, Git, unit testing (xUnit preferred, NUnit or MSTest also common), and Docker for containerisation. LINQ is assumed for any EF Core role.

.NET developer salaries in 2026: £40K–£70K UK; £65K–£100K for senior. US: $90K–$145K; $120K–$175K for senior Azure-integrated platform roles.

ATS Keywords for a .NET Developer Resume

.NET ATS filtering uses framework names, platform version identifiers, and Azure service names. ".NET experience" as a standalone claim is significantly weaker than specific version and framework names.

Essential ATS terms for a .NET developer resume:

  • Title variants: .NET Developer, C# Developer, ASP.NET Developer, .NET Engineer, Senior .NET Developer, .NET Core Developer, C# Software Engineer, .NET Backend Developer, Full Stack .NET Developer
  • Platform versions: .NET, .NET 8, .NET 6, .NET Core, ASP.NET Core, .NET Framework (legacy signal), C#, C# 12
  • Web frameworks: ASP.NET Core, ASP.NET MVC, Web API, Minimal API, Razor Pages, Blazor, Blazor WebAssembly, Blazor Server, SignalR
  • ORM and data access: Entity Framework Core, EF Core, LINQ, Dapper, ADO.NET, SQL Server, T-SQL, Azure SQL, PostgreSQL, MongoDB, Redis, Cosmos DB
  • Architecture: Clean Architecture, CQRS, MediatR, DDD, domain-driven design, repository pattern, dependency injection, microservices, event-driven, SOLID
  • Azure services: Azure, Azure Functions, Azure Service Bus, Azure App Service, Azure Blob Storage, Azure AD, Azure DevOps, Azure Container Apps, Azure API Management
  • Testing: xUnit, NUnit, MSTest, Moq, FakeItEasy, FluentAssertions, unit testing, integration testing, BenchmarkDotNet
  • DevOps: Docker, Kubernetes, CI/CD, GitHub Actions, Azure Pipelines, NuGet, YAML
  • Tools: Visual Studio, VS Code, Rider, Git, ReSharper
  • Long-tail phrases: .NET developer resume, C# developer resume, ASP.NET developer resume, how to write a .NET developer resume, .NET 8 developer cv, senior C# developer resume, .NET Core developer resume

Placement: ".NET 8" or "ASP.NET Core" explicitly in the headline — not just ".NET" — to distinguish modern platform experience from legacy Framework. Azure service names (Azure Functions, Azure Service Bus) if relevant, in Skills or headline. Architecture pattern (Clean Architecture, CQRS) in the first experience bullet where it applies — this is the seniority signal that ".NET developer" alone doesn't carry.

.NET Developer CV Structure and Bullets That Show Modern Platform and Architecture Depth

Section order:

  1. Headline — ".NET Developer | C# · ASP.NET Core 8 · Azure · Clean Architecture · CQRS · EF Core"
  2. Skills — Languages / Web Frameworks / Architecture / Data Access / Azure Services / Testing / DevOps
  3. Experience — 4–5 bullets per role; platform version, architecture pattern, and performance/reliability outcome per bullet
  4. Projects — significant open-source .NET contributions, GitHub repos with meaningful C# code, or personal API/Blazor projects; link to GitHub

Two pages for 4+ years. Every experience bullet should name the .NET version and the architecture approach — not just "built an API" but "built a Clean Architecture ASP.NET Core 8 API using CQRS and MediatR." Performance numbers (response time, throughput) or reliability figures (uptime, message processing volume) where they exist.

Three elements make a .NET developer bullet convincing: the .NET version and architecture pattern used, the system built and its scale (concurrent users, data volume, message throughput), and the measurable performance or reliability outcome. Three examples:

  • Designed a Clean Architecture ASP.NET Core 8 REST API backend for a B2B e-commerce platform — CQRS implemented with MediatR, EF Core 8 with SQL Server for primary data, Redis distributed caching for product catalogue reads, JWT authentication with refresh token rotation; API sustains 3,200 concurrent users at 42ms P99 response time measured via k6 load testing
  • Migrated a 200KLOC .NET Framework 4.7.2 monolith to .NET 8 using a strangler fig pattern — analysed 340 NuGet packages for .NET 8 compatibility, migrated incrementally over 6 months to maintain production availability throughout; final state: 22 microservices running on .NET 8, 4 Azure Functions for background processing, zero production downtime during migration
  • Implemented an event-driven integration between Dynamics 365 CE and a legacy on-premise order management system via Azure Service Bus — 4 message types, dead-letter queue with automated Slack alerting, and an idempotent consumer designed for Azure Service Bus at-least-once delivery semantics; zero message loss across 14 months of production operation processing 8,000 messages per day

.NET developer interviews include C# knowledge questions (explain async/await, when would you use ValueTask vs Task, what is the difference between IEnumerable and IQueryable), architecture scenarios (design this API endpoint using Clean Architecture), and sometimes a live coding exercise. Your CV's architecture vocabulary determines whether the interview tests your C# depth or your system design judgment.

Three .NET Developer CV Mistakes That Blur the Framework Version Signal

".NET" listed without version or framework distinction. "Experienced .NET developer with 8 years of .NET experience" could mean 8 years on .NET Framework 1.1 through 4.7.2, 8 years on modern .NET Core/.NET 8, or a mixture. These are different value propositions to different employers. An enterprise organisation looking to modernise its .NET Framework 4.7 estate wants a developer who knows both and can plan the migration. A greenfield product company wants a developer who knows .NET 8, ASP.NET Core Minimal API, and Azure Container Apps. Name the specific version in the headline and in each role's bullets: "ASP.NET Core 8", ".NET 6 (LTS)", ".NET Framework 4.7.2 (legacy maintenance and migration)" — these strings carry information that ".NET" does not.

Architecture vocabulary absent. "Developed REST APIs using ASP.NET Core" describes 80% of C# developers applying for backend roles. "Implemented a Clean Architecture API using CQRS with MediatR, FluentValidation at the command level, and EF Core with repository pattern for data access" describes a developer who designs systems, not just builds endpoints. Architecture patterns (Clean Architecture, Onion Architecture, hexagonal architecture, vertical slice architecture) and integration patterns (CQRS, event sourcing, saga pattern) are the seniority signals that distinguish senior .NET engineers from mid-level developers. If you use these patterns — and most experienced .NET developers do — name them explicitly in your experience bullets.

Testing framework absent. .NET development in professional teams is tested — xUnit is the most widely used test framework, followed by NUnit; Moq or FakeItEasy for mocking; FluentAssertions for readable assertions. A .NET developer CV with no mention of any testing framework, no test coverage percentages, and no reference to unit or integration testing signals someone who doesn't write tests — which is a risk signal for any team with a CI/CD pipeline that runs tests on every commit. Name your testing framework, your approximate coverage level on significant projects, and any test-driven development approach you use. This is table stakes for senior .NET roles and a differentiator for mid-level ones.

If you are applying to .NET developer or C# engineer roles and want your CV rebuilt around the specific ASP.NET Core, Azure, and architecture requirements in a target job description, Resumegpt generates your .NET developer CV from your work history in under 60 seconds — modern .NET platform evidenced, architecture depth named, testing practices signalled, ATS-optimised, and exported as a PDF ready to submit.