Implement a validation filter that gives minimal API endpoints one stable 400 response shape.

• Use public camel-case field keys.
• Allow several messages per field.
• Skip the handler on failure.
• Keep business conflicts separate from field validation.

I make validation an endpoint boundary so handlers receive structurally valid input. The validator returns a dictionary rather than throwing, and the filter maps that dictionary directly to ValidationProblem.

public interface IRequestValidator<T>
{
    Dictionary<string, string[]> Validate(T request);
}

public sealed class ValidationFilter<T>(IRequestValidator<T> validator)
    : IEndpointFilter
{
    public async ValueTask<object?> InvokeAsync(
        EndpointFilterInvocationContext context,
        EndpointFilterDelegate next)
    {
        var request = context.Arguments.OfType<T>().Single();
        var errors = validator.Validate(request);
        return errors.Count == 0
            ? await next(context)
            : TypedResults.ValidationProblem(errors);
    }
}

var users = app.MapGroup("/users");
users.MapPost("/", CreateUser)
    .AddEndpointFilter<ValidationFilter<CreateUserRequest>>();

The filter removes repeated plumbing without turning domain failures into validation. If endpoints need different rule sets, register explicit validators rather than hiding conditional behavior in one global validator.

• The request argument is missing.
• A field has multiple failures.
• An asynchronous uniqueness check is needed.
• The JSON body cannot bind.

• Assert the handler is not called.
• Assert exact public keys and arrays.
• Keep malformed JSON behavior separate.

• Throwing validation exceptions for normal input.
• Returning property display names as unstable keys.
• Converting 409 conflicts into 400 fields.
• Copying the filter into every endpoint.