Overview of .Net 9 Minimal APIs
When building modern systems, speed matters, not just for the app itself but for how fast one can create, test, and deploy it. This is the point where Minimal APIs make things easier. First introduced a few versions back; they have matured in .NET 9, giving developers a lean and elegant way to craft web services with almost no overheads. The .NET team has focused on performance and architectural improvements, while Microsoft continues to evolve the framework to better support scalable and maintainable application development.
This post discusses what Minimal APIs are, how they fit perfectly into a microservices architecture, what new features and features in .NET 9 enhance microservices support, and a few pointers while using them.
What Are Minimal APIs?
If you have ever created a small API and thought, “Why do I need a Startup class/Controller for something so small?” Minimal APIs solve that problem. They let one define endpoints directly inside Program.cs, keeping the entire service inside a few clean lines. Minimal APIs can be implemented in a single file for simplicity, but for larger projects, organizing endpoints into separate files improves maintainability.
Here’s a Quick Demo:
var app = WebApplication.CreateBuilder(args).Build();
app.MapGet(“/”, () => “Hello from a Minimal API in .NET 9!”);
app.Run();
This is enough to respond to an HTTP GET request. In the above example, the lambda function acts as the handler method for the endpoint, and parameter binding would automatically map incoming request data to method parameters if any were defined. It is similar to working with frameworks like Express.js or Flask, fast setup, fewer abstractions, and full control.
Why They’re Great for Microservices Architecture
Microservices are designed to be small, isolated, and fast-starting. Minimal APIs naturally support those goals by trimming any unnecessary complexity.
Some advantages in real projects:
- Tiny footprint and less overhead – no controllers, views, or MVC plumbing.
- Instant startup – ideal for container-based deployments where services may restart often.
- Easier debugging – with less framework code in the middle, problems can be traced faster.
- Rapid iteration – change the route, rebuild, and one is ready to test.
If the service only handles a few endpoints, this approach keeps development quick and the codebase tidy. This makes sense for net microservices, as it aligns with the principles of microservices architecture by enabling lightweight, scalable, and maintainable services.
Minimal APIs are also easy to test with unit tests and benefit from modern tools for development, observability, and monitoring, making them a strong choice for building robust microservices.
Creating Minimal Microservices in .NET 9
Let us build a small Product Catalog Service that provides a few simple endpoints.
Step 1 – To start, create a fresh project using this command:
dotnet new web -n ProductCatalogService
Step 2 – Let us define our product model
Create a file Products.cs:
public record Products (int Id, string Name, decimal Price);
Step 3 – Define the endpoints
Open Program.cs and add:
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
var products = new List<Product> { … };
app.MapGet(“/products”, () => products);
app.MapGet(“/products/{id}”, (int id) =>
{
var p = products.FirstOrDefault(x => x.Id == id);
return p is null ? Results.NotFound() : Results.Ok(p);
});
app.Run();
Run it:
dotnet run
Visit /products or /products/1 in the browser, and your data appears instantly, no controllers required.
The Latest in .NET 9 Minimal APIs
.NET 9 refines the Minimal API experience with several thoughtful updates:
- With faster routing and lower memory usage, each request is processed more efficiently, enhancing the overall functionality of your APIs.
- Route groups organize related endpoints under a shared prefix, also known as a common prefix or url prefix. You can create nested groups for more complex routing scenarios, allowing for scalable and maintainable route hierarchies.
- Simplified Swagger/Open API support; add documentation in seconds.
- Smarter middleware hooks; attach filters or validation logic with less ceremony.
Example using route groups:
var api = app.MapGroup(“/api/products”);
api.MapGet(“/”, () => products);
api.MapGet(“/{id}”, (int id) =>
products.FirstOrDefault(p => p.Id == id) is Product prod
? Results.Ok(prod)
: Results.NotFound());
This structure scales neatly as the API grows. Best Practices for Production-ready Minimal APIs:
- Validate incoming data, never assume requests are valid.
- Leverage dependency injection, register services through builder.Services, and ensure each registered service is available for injection into your endpoints.
- Centralize error handling, use a small middleware to catch, and format exceptions.
- Add authentication, JWT or OAuth works well here.
- Implement structured logging, integrate ILogger or OpenTelemetry for tracing.
- Generate docs, enable Swagger UI for easy endpoint exploration.
- Use local function for endpoint filters to control request/response handling, and ensure clearly defined API contracts for maintainability.
- Consider using NuGet packages like Carter to organize endpoints and register services more efficiently, reducing direct edits to program.cs.
Example Swagger setup:
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
This gives you a built-in, interactive API viewer right from the browser.
Deploying Minimal APIs with Docker or Kubernetes
Minimal APIs start fast and use less memory, which allows them to run efficiently inside containers.
Minimal APIs are particularly well-suited for net microservices and microservices architecture, enabling rapid development and deployment of scalable services. Configuration can be managed through WebApplication.CreateBuilder, which registers essential services and reads configuration settings, making it easy to customize behavior for containerized deployments.
A simple Docker file looks like this:
FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base
WORKDIR /app
COPY . .
ENTRYPOINT [“dotnet”, “ProductCatalogService.dll”]
Build and run:
docker build -t productcatalog .
docker run -p 8080:80 productcatalog
Once containerized, deployment to Kubernetes is straightforward, run it as a lightweight pod behind a service, and scale replicas as needed. Because of its small structure, startup and scale-out times remain impressively low.
Observability tools are essential for monitoring and managing microservices in production, ensuring reliability and performance at scale.
Conclusion
Minimal APIs in .NET 9 prove that less code does not mean less capability. They trim away layers you do not always need while keeping the full performance and reliability of the .NET platform.
Developers adopting microservices often find Minimal APIs offer a simple yet powerful approach. They make traditional controller-based designs feel heavy in comparison.
About eInfochips-
eInfochips, an Arrow Electronics company, delivers product engineering and digital transformation services to global enterprises. With deep expertise in cloud, DevOps, and application development, we help organizations build scalable microservices-based platforms and modern full-stack applications. To learn how we can support your next microservices initiative, explore our full-stack development services
Author: Yashita Sharma
Category: Software and Mobile Apps
Author Introduction:
Yashita is a .NET Developer with four years of experience specializing in designing and developing robust APIs and backend systems. She focuses on building scalable and secure web applications using modern .NET technologies. Her expertise spans API design, database management, performance optimization, and integration of enterprise solutions. Over the years, she has contributed to several projects involving ASP.NET Core, C#, RESTful APIs, SQL Server, and microservices architecture, demonstrating a strong passion for crafting efficient, maintainable, and high-performing software solutions.
