Production and consumption can diverge
When a source persistently outpaces its consumer, unfinished data accumulates. Asynchronous execution separates activities without eliminating that imbalance; an unbounded queue turns waiting into growing memory and future processing work.
Backpressure communicates downstream limits upstream so production or sending waits, slows, or follows demand allowances. Reactive Streams addresses this exchange across asynchronous boundaries so receivers need not buffer arbitrarily large quantities.
References: [1]
Watermarks and demand allowances
Python StreamWriter.drain illustrates watermarks: it waits when the write buffer reaches a high watermark and resumes after draining to a low watermark. It can return immediately otherwise. This manages buffered transmission, not proof of remote business processing.
Reactive Streams prevents a publisher from emitting more elements than the subscriber requested. Demand is not a promise to produce that many: the stream can complete or fail earlier. Permission to send and guaranteed production are different contracts.
Local bounds must fit the processing chain
A bounded queue can make producers wait when full. Moving excess work into another unbounded collection merely relocates the backlog, so production, queuing, execution, and result consumption must be considered together.
Backpressure does not increase the consumer’s sustained processing capacity. Failure, closure, and unwanted data still need policies. An interface can wait asynchronously without blocking its execution thread, so backpressure need not mean stopping the entire process.