System Design Architecture Patterns and APIs Syllabus

What is the N+1 problem in GraphQL and how is it commonly mitigated?

When resolving a list of N items triggers 1 query for the list plus N additional queries for each item's related data. It is mitigated with batching/caching tools like DataLoader that coalesce requests within a tick.

What is gRPC?

A high-performance, open-source RPC framework by Google that uses HTTP/2 for transport and Protocol Buffers as the interface definition language and binary serialization format, supporting streaming and multiple languages.

What are Protocol Buffers (protobuf)?

A language-neutral, platform-neutral binary serialization format and IDL where message schemas are defined in .proto files and compiled into code; it is more compact and faster to parse than JSON.

Name the four gRPC communication (streaming) modes.

1) Unary (single request, single response), 2) Server streaming, 3) Client streaming, 4) Bidirectional streaming.

Give three technical reasons gRPC outperforms REST/JSON for service-to-service calls.

1) HTTP/2 multiplexing and header compression, 2) compact binary Protocol Buffers instead of text JSON, 3) built-in streaming and strongly-typed contracts with code generation.

List the common API versioning strategies.

URI/path versioning (e.g., /v2/users), query parameter (?version=2), custom header versioning, and content negotiation via the Accept header (media-type/'Accept-Version').

Compare offset-based and cursor-based (keyset) pagination.

Offset-based uses LIMIT/OFFSET (e.g., page & size) — simple but slow on deep pages and unstable when data changes. Cursor/keyset uses a pointer to the last item (e.g., WHERE id > cursor) — stable and efficient for large/real-time datasets but no random page jumps.

For offset pagination, what formula converts a page number to a database offset?

$\text{offset} = (\text{page} - 1) \times \text{pageSize}$

What is Event Sourcing?

A persistence pattern where state changes are stored as an immutable, append-only sequence of events rather than storing current state; the current state is derived by replaying the events in order.

Name two key benefits and two challenges of Event Sourcing.

Benefits: full audit trail/history and ability to reconstruct any past state (temporal queries, replay). Challenges: complexity of rebuilding/querying current state, schema/event versioning, and eventual consistency when building read models.

What is a snapshot in Event Sourcing and why is it used?

A periodically saved copy of an aggregate's current state so that rebuilding state does not require replaying the entire event history from the beginning, improving read/rehydration performance.

What is CQRS (Command Query Responsibility Segregation)?

A pattern that separates the write model (commands that change state) from the read model (queries that return data), allowing each to be optimized, scaled, and modeled independently.

Why is CQRS frequently paired with Event Sourcing?

Event Sourcing produces the stream of write-side events; CQRS uses those events to build denormalized read models (projections) optimized for queries, cleanly separating the append-only write path from optimized reads.

In CQRS, what consistency model typically applies between the write and read sides?

Eventual consistency: the read model is updated asynchronously from write-side events, so there can be a lag before reads reflect the latest writes.

Compare choreography and orchestration in distributed workflows.

Choreography: decentralized; each service reacts to events and emits its own, with no central controller (loose coupling, harder to trace). Orchestration: a central orchestrator explicitly directs and coordinates each service call (easier to monitor/control, but a central coupling point/bottleneck).

In the Saga pattern, how do choreography-based and orchestration-based sagas differ?

Choreography-based saga: services coordinate the distributed transaction by exchanging events with no central coordinator. Orchestration-based saga: a central orchestrator tells each participant which local transaction to run and issues compensating transactions on failure.

What is a compensating transaction in a Saga?

An action that semantically undoes the effect of a previously completed local transaction when a later step in the distributed saga fails, restoring consistency without traditional ACID rollback.

Compare synchronous and asynchronous communication between services.

Synchronous: caller sends a request and blocks/waits for the response (e.g., HTTP/gRPC) — simple but creates temporal coupling. Asynchronous: caller sends a message and continues without waiting (e.g., message queues/events) — decoupled and resilient, but adds complexity and eventual consistency.

What is temporal coupling and which communication style reduces it?

Temporal coupling is when both services must be available at the same time for an interaction to succeed (typical of synchronous calls). Asynchronous, message/queue-based communication reduces it by buffering messages so the receiver need not be up simultaneously.

How does traditional HTTP polling differ from long polling?

Regular polling: client repeatedly sends requests at fixed intervals; the server responds immediately even if there is no new data (wasteful). Long polling: the server holds the request open until data is available (or timeout), then responds, and the client immediately reopens a new request.

Compare WebSockets, Server-Sent Events (SSE), and long polling on directionality and transport.

WebSockets: full-duplex bidirectional over a single persistent TCP connection (ws://). SSE: unidirectional server-to-client over a persistent HTTP connection, auto-reconnect, text-only. Long polling: emulated push using repeated held HTTP requests, higher overhead.

When would you choose SSE over WebSockets?

When you only need one-way server-to-client streaming (e.g., live feeds, notifications, stock tickers), want to reuse plain HTTP with automatic reconnection and simpler infrastructure, and do not need client-to-server messaging over the same channel.

What is a webhook?

A user-defined HTTP callback where a server proactively sends an HTTP POST to a pre-registered client URL when a specific event occurs, enabling event-driven 'push' integration instead of the client polling for changes.

Contrast webhooks with polling and explain how webhook security is typically ensured.

Polling has the client repeatedly ask for updates (wasteful, delayed); webhooks push data only when events occur (efficient, near real-time). Security is commonly ensured by verifying an HMAC signature in a header computed over the payload with a shared secret.

What is the Circuit Breaker pattern and what are its three states?

A resilience pattern that stops calling a failing dependency to prevent cascading failures. States: Closed (calls flow, failures counted), Open (calls fail fast immediately without invoking the dependency), and Half-Open (a limited number of trial calls test recovery; success closes it, failure reopens it).

What triggers a Circuit Breaker to move from Closed to Open?

When the failure rate or count of failed calls crosses a configured threshold within a monitoring window, the breaker trips to Open and begins failing fast.

What is retry with exponential backoff, and why add jitter?

Retrying a failed request while exponentially increasing the wait between attempts (e.g., 1s, 2s, 4s, 8s) to avoid overwhelming a recovering service. Jitter adds randomness to the delay so many clients don't retry in sync (avoiding the 'thundering herd'/retry storm).

Write the formula for the retry delay in exponential backoff (attempt $n$, base delay $b$).

$$\text{delay}(n) = b \times 2^{\,n}$$ often capped at a maximum: $\text{delay}(n) = \min(\text{cap},\, b \times 2^{\,n})$.

Give the formula for 'full jitter' exponential backoff.

$$\text{delay} = \text{random}\!\left(0,\ \min(\text{cap},\ b \times 2^{\,n})\right)$$ where the actual wait is uniformly sampled between 0 and the computed backoff bound.

What is the Bulkhead pattern?

A resilience pattern that isolates resources (e.g., separate thread pools, connection pools, or service instances) per dependency or client so that a failure or resource exhaustion in one partition cannot sink the entire system — named after watertight ship compartments.

What is the Timeout pattern and why is it essential in distributed systems?

Setting a maximum time to wait for a response before aborting a call. It is essential because it prevents threads/resources from blocking indefinitely on a slow or hung dependency, freeing resources and enabling fast failure and fallbacks.

How do the Timeout, Retry, and Circuit Breaker patterns typically work together?

Timeout bounds each call so it fails fast; Retry (with backoff/jitter) re-attempts transient failures; Circuit Breaker counts failures and opens to stop retrying a persistently failing dependency, preventing cascading overload.

What is graceful degradation?

Designing a system so that when a component or dependency fails, the application continues operating with reduced functionality rather than failing completely (e.g., disabling recommendations but still serving the catalog).

What is a fallback in resilience engineering? Give an example.

An alternative response or path used when the primary operation fails or times out — e.g., returning cached/stale data, a default value, or a queued action instead of an error, so the user still gets a usable result.

Distinguish graceful degradation from a fallback.

A fallback is a specific alternative action for one failed operation (e.g., serve cached data). Graceful degradation is the broader system-level strategy of maintaining partial/core functionality under failure, often implemented using multiple fallbacks.

What is the 'thundering herd' problem and which patterns mitigate it?

When many clients simultaneously retry or hit a resource (e.g., after an outage or cache expiry), overwhelming the recovering service. Mitigations include jittered exponential backoff, circuit breakers, request coalescing, and rate limiting.

Why is statelessness important for horizontally scaling REST and FaaS services?

Because no client session state is stored on a specific instance, any request can be routed to any instance; this lets you add/remove instances freely behind a load balancer and enables auto-scaling and fault tolerance.

What HTTP status code is conventionally returned when a Circuit Breaker is open or a service is overloaded, and what does it signal?

503 Service Unavailable (often with a Retry-After header), signaling the service is temporarily unable to handle the request and the client should retry later.

In event-driven microservices, what is the difference between an event and a command?

An event is an immutable statement that something has already happened (past tense, e.g., 'OrderPlaced'), broadcast to any interested subscribers. A command is a directive to a specific handler to perform an action (imperative, e.g., 'PlaceOrder') and expects it to be executed.

What is idempotency and why is it critical for retries and message processing?

An operation is idempotent if performing it multiple times yields the same result as performing it once. It is critical because retries and at-least-once message delivery can cause duplicates; idempotent handlers (often via idempotency keys) prevent double-processing side effects.