Context
Decomposition Strategies
The method of system decomposition determines the types and number of interservice interactions.
Interservice communication patterns you need to choose not according to fashion, but according to latency budget, criticality of the operation and operational restrictions. The main goal is predictable behavior of the system under load and during failures.
Synchronous patterns
HTTP/gRPC request-response
Suitable for low-latency requests when the client needs an immediate response. Requires strict timeout/retry control.
Aggregator/BFF composition
A separate service collects data from several upstreams. Convenient for UI, but can become a latency bottleneck.
Asynchronous patterns
Queue-based async
Producer and consumer are decoupled in time; convenient for aligning spikes and background processes.
Pub/Sub events
One emitter publishes an event, multiple subscribers react independently. Good for extensibility.
Event-carried state transfer
The event carries enough context to reduce synchronous callback requests between services.
Reliability
Fault Tolerance Patterns
Communication without resilience policies in a distributed environment is usually unstable.
How to choose a pattern
We need a response to the user within one HTTP request -> often sync path.
We need resistance to spikes and loose coupling -> async via queue/topic.
If the operation is money/order critical, check idempotency and ordering before selecting a pattern.
If you have a lot of cross-service hops, reduce the depth of synchronous chains and implement cache/materialized views.
Timeout budgets for each hop and general end-to-end deadline policy.
Retry with jitter and retry budget, so as not to create a retry storm when the dependency degrades.
Circuit breaker/bulkhead for fault isolation and concurrency control.
Idempotency keys for teams and deduplication for event-consumers.
DLQ/parking lot for invalid or problematic messages.
Practical checklist
- For each integration channel, an owner, SLO and error budget are specified.
- Contracts are versioned and verified by contract tests in CI.
- There is a degradation strategy when the downstream service is unavailable.
- The trace covers the end-to-end path through sync and async segments.
- Critical commands and events are processed idempotently.