How do components communicate in a system (APIs)?

Question

Accepted Answer

In a system, components (services, clients) communicate through **APIs** and various protocols — synchronous (REST, gRPC) and asynchronous (messaging/queues). Understanding how components communicate is fundamental to designing systems made of multiple parts.

## Synchronous communication (request/response)

```text
The caller WAITS for a response (blocking):
  REST (HTTP) → most common; resources over HTTP (JSON) → simple, ubiquitous, web-friendly
  gRPC → high-performance RPC (binary, HTTP/2) → fast, typed; good for internal services
  GraphQL → flexible queries (client requests exactly what it needs)
→ for: direct request/response where the caller needs an answer now
```

## Asynchronous communication (messaging)

```text
The caller does NOT wait (decoupled, non-blocking):
  MESSAGE QUEUES (RabbitMQ, SQS) → send a message; a consumer processes it later
  EVENT STREAMING (Kafka) → publish events; consumers react
  PUB/SUB → broadcast events to subscribers
→ for: decoupling, background work, handling spikes, event-driven systems
  ✓ resilience (queue buffers), scalability, decoupling  ✗ more complexity, eventual consistency
```

## Choosing and considerations

```text
SYNC → when the caller needs an immediate response; simpler request/response
ASYNC → when decoupling, resilience, or background processing matters (don't block)
→ Also: API design (clear contracts), versioning, error handling, timeouts/retries,
  authentication, rate limiting → robust communication between components
```

## Why it matters

Understanding how components communicate via APIs is foundational because **systems are made of multiple parts that must communicate**, so understanding communication is essential for designing them.

Systems consist of services and clients that interact, and how they communicate is a fundamental aspect of system design.

Understanding **synchronous communication** (request/response where the caller waits) — **REST** (the ubiquitous HTTP/JSON approach), **gRPC** (high-performance RPC for internal services), and GraphQL (flexible queries) — covers the common ways components make direct calls expecting an answer.

Understanding **asynchronous communication** (decoupled, non-blocking) — **message queues** (sending messages for later processing), **event streaming** (Kafka), and pub/sub — is equally important, as it enables **decoupling, resilience (queues buffering load), scalability, and event-driven systems**, at the cost of more complexity and eventual consistency.

Understanding the **sync vs async distinction and when to use each** — synchronous when the caller needs an immediate response, asynchronous when decoupling, resilience, or background processing matters — is a key design consideration that significantly affects a system's characteristics.

Understanding additional considerations (clear API contracts, versioning, error handling, timeouts/retries, authentication, rate limiting) reflects designing robust communication.

Since systems are composed of communicating parts and how they communicate (sync vs async, the protocols, and the design considerations) fundamentally shapes the system, and since understanding component communication is essential for designing multi-component systems, understanding how components communicate via APIs is essential, foundational system-design knowledge — fundamental to designing systems made of multiple interacting parts, covering the synchronous and asynchronous communication that connects components, and central to architecting the distributed, service-based systems common today.