.NET & C#

In one line: Modern .NET (with C#) is Microsoft's reinvented platform — now open-source, cross-platform, and genuinely fast — and it's the natural backend choice wherever an organization already lives in the Microsoft ecosystem (Azure, Active Directory, Office, Windows), occupying much the same enterprise niche as the JVM.

In plain English

.NET is to the Microsoft world what the JVM is to the broader enterprise world. C# is its primary language — a modern, statically-typed language that's evolved into one of the most pleasant mainstream languages to write. The crucial thing to know is that .NET reinvented itself: the old ".NET Framework" was Windows-only and proprietary; modern .NET (formerly ".NET Core") is open-source, runs on Linux and Mac, performs excellently, and is fully competitive with the JVM and Node. ASP.NET Core is its web framework. You'll find .NET most often where a company is already a "Microsoft shop" — using Azure, Active Directory, Windows servers, the Office stack — because the integration is seamless and the tooling (Visual Studio) is best-in-class. For a web developer, C# will feel familiar coming from TypeScript (they share a designer and many ideas), and "comfortable in .NET" opens a large, well-paid slice of the enterprise market.

The reinvention you need to know about

The single most important fact, because it corrects a common outdated impression:

• Old (.NET Framework): Windows-only, proprietary, the thing people remember disliking.
• Modern (.NET, née .NET Core, now just ".NET**"):** open-source, cross-platform (Linux/Mac/Windows), high-performance, cloud-native. This is what "doing .NET" means today, and it competes head-to-head with the JVM and Node on the merits.

So "we run .NET" no longer implies Windows servers or vendor lock-in. Modern .NET services routinely run in Linux containers on any cloud.

C# and ASP.NET Core

C# is statically typed, expressive, and consistently gains modern features (records, pattern matching, nullable reference types, async/await — which C# popularized). ASP.NET Core offers both a structured MVC/controller style and a concise "minimal API" style:

// ASP.NET Core minimal API — concise, fast, and strongly typed.
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<AppDb>();        // dependency injection built in
var app = builder.Build();

app.MapGet("/api/orders/{id}", async (long id, AppDb db) =>
    await db.Orders.FindAsync(id) is Order o
        ? Results.Ok(o)
        : Results.NotFound());

app.MapPost("/api/orders", async (CreateOrder req, AppDb db) => {
    var order = new Order(req.Items);
    db.Orders.Add(order);
    await db.SaveChangesAsync();
    return Results.Created($"/api/orders/{order.Id}", order);
});

app.Run();

Notable ecosystem pieces: Entity Framework Core (the standard ORM), first-class dependency injection built into the framework, and tight integration with Azure and Microsoft identity. The developer experience in Visual Studio (and the lighter VS Code + C# Dev Kit) is widely considered among the best in any ecosystem.

Highlight: pick .NET when you have Microsoft gravity — the integration is the value

The clearest signal that .NET is the right call is existing Microsoft-ecosystem gravity: you're on Azure, your identity is Active Directory / Entra ID, your org runs Windows and Office, your team knows C#. In that context, .NET isn't just "a good backend platform" — it's the one that disappears into your existing infrastructure: native Azure integration, seamless AD authentication, unified tooling. That integration advantage is the same logic as choosing Azure as your cloud — the platform that fits your existing world out-ships the marginally-different alternative. Absent that gravity, .NET is still an excellent, fast, cross-platform choice on the merits; with it, it's usually the obvious one. Conversely, a startup with no Microsoft footprint and a JavaScript team has little reason to reach for it over Node — not because it's worse, but because the integration advantage that makes it shine isn't there.

How it compares

.NET sits in the same broad niche as the JVM — statically typed, fast, mature, enterprise-grade, strong tooling — and the choice between them is usually about ecosystem gravity (Microsoft shop → .NET; broader/Java-heritage enterprise → JVM) more than raw capability. Versus Node/TypeScript, the tradeoffs mirror the JVM comparison: .NET brings static typing, true multi-threading, and strong performance for long-running and CPU-bound work, while Node wins on full-stack JS code sharing, fast startup for serverless, and startup-velocity. Modern .NET's performance is genuinely excellent — frequently at or near the top of mainstream backend benchmarks.

Common mistakes

Where people commonly trip up

• Thinking .NET is still Windows-only/proprietary. Modern .NET is open-source and cross-platform; it runs in Linux containers on any cloud. Update the mental model.
• Choosing .NET without Microsoft gravity. Its biggest edge is seamless Azure/AD/Office integration; absent that, a JS team has little reason to prefer it over Node. Pick it for the integration, not by default.
• Confusing ".NET Framework" with modern ".NET." They're different; new work targets modern .NET. Legacy .NET Framework apps are a separate (Windows-bound) world.
• Assuming it's slow because it's enterprise. Modern .NET is one of the fastest mainstream backends; performance is a strength, not a concern.
• Overlooking how familiar C# is from TypeScript. They share a designer and many concepts; a TS developer ramps on C# faster than they expect.

Page checkpoint

Checkpoint Quiz

Did the .NET ecosystem stick?

Required

What's next

→ Continue to Go — a deliberately different philosophy: radical simplicity and built-in concurrency for cloud-native services.