An asynchronous architecture needs a precise answer to “when can the caller rely on this change?” A queue acknowledgment, a database commit, and a replicated read-model update are different events.

The author of Scaling Java-Based Real-Time Systems describes production problems involving read-after-write behavior, state restoration, and blocking work in event consumers. I find the deadline and visibility questions more reusable than any blanket conclusion about Kafka, RocksDB, or a particular cache. A component can be appropriate in one latency budget and unsuitable in another.

Put the visibility requirement in the API

Consider a hypothetical routing update followed immediately by a call that depends on it. If the update returns success before the routing read model catches up, the second operation may use stale state even though both services appear healthy.

One possible contract returns an operation identifier and exposes pending versus active state. Another requires the dependent read to observe at least a returned version. A third keeps the critical decision on an authoritative path. Each choice shifts latency, availability, and complexity differently.

A proposed asynchronous read-model path. The caller contract must account for the gap between commit and read-model visibility.

A proposed asynchronous read-model path. The caller contract must account for the gap between commit and read-model visibility.

Budget the entire path

A proposed deadline budget includes publication delay, broker wait, processing time, read-model update, and visibility to readers. Average consumer lag is not enough: the relevant metric is the age of the specific change the caller depends on.

Stage Useful measurement
Publication Commit-to-event delay
Queue Event age before processing
Processing Work time and dependency waits
Read model Applied version and convergence lag
Caller End-to-end time until the change is usable

If the latency requirement is 300 milliseconds, allocating 250 milliseconds to a queue leaves little room for everything else. The architecture should make that arithmetic visible before adding retries and fallback paths.

Recovery has a latency contract too

Rebuilding local state from a log may make a new instance slow to become useful. Separate process startup from readiness, and test restoration against realistic state volume and concurrent recovery. Scaling out is ineffective if new workers cannot serve before the overload has already passed.

Blocking dependency calls inside a consumer also need explicit timeouts and bounded concurrency. Moving them to a worker pool can protect the poll loop, but introduces ordering, offset, and failure-handling decisions that must be designed rather than assumed away.

The question I would bring to a design review is whether the system can demonstrate its promised visibility under normal load, dependency slowdown, and recovery. Loose coupling is valuable when the resulting temporal contract still matches the product.

Related reading: Slack architecture and asynchronous boundaries.

Archive note: added November 18, 2026, and filed under 2026-11 as part of the systems reading series.