For developers building cloud-native .NET applications, every millisecond of startup time and every megabyte of memory footprint directly impacts scalability and costs. By combining ASP.NET Core Minimal APIs with Native Ahead-of-Time (AOT) compilation, you can create services that launch in milliseconds with dramatically reduced sizes.

This approach sidesteps the traditional JIT overhead and trims away unused framework code. Minimal APIs are a natural fit because they were designed with performance in mind and have excellent compatibility with the trimmer and AOT compiler.

The practical payoff is substantial: deployment artifacts under 20MB that start significantly faster than framework-dependent apps. This article demonstrates exactly how to set this up, including project configuration, code patterns to avoid, and what to expect in production.

#What Are Minimal APIs?

Minimal APIs were introduced in .NET 6 as a simpler, higher-performance alternative to MVC controllers for building HTTP APIs. You define your routes and handlers in Program.cs using extension methods on the WebApplication instance.

This model eliminates much of the reflection and attribute processing that occurs in traditional controllers, leading to lower runtime costs and easier trimming for AOT scenarios.

csharp 
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => Results.Ok(new { message = "Hello World" }));

app.MapPost("/users", async (UserService service, CreateUserRequest request) => 
{
    var user = await service.CreateAsync(request);
    return Results.Created($"/users/{user.Id}", user);
});

app.Run();

#Understanding Native AOT

Native AOT compiles your application to native machine instructions at build time. The resulting single-file executable contains everything needed to run without a separate .NET runtime installation. This eliminates JIT compilation entirely at startup.

Benefits include near-instant cold starts ideal for serverless, reduced disk and memory usage from framework trimming, and an overall smaller security footprint. Your code must avoid or annotate areas that require runtime reflection.

#Step-by-Step: Enabling AOT for Your Minimal API Project

Start with a standard Minimal API project targeting .NET 8. Add the PublishAot and SelfContained properties to your project file. These tell the build system to produce a native executable.

xml 
<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <PublishAot>true</PublishAot>
    <SelfContained>true</SelfContained>
    <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
  </PropertyGroup>
</Project>

After updating the project, publish it using the CLI. Specify a runtime identifier matching your deployment target. The process may take longer than a standard publish as it performs full static analysis and native compilation.

bash 
dotnet publish -c Release -r linux-x64

#Performance Results You Can Expect

Realistic benchmarks show cold start times dropping from several hundred milliseconds to less than 50ms for simple services. The on-disk size of the published application shrinks by 60-75% compared to framework-dependent publishing. These improvements lead to faster autoscaling, lower infrastructure costs, and higher density per host.

  • Validate your application with dotnet publish and address any trim warnings reported by the SDK
  • Prefer injected services and typed handlers over complex model binding that might rely on reflection

The key takeaway for developers is to consider Minimal APIs and Native AOT for your next ASP.NET Core project, especially if deployment size and startup performance are priorities. While not every library is compatible yet, the core web stack works well and the benefits are compelling for microservices and APIs. Profile your specific workload, but in most cases this stack provides a clear win for production efficiency.