AT10 — Synchronous vs Asynchronous: The Invisible Architecture Decision

Your checkout service calls inventory, payment, and fulfilment in sequence. Each takes 100ms. Your P99 is 850ms. You made this decision without knowing you made it.

Every call in your system sits on one side of a dial. Synchronous: the caller blocks until the operation completes. Asynchronous: the caller returns immediately and the result arrives later. Most engineers pick synchronous by default. That default is a decision. AT10 — Synchronous vs Asynchronous — is the name of the decision you keep making without naming.


The dial

A synchronous operation is simple to reason about. The caller waits. The result comes back. The call stack tells the whole story. When something fails, the stack trace points at it.

An asynchronous operation returns immediately. The result is delivered later — through a callback, a webhook, a queue consumer, a polling endpoint. Nothing blocks. Nothing waits. The caller does other work while the operation runs.

The dial does not offer a neutral position. Every call in your system sits on one side. The question is whether you chose that side or inherited it.


Where the dial appears

A payment API returns the result synchronously. The caller waits for the settlement confirmation. This is the correct choice when the next step in the flow depends on the result — the user cannot see the order confirmation page until the payment cleared.

A payment API returns a payment reference and delivers the final result via webhook. The caller records the reference and moves on. The webhook fires when settlement completes. This is the correct choice when settlement can take seconds or minutes — blocking the caller for that duration wastes a connection and holds the user in front of a spinner.

A Kafka consumer commits offsets synchronously after processing each message. It is slower. It carries no duplicate risk on failure. A consumer that commits asynchronously in batches is faster. It carries a small duplicate risk when the process dies before the batch commit fires.

Same dial. Different requirement. Different setting.


Setting the dial

The rule is one question: does the caller actually need to wait, or have they been waiting by default?

Set toward synchronous when the caller needs the result to continue. A read that returns data the next line of code uses. A validation that decides whether the request proceeds. A write whose success determines the response to the user.

Set toward asynchronous when the caller does not need the result immediately. An email notification triggered by an order. A downstream index update after a database write. A fan-out to 100,000 follower feeds after a post.

Set toward asynchronous when the operation is too slow to block on. A video transcode. A large report generation. A settlement that depends on an external clearing house that takes minutes.

The wrong default is synchronous everywhere. The wrong default is also asynchronous everywhere. The default is a decision to make per call.


The failure mode: FM5 — Latency Amplification

Synchronous by default has one dominant failure mode. It is FM5 — Latency Amplification.

Your checkout service calls inventory synchronously. Inventory calls the warehouse service synchronously. The warehouse service calls the shipping calculator synchronously. Each hop adds 100ms. Four hops later, the caller has waited 400ms and none of the work happened in parallel.

Little's Law is the underlying constraint. Throughput equals arrival rate times average latency. When each request holds a connection for the full 850ms, your capacity to accept new requests collapses. The system slows further under load. Every synchronous call in a chain compounds.

Asynchronous decomposition breaks the chain. The checkout API returns as soon as the order is recorded. Inventory reservation, payment processing, and fulfilment happen in parallel through a queue. The user sees the confirmation page in under 100ms. The work continues without them.


The failure mode: FM2 — Cascading Failures

Synchronous chains expose FM2 — Cascading Failures. When the warehouse service slows down, every service calling it synchronously slows down. Every service calling those services slows down. Threads pile up. Connection pools fill. The failure spreads to services that have no direct dependency on the warehouse.

Asynchronous decomposition through a queue absorbs the failure locally. The warehouse service falls behind on its queue. The queue depth grows. The upstream services do not notice — they wrote their message and moved on. The failure is bounded to the consumer of the slow service, not propagated to every caller.

The queue is not free. It introduces its own failure modes. But it stops one specific propagation.


The complexity cost

Asynchronous systems are harder to debug. The request and the result are separated in time. The call stack breaks at the async boundary. A stack trace on the consumer side does not show what the producer was doing.

Asynchronous systems are harder to trace. Distributed tracing must span the queue. Correlation IDs must pass through every message. A missing correlation ID at any hop breaks the trace.

Asynchronous systems are harder to test. You cannot assert on the result inline. Tests must wait for asynchronous delivery. Flaky tests are the common symptom of assertions that raced the async boundary.

The latency benefit must justify this complexity. When the caller genuinely needed to wait — synchronous is the correct answer and the added complexity of async buys nothing. When the caller was blocking on work they did not need — the P99 you gain and the failure isolation you gain are worth the debugging cost.


The signal that tells you this applies

Your P99 latency is dominated by sequential calls to downstream services. Your service holds threads open waiting for external systems. When a downstream service slows down, your service slows down with it. When your queue depth is zero because you do not have a queue.

These are the signals that AT10 was set to synchronous by default. Not by decision.


The interaction with AT1

AT10 does not stand alone. Choosing asynchronous shifts your position on AT1 — Consistency vs Availability. An async fan-out to follower feeds means the follower sees the post seconds after the author wrote it. That is eventual consistency. It is the price of the async decision.

For a social feed, this is correct. Bounded staleness is acceptable. For a payment ledger, this is not. The dial for AT10 cannot be set without knowing where you have set AT1. A team that chooses async for a payment path has also chosen availability over consistency, whether they meant to or not.


Naming the decision

Two engineers argue for twenty minutes about a notification system. One wants synchronous writes to the database, then send. Nothing lost. The other wants a message queue. Fast writes, retryable sends.

Both are correct. Neither has named the tradeoff. Once they name it — AT10, with AT1 attached — the argument ends. What does the product require? What does the SLO say? That is a one-minute conversation.

The invisible architecture decision becomes visible the moment it has a name. Every call in your system already made this choice. The only question is whether you can point at each one and say why.


The full framework treatment — compression blocks, three-level exercises, and the complete AT/FM mapping — is in the Reference Book, Chapter 8 (Architecture Tradeoffs). Free chapter available at computingseries.com/books/ref.