← Interview Preparation

Communication & Data Transfer

How systems exchange data — from bytes to terabytes, browser to data center. REST and HTTP API design, JSON:API contracts, GraphQL, gRPC and tRPC, real-time protocols (WebSockets, SSE, WebRTC), async integration (webhooks, event APIs), and large-payload strategies. Primary prerequisite: Networking (TCP, TLS, HTTP mechanics). This track stays at the application layer and adds on top of sibling references — not instead of them.

Time budget: ≈36h

How this reference fits the collection

  • We deliberately do not repeat TCP/DNS mechanics, Kafka internals, saga/outbox proofs, B-tree storage, in-process mutex design, or OTel dashboard setup — those live in sibling tracks linked below.
  • Work through topics top to bottom — GraphQL and gRPC assume REST concepts; bulk transfer assumes async integration patterns.
  • Networking — wire protocol, DNS, TLS, HTTP/1–3, load balancing. Start here before this track.
  • Concurrency — threads, pools, semaphores inside a process. This track applies those ideas to outbound API calls and connection fan-out, not mutex design.
  • Distributed Systems — Kafka internals, sagas, outbox relay, delivery guarantees. This track helps you choose sync vs async and design webhook/AsyncAPI contracts.
  • Databases — storage engines, object lakes, MVCC. This track covers presigned uploads and export APIs that land data there.
  • Data Engineering — pipelines after data arrives. This track covers the API surface for bulk export and ingest orchestration.
  • Microservices Patterns — discovery, gateways, mesh, event sourcing, CQRS — platform assembly after protocols.
  • LLD — class-level APIs in interview problems. This track is system-level protocols (HTTP, gRPC, GraphQL) across network boundaries.
  • Observability — traces, metrics, SLOs. This track mentions propagation headers across hops; instrumentation depth stays there.

Topic 9 (Deep Cuts) — advanced GraphQL, resumable multipart protocols, backpressure, and custom binary framing. Gateway and mesh → Microservices Patterns.

The Reference

  1. 1

    How services talk — styles, coupling, and the application-layer lens on top of HTTP.

    1. 1.1The Application Communication Lens2/530m
    2. 1.2Sync vs Async Integration Patterns3/530m
  2. 2

    Resource design, versioning, pagination, and production-grade HTTP APIs.

    1. 2.1RESTful Design & Versioning3/535m
    2. 2.2OpenAPI, Errors & Pagination3/535m
  3. 3

    Standardized JSON envelopes, sparse fieldsets, and schema evolution at the boundary.

    1. 3.1JSON:API Conventions3/530m
    2. 3.2Contract-First & Schema Evolution3/535m
  4. 4

    Schema-first queries, the N+1 problem, federation, and when GraphQL beats REST.

    1. 4.1GraphQL Schema & Execution3/535m
    2. 4.2Federation, Performance & Trade-offs4/535m
  5. 5

    Protobuf, streaming RPC, gRPC-Web, tRPC, and Connect for typed service meshes.

    1. 5.1gRPC, Protobuf & Streaming RPC4/540m
    2. 5.2tRPC, Connect & Type-Safe RPC3/530m
  6. 6

    WebSockets, SSE, long polling, and WebRTC for live and peer communication.

    1. 6.1WebSockets & Server-Sent Events3/535m
    2. 6.2WebRTC & Peer Data Paths4/535m
  7. 7

    Webhooks, callbacks, and message-based boundaries between services.

    1. 7.1Webhooks & Callback APIs3/530m
    2. 7.2Message-Based Integration4/535m
  8. 8

    From megabyte uploads to terabyte migrations — chunking, presigned URLs, and physical transfer.

    1. 8.1Large Payload Strategies4/540m
    2. 8.2Offline & Physical Transfer3/530m
  9. 9

    Advanced GraphQL, resumable protocols, backpressure, and custom framing.

    1. 9.1Advanced GraphQL Operations4/530m
    2. 9.2Resumable & Multipart Protocols3/525m
    3. 9.3Backpressure & Flow Control4/530m
    4. 9.4Custom Binary Protocols & Framing5/535m