Build a bulk endpoint that updates up to 100 orders without returning half-success ambiguity.

• Allow at most 100 commands.
• Reject duplicate ids.
• Load the complete target set once.
• Use one atomic SaveChanges call.

I validate command shape first, load every target in one query, compare requested and loaded ids, then validate domain transitions. Only after the whole batch passes do I mutate tracked entities and save once.

app.MapPost("/orders/bulk-status", async Task<IResult> (
    BulkStatusRequest request, AppDbContext db, CancellationToken ct) =>
{
    if (request.Items is not { Count: > 0 and <= 100 })
        return Results.ValidationProblem(new() {
            ["items"] = ["Provide between 1 and 100 updates."]
        });

    var ids = request.Items.Select(x => x.Id).ToArray();
    if (ids.Distinct().Count() != ids.Length)
        return Results.ValidationProblem(new() {
            ["items"] = ["Each order id may appear only once."]
        });

    var orders = await db.Orders.Where(x => ids.Contains(x.Id)).ToListAsync(ct);
    var missing = ids.Except(orders.Select(x => x.Id)).ToArray();
    if (missing.Length > 0)
        return Results.NotFound(new ProblemDetails {
            Title = "Some orders were not found",
            Extensions = { ["missingIds"] = missing }
        });

    var byId = orders.ToDictionary(x => x.Id);
    var errors = new Dictionary<string, string[]>();
    foreach (var item in request.Items) {
        if (!byId[item.Id].CanMoveTo(item.Status))
            errors[$"items[{Array.IndexOf(ids, item.Id)}].status"] =
                [$"Cannot move from {byId[item.Id].Status} to {item.Status}."];
    }
    if (errors.Count > 0) return Results.ValidationProblem(errors);

    foreach (var item in request.Items) byId[item.Id].MoveTo(item.Status);
    try {
        await db.SaveChangesAsync(ct); // One SaveChanges is transactional.
    } catch (DbUpdateConcurrencyException) {
        return Results.Conflict(new ProblemDetails {
            Title = "One or more orders changed during the update",
            Status = StatusCodes.Status409Conflict
        });
    }
    return Results.NoContent();
}).RequireAuthorization("orders.manage");

The all-or-nothing contract is easier to retry and reason about than an undocumented mix of successes and failures. For intentionally partial workflows, return an explicit per-item result model instead.

• The same id appears twice.
• One transition is invalid.
• A row disappears before save.
• A concurrent writer changes an order.

• Snapshot rows before the call and verify no change on any rejection.
• Use 0, 1, 100, and 101 commands.
• Assert one database round trip for loading.

• Updating while still discovering errors.
• Looping over ids with one query per item.
• Returning 200 with hidden partial failures.
• Accepting an unbounded batch.