🔌

APIs, Networking & Integration Topics

API design, management, and integration patterns including REST, GraphQL, and other protocols. Covers API contract design, versioning strategies, error handling, idempotency, deprecation planning, and SDK/integration frameworks. Includes system-to-system integration, webhook patterns, and integration platform considerations. Excludes network infrastructure and network-layer protocols (see Network Architecture under Cloud & Infrastructure or a dedicated networking category if needed).

Enterprise Application Integration

Integration architecture across many heterogeneous enterprise systems, legacy and modern: how systems exchange data (synchronous calls, push, scheduled bulk or file transfer, messaging) and when each fits, point-to-point versus middleware designs, connectors and adapters, choosing a native connector, iPaaS or custom build, bridging SOAP/XML and REST/JSON, canonical data models and schema mapping, governing shared-schema change, system-of-record ownership, orchestration versus choreography, hybrid on-premises to cloud connectivity over outbound-only or flaky links, multi-tenant integration platforms with idempotent delivery and downstream rate limits, failure handling, dead-letter queues and reconciliation at integration seams, and phased delivery against poorly understood legacy systems. Excludes the design of a single API surface, API gateway and versioning mechanics, broker-level event streaming, data-platform ingestion, and vendor selection or cloud migration programmes covered elsewhere.

10 questions

GraphQL and Flexible Query APIs

Designing schema-driven query APIs where clients specify exactly the data they need. Covers schema and type design (queries, mutations, cursor pagination, nullability, interfaces and unions, mutation errors as typed data), resolvers, the N+1 problem and per-request DataLoader batching, federation with entity keys, query cost, depth and alias limiting, error handling and partial responses, persisted queries and caching, and evolving a shared schema through deprecation. Choosing between GraphQL and REST, REST-to-GraphQL migration, rate-limiting algorithms and API versioning schemes are covered elsewhere.

8 questions

gRPC and Service-to-Service Communication

Efficient inter-service communication using RPC-style contracts: gRPC, Protocol Buffers, and HTTP/2 transport. Covers unary and streaming modes (server, client, bidirectional), flow control, backpressure and cancellation, protobuf schema evolution and field compatibility (reserved field numbers, oneof, unknown fields), binary serialization trade-offs versus JSON/REST, deadlines and timeout propagation, status codes, retries on idempotent calls, interceptors and metadata, long-lived streams behind proxies and load balancers, gRPC-web and gateway exposure, upload and chat contract design, phased migration from REST, and choosing a transport for internal versus public-facing traffic. Excludes REST resource design, GraphQL, mTLS and mesh security, service discovery infrastructure, and broker-based messaging, which are covered elsewhere.

11 questions

API and Integration Troubleshooting

Isolating a fault at an API or integration boundary from the evidence available: reading HTTP status codes, response headers and error payloads, correlating request IDs and traces to what happened inside a system, investigating intermittent failures, latency spikes and timeouts, diagnosing TLS, authentication and rate-limit failures, and deciding whether the fault sits with the client, the network, the gateway or the provider. Includes triaging intermittent failures against third-party and partner APIs, telling a client library bug from a bad request, a server error or an environment problem, narrowing field failures that only some mobile users see, detecting silent failures and quietly lost records where status codes look healthy, what logs and telemetry to capture for integration problems, safe temporary mitigations while investigating, and giving integrators actionable diagnostics without exposing other tenants' data. Excludes API design, security mechanics, live multi-service incident command, network-layer packet diagnosis and general-purpose debugging.

5 questions

HTTP Protocol and Web Fundamentals

HTTP semantics that underpin web and API behavior: methods (safe vs idempotent, retries), the status codes that drive caching, conditional and range behavior, request and response headers, content negotiation and Vary, HTTP caching (Cache-Control, private vs shared caches, ETag, conditional requests), cookies and credentialed cross-origin requests (SameSite, CORS and preflight at the header level), large responses (range requests, resuming a download), connection reuse and message framing (keep-alive, chunked transfer, pipelining), and HTTP/1.1 vs HTTP/2 vs HTTP/3 differences such as multiplexing, flow control and head-of-line blocking. Includes TLS at the request level (handshake overview, session resumption, termination at the edge vs passthrough) and how proxies and load balancers change requests, including forwarded client addresses. Excludes TCP/UDP and OSI-layer networking, attack-focused web security, resource and endpoint design, and CDN or edge-cache operations.

9 questions

API Versioning, Deprecation and Backward Compatibility

Evolving an API without breaking existing consumers: versioning schemes (URI, header, media type, semantic versioning), classifying breaking versus non-breaking changes including behavioural ones such as defaults and error text, deprecation and sunset policy and timelines (including accelerated retirement), running multiple versions concurrently, and planning consumer migrations at scale including SDK, partner, mobile and long-tail client impact. Also covers finding who still calls an old version, catching accidental breaks with contract checks in CI, expand-then-contract evolution of fields and stored data, gradual rollout with per-version monitoring, and compatibility between independently deployed services, streams and libraries. Covers compatibility guarantees across REST, GraphQL and gRPC consumers. Excludes general API surface design, payload and OpenAPI schema design, protobuf field-level mechanics, writing the notices themselves, rate limiting, gateways and database schema migration.

35 questions

API Gateways and API Management

The API gateway as a component and the API program it enforces: routing and aggregation, a policy chain for authentication hand-off, throttling hooks, request validation and transformation, protocol translation, telemetry, TLS termination, failure isolation, scaling, multi-region placement, response caching with stampede protection, tenant-aware routing and isolation, traffic steering by version or experiment cohort, and safe policy rollout and testing, plus gateway versus service mesh versus BFF placement of cross-cutting concerns. Also the management surface around it: key and credential provisioning with approval, plan and tier enforcement, separating public from partner audiences, usage analytics, and central policy governance. Excludes throttling algorithms and distributed counters, OAuth/JWT mechanics, load-balancer algorithms, documentation and developer-portal content, and whole-API-surface design.

13 questions

Rate Limiting, Throttling and Quota Management

Protecting API capacity and enforcing fair use: rate-limiting algorithms (token bucket, leaky bucket, fixed/sliding window), per-client, per-tenant and hierarchical quotas, throttling responses (429 semantics, Retry-After, limit headers), and tiered plan enforcement. Covers where to enforce limits (gateway vs. service), distributed counters, concurrency limits, client retry with backoff and jitter, and backpressure, load shedding and graceful degradation under load. Excludes gateway configuration generally, API versioning, authentication mechanics, cache design, and billing and payment pipelines.

39 questions

API Contracts and Schema Design

Defining the interface contract between producers and consumers: request/response payload shapes, data models, field-level validation, nullability, and enum/typing decisions (including safely evolving an enum's allowed values without breaking clients). Covers contract-first design with OpenAPI and JSON Schema (authoring specs, generating SDKs and mock servers, catching breaking changes in CI), mapping internal domain models to external DTOs as both evolve independently, and designing a stable error-response contract (structured error codes, correlation IDs, retryable classification). Also covers the leadership and behavioral practice of establishing and governing contract standards across teams. The contract is the durable artifact clients depend on.

17 questions
Page 1/2