What’s new in .NET 10

Every time .NET releases a new version, our Slack lights up with opinions and – sometimes – sighs of relief over long-awaited features. No wonder – .NET is Happy Team’s main stack, and we always want to be among the first to make the most of it.

It’s been a few months since the release of .NET 10 (November 2025, as a Long-Term Support version), so it’s time to take a closer look at what’s actually in it for teams like ours: focused on engineering excellence and working closely with clients in logistics, eMobility, and eCommerce.

Faster systems

.NET 10 brings another round of runtime improvements: better memory handling, smarter JIT optimisations, and less pressure on the garbage collector.

You feel the change when the system is under load:

• New Dynamic Adaptation to Application Size (DATAS) reduces memory usage for idle services (often by tens of per cent). In practice, you can run more instances on the same VM or container, which adds up quickly on Azure/AWS bills.
• Improved escape analysis means more objects stay on the stack instead of the heap. This matters when you’re processing thousands of tracking events or shipment updates per second.
• Further improvements to Native AOT and startup performance bring cold starts down to tens of milliseconds. When traffic spikes, new instances can spin up fast enough that users don’t notice.

Stricter JSON

If you work with multiple carriers and external APIs, you’ve probably seen cases where the payload is technically “valid” but contains duplicated or inconsistent fields, and the system quietly picks the wrong value. That kind of issue is hard to spot and even harder to trace back.

New options in System.Text.Json allow you to fail deserialisation when duplicate properties appear or when the payload doesn’t match the expected structure. Instead of letting incorrect data flow through the system, you can now stop it before it reaches your database or business logic.

In practice, this means fewer “ghost bugs” caused by bad payloads – in logistics or eMobility, where a single wrong TrackingId or status update can break a workflow, this kind of fail-fast behaviour makes a real difference.

Validation

The new APIs in .NET 10 make it easier to define validation once and reuse it across endpoints, because validation logic can now live outside the HTTP layer (via Microsoft.Extensions.Validation). Errors are also produced in a more standardised way, which makes behaviour easier to reason about.

Surely, it doesn’t remove the need for custom validation, but it reduces how much of it you have to write and how many versions of the same rule end up scattered across the codebase.

Testing across teams

.NET 10 adds significant improvements to 'dotnet test' command through Microsoft.Testing.Platform integration, improving consistency between local runs and CI pipelines. If you’ve ever had: “It works locally, but fails in the pipeline”, this is exactly the kind of issue it helps reduce.

The same test infrastructure can now be used across environments, instead of relying on slightly different runners or configurations. It matters most in setups where multiple teams contribute to the same codebase, where differences in local environments tend to surface quickly.

Real-time updates

In some systems, the client needs to receive updates as they happen, for example, a shipment changing status or a charging session starting or stopping. The usual way to handle this is either polling (asking the server every few seconds) or setting up WebSockets, which adds a separate connection model and more complex handling.

.NET 10 introduces built-in support for Server-Sent Events (SSE) as an alternative.

• Instead of repeated requests (polling), the server can keep a single HTTP connection open and stream updates over time.
• Unlike WebSockets, this doesn’t require a separate protocol or bidirectional communication setup

For cases where the client only needs to receive updates, this simplifies the architecture and reduces the need for custom infrastructure.

Security that doesn’t rely on passwords

Authentication is one of the few areas where users immediately feel the difference.

.NET 10 adds built-in support for passkeys (WebAuthn / FIDO2) in ASP.NET Core Identity that allows login without passwords (via biometrics or device-based authentication).

In eCommerce, this directly affects conversion – fewer failed logins and fewer password resets.

In eMobility platforms, it improves access to user accounts and mobile apps.

And what about AI?

It’s impossible to talk about anything now without mentioning AI. .NET is no different and explores how AI fits into the system:

• calling an LLM or embedding model becomes just another external call, similar to a carrier or payment API
• multi-step flows (e.g. classify > enrich > decide) can be structured as part of the backend logic, not as a separate service
• AI can be introduced into existing systems incrementally, without building a separate platform around it.

In other words, AI stops being something “on the side” and becomes part of the normal request flow, used where it adds value.

Wrapping up

Looking at it as a whole, .NET 10 doesn’t introduce headline features, but it improves several areas where systems tend to struggle.

• Runtime reduces memory pressure and makes scaling more predictable
• JSON handling catches bad data early, before it spreads through the system
• Validation can be reused instead of reimplemented across services
• Testing behaves more consistently between local and CI environments
• Real-time updates no longer require custom infrastructure for simple scenarios
• Authentication becomes simpler and less dependent on passwords
• AI integration can be introduced as part of existing services

.NET 10 makes systems behave more predictably in the situations that usually cause trouble, and that’s exactly what we’re looking for.