What is backpressure, and how do you implement it across a .NET system, from in-process queues to message brokers and HTTP APIs?

1. Backpressure is end-to-end

client ──► API ──► [queue] ──► consumer ──► ERP (50/s)
   ▲         │          │            │          │
   │   reject 429/503   bounded/     prefetch,  rate limit,
   │   + Retry-After    durable      concurrency bulkhead
   └── backoff with jitter

Each arrow needs a decision. The weakest boundary determines what happens under overload.

2. Network-level flow control comes free, if you let it

• If an ASP.NET Core endpoint reads the request body asynchronously and slowly, Kestrel stops reading from the socket when its pipe buffer is full; TCP windows close; the client slows down. No extra code needed.
• If you buffer the whole body first (or read synchronously in a hurry), you defeat this and take the memory hit instead.
• HTTP/2 and gRPC add per-stream windows, so one slow stream doesn't block others on the same connection.

3. Broker consumer settings

var processor = client.CreateProcessor("orders", new ServiceBusProcessorOptions
{
    MaxConcurrentCalls = 8,          // matched to ERP capacity (with rate limiter)
    PrefetchCount = 16,              // small: don't hoard messages whose locks may expire
    AutoCompleteMessages = false,
    MaxAutoLockRenewalDuration = TimeSpan.FromMinutes(5)
});

Too much prefetch means a consumer holds messages it can't process before their locks expire → redelivery → duplicates. Consumers must be idempotent anyway, because at-least-once delivery is normal.

4. Load shedding by priority

Implement with separate queues/limiters per class, priority channels (.NET 9 adds an unbounded prioritised channel), or partitioned rate limiters.

5. Autoscaling with caps

Scale consumers on queue age/depth (KEDA scalers for Service Bus, RabbitMQ, Kafka), but cap the maximum so you don't overwhelm the downstream system you're protecting: 50 consumers × 8 concurrent calls = 400 concurrent ERP calls, which may be exactly the overload you were trying to avoid.

6. Design checklist

7. Version notes

8. Try it yourself

1. Bounded channel of 100; producer at 1,000 items/s, consumer at 100/s. Compare Wait, DropOldest, and TryWrite + reject counting; plot depth and age.
2. Run the code example and drive /orders with bombardier; count 202 vs 503 responses.
3. Upload a large body to an endpoint that reads slowly with ReadAsync and observe the client being throttled by TCP.
4. Configure a Service Bus processor with large vs small PrefetchCount and slow handlers; observe lock-lost redeliveries.
5. Add an "oldest item age" metric to a queue and alert when it exceeds a threshold.

using System.Diagnostics;
using System.Threading.Channels;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton(_ => Channel.CreateBounded<Order>(new BoundedChannelOptions(1_000)
{
    FullMode = BoundedChannelFullMode.Wait,
    SingleReader = false
}));
builder.Services.AddHostedService<ErpWriter>();
var app = builder.Build();

// Reject at the edge when full: the client backs off instead of timing out.
app.MapPost("/orders", (Order order, Channel<Order> queue, HttpResponse response) =>
{
    if (queue.Writer.TryWrite(order with { AcceptedAt = Stopwatch.GetTimestamp() }))
        return Results.Accepted();

    response.Headers.RetryAfter = "5";
    return Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
});

app.Run();

public sealed record Order(int Id, decimal Total, long AcceptedAt = 0);

// Consumers sized to downstream capacity; queue age is the key metric.
public sealed class ErpWriter(Channel<Order> queue, ILogger<ErpWriter> log) : BackgroundService
{
    protected override Task ExecuteAsync(CancellationToken stoppingToken) =>
        Task.WhenAll(Enumerable.Range(0, 4).Select(_ => ConsumeAsync(stoppingToken)));

    private async Task ConsumeAsync(CancellationToken ct)
    {
        await foreach (var order in queue.Reader.ReadAllAsync(ct))
        {
            var age = Stopwatch.GetElapsedTime(order.AcceptedAt);
            if (age > TimeSpan.FromSeconds(30))
                log.LogWarning("Order {Id} waited {Age} in queue", order.Id, age);
            await Task.Delay(20, ct); // ERP call at a rate it can handle
        }
    }
}

For orders that must never be lost, the bounded channel would be replaced by a durable broker with prefetch and concurrency limits on the consumer.