Clean architecture with .NET, FastEndpoints, and Refit

Why We Prefer FastEndpoints for Modern .NET APIs

We’ve long been strong supporters of ASP.NET for building .NET APIs, and just as passionate about Clean Architecture. Over the past while, FastEndpoints has become our go-to framework. It’s fast, maintainable, and highly extensible, all while aligning beautifully with clean architectural principles.

This advantage becomes even clearer when the API is consumed from a .NET client application. You can share request/response types and route definitions between the API and the client, staying fully type-safe without manual mapping. It also pairs perfectly with Refit for strongly typed REST calls.

FastEndpoints makes the REPR Design Pattern trivial to implement thanks to its native features. There’s no need for Mediatr or AutoMapper—tools I’ve never truly loved. The framework handles mapping between request/response models and domain models out of the box, without introducing extra dependencies.

public class SubjectRequest
{
    public string FirstName { get; set; }
    public string LastName  { get; set; }
}

public class SubjectResponse
{
    public string FullName { get; set; }
    public string Message  { get; set; }
}

public class SubjectEndpoint : Endpoint<SubjectRequest, SubjectResponse>
{
    public override void Configure()
    {
        Post("/subjects");
    }

    public override async Task<Void> HandleAsync(SubjectRequest req, CancellationToken ct)
    {
        return await Send.OkAsync(new SubjectResponse
        {
            FullName = $"{req.FirstName} {req.LastName}",
            Message  = $"Welcome to Cit Center Hospital, {FullName}"
        }, ct);
    }
}

Compliance

From a compliance perspective, FastEndpoints shines by making it easy to enforce rules across your entire API surface. Because each endpoint is a self-contained slice (REPR), you can apply specific validation logic or security policies granularly. Alternatively, its robust middleware pipeline allows you to implement global compliance checks—like audit logging or strict authorization headers—without cluttering your business logic.

Security

Security is another strong suit. FastEndpoints offers built-in support for fine-grained permissions and role-based access control, making it straightforward to secure endpoints based on user claims. It integrates seamlessly with standard authentication protocols like OAuth2 and OpenID Connect, ensuring your API remains both secure and compliant with modern identity standards.

It also includes first-class support for events, background processing, middleware, filters, server-sent events, and even its own testing framework. It genuinely feels like the creators have thought of everything.

Of course, you can build similar functionality manually using Minimal APIs combined with a handful of additional libraries. But that often adds unnecessary complexity. With FastEndpoints, you get a cohesive, well-designed solution with excellent documentation built right in.

And yes—it’s extremely fast.

If you’re building a .NET API, give FastEndpoints a try. You’ll likely thank us later.