Rapid-Fire Question Bank

Mention the memory hierarchy, cache lines, locality, random access, stalls, and why two O(n) algorithms can differ greatly in wall-clock time.

Concurrency is multiple in-flight tasks; parallelism is simultaneous execution. Explain I/O waiting, core count, event loops, and why excessive concurrency creates queueing and context switches.

Define the saturated resource and show that mitigation differs: optimize compute, locality/capacity, operation pattern, or bytes transferred.

Look for hot cores/shards, lock waits, run queues, GC, I/O queues, downstream waits, burstiness, throttling, and retries. Avoid equating node-average CPU with spare capacity.

Blocking code on the event loop, CPU-heavy handlers, difficult library integration, fairness problems, and operational complexity. Propose bounded worker pools or multiple loops.

Amortizes syscalls, network headers, compression, and storage operations; adds wait time, memory, head-of-line blocking, and fairness issues. Bound by size and time.

Compute 80 core-s/s; 134 cores at 60%; divide by 0.75 for zone loss ≈ 178 cores, then discuss imbalance, background work, burst/growth margin, and benchmark validity.

NUMA remote memory, thread migration, cross-socket locks, cache-coherence traffic, IRQ placement, different power settings, and larger working set. Compare per-node counters and pin an experiment.

Use deadlines, bounded concurrency, cost-aware admission, per-tenant quotas, queue limits, load shedding, retry budgets, autoscaling, and degraded responses. Explain where rejection occurs and how clients back off.

Baseline profiles; quantify copy CPU and memory bandwidth; prototype under realistic payload/concurrency; include tail latency, pinned memory, buffer ownership, safety, portability, and operational complexity.

Tenant-aware admission and queues, CPU/memory/network quotas, shard isolation, workload classes, fair scheduling, cache partitioning, per-tenant observability, and a policy for unused capacity borrowing.

Failover raises foreground load; cold caches and replica rebuild add disk/network/CPU; latency triggers retries; queues grow. Use repair throttles, spare capacity, retry budgets, gradual warmup, priority separation, and chaos tests.

A monolith is one deployable unit; a modular monolith additionally enforces internal boundaries, ownership, and dependency direction. It can still scale horizontally.

Any instance can handle a request; replacement and load balancing are simple. Clarify that durable/session state must live in a replicated store or recoverable layer.

Burst absorption, decoupled timing, fan-out, retry isolation, and long work. Also mention duplicates, lag, ordering, and user-visible status.

Good boundaries align capability, data ownership, invariants, team ownership, scaling, and failure isolation. Bad boundaries are entity CRUD services, shared tables, chatty calls, and coordinated releases.

End-to-end deadlines, retry only transient/idempotent operations, exponential backoff with jitter, retry budgets, circuit breakers, and load shedding.

Orchestrator stores workflow state and commands steps; choreography reacts to events. Compare auditability, coupling, discoverability, centralization, and compensation.

Map domain/invariants and change pain; choose a capability with clear ownership, low cross-transaction coupling, and measurable scaling or release benefit. Describe strangler routing, data ownership, compatibility, observability, and rollback.

Classify correctness-critical versus optional, define latency budget/deadlines, cache or precompute where possible, queue noncritical work, and give coherent degraded behavior.

Versioned desired state, local cache/last-known-good, reconciliation, leases/expiry, idempotent rollout, scoped blast radius, emergency controls, and audit.

Idempotency key and dedupe store, transactional outbox/inbox, atomic state transition with acknowledgment, effect-specific reconciliation, and clear exactly-once scope.

Common identity/control plane; placement metadata; tenant-aware routing; shared shards with quotas; isolated clusters for higher tiers; encryption and observability; online migration and billing.

Use change/deploy coupling, cross-service invariants, synchronous chatter, incident ownership, scaling profiles, and team structure. Explain migration and contract simplification, not only organization preference.

Functional describes behavior/capabilities; non-functional or quality attributes describe latency, availability, security, scale, and operational constraints. Give operation-specific examples.

Measured indicator, internal target, and contractual commitment. Include population, window, and measurement point.

Acceptable data-loss window and restoration time after a defined disaster. Explain that replication, backups, and failover address different failures.

Operations/user/day divided by seconds/day, then apply peak factor and account for skew, retries, background work, and growth.

It represents tail experience and exposes queueing/stragglers; name the request population and avoid treating one percentile as the entire distribution.

Read-your-writes for posts, ordering per author/conversation, deletion propagation, counter accuracy, stale ranking tolerance, and whether duplicates are acceptable.

Critical operations and success boundary; object size/workload; durability/RPO; availability/RTO and regional scope; consistency/overwrite semantics; then security/retention and scale.

Ledger needs strong invariants, audit, idempotency, durable ordered writes, precise recovery; counter may accept approximation, batching, sharding, and eventual convergence. Still define abuse and reset semantics.

Clarify operation/failure/window, quantify cost/downtime, identify correlated and regional failures, distinguish durability from availability, propose tiers, and require tested recovery plus business justification.

Freshness target, query latency, dimensions/cardinality, ingest rate/size, exactness, retention, late events, replay, audience concurrency, and failure/degradation behavior.

Data residency, conflict/invariant analysis, per-operation consistency, RPO/RTO, audit, key management, dependency mapping, staged traffic, reconciliation, rollback, and evidence for regulators.

Range scenarios, hard quotas and admission, queueable/degradable features, load tests, regional/tenant rollout, autoscaling limits, cost guardrails, kill switches, and live assumption validation.

It uses the route table/default gateway, resolves the next-hop link address with ARP/NDP, encapsulates the IP packet in a local frame, and routers forward by prefix.

Bandwidth is transfer rate; latency is delay. Explain propagation, serialization, processing, queueing, and why high bandwidth does not imply low RTT.

It rewrites addresses/ports and tracks flows; limits include port mappings, state table, throughput, and a centralized failure domain.

MTU/path-MTU blackhole, fragmentation/tunnel overhead, proxy body limit, buffering, or bandwidth timeout. Propose payload-size tests and packet/ICMP inspection.

Amount of data in flight needed to fill the path; relates to windows, parallel streams, bulk transfer, and high-RTT links.

CDN, edge LB/reverse proxy, sidecar, or app. Discuss re-encryption, identity, header trust, cert rotation, and observability.

Segment by IPv4/IPv6, DNS answer, edge PoP, path, MTU, TLS, payload, and time. Use diverse probes, carrier path data, CDN logs, packet captures, and controlled routing changes.

Ephemeral port/NAT state exhaustion, TIME_WAIT, poor pooling, destination concentration. Measure mappings, reuse connections, spread egress IPs/gateways, tune pools and timeouts safely.

Global DNS/anycast/edge, DDoS/WAF, regional L7 LB, private app subnets, controlled egress, database routes, TLS boundaries, health/failover, and asymmetric/partition behavior.

Reserve client/network variance, assign per-hop budgets based on service objectives, propagate deadline, fail fast on insufficient remaining time, bound retries, and collect remaining-budget traces.

Inventory flows, introduce proxies/NAT or translation zones, new non-overlapping ranges, DNS/service discovery indirection, dual connectivity, observability, staged workload moves, and eventual removal.

Existing flow pinning, stateful NAT/LB tables, idle/drain timeouts, backend membership, proxy protocol changes, reconnect storm. Canary by connections, connection-age metrics, graceful drain, rollback.

Reliable, ordered byte stream with duplicate suppression, flow and congestion control between endpoints; no message boundaries or application commit/exactly-once guarantee.

Best-effort datagrams with ports and checksum; messages may be lost, duplicated, reordered, or fragmented, and no built-in congestion control/handshake.

Flow control protects the receiver’s buffers; congestion control adapts to path/network capacity.

TCP is a stream; sends can be split/coalesced. Use length prefix, delimiter with escaping, fixed frames, or self-describing encoding and handle partial I/O.

Recovery feedback/timers take longer and congestion window reduction limits in-flight data; relate to BDP and retransmission.

Freshness over completeness, low-latency media/game state, discovery, or as substrate for QUIC/custom reliability—while adding congestion, security, sequencing as required.

Slow receivers cause send queues; TCP backpressure may not reach app because buffers are unbounded. Bound per-connection queues, coalesce presence/typing, persist messages elsewhere, and disconnect/replay.

Account for max server connections, per-connection multiplexing, query concurrency/service time, queue bound, timeouts, lifetime, health validation, failover, and tenant fairness.

HTTP/2 streams multiplex but TCP loss can block delivery across streams; QUIC has stream-level reliability so one stream’s loss need not block others. Include handshake, CPU, fallback, and application/server bottlenecks.

Exponential backoff with full jitter, server retry hints, admission tokens, regional routing, session resumption, progressive capacity restoration, per-client caps, and observability of attempt cohorts.

UDP/multicast or QUIC datagrams where supported, sequence numbers, snapshots plus deltas, gap detection/recovery channel, congestion/rate policy, authentication, clocks, and regional loss behavior.

Client timeout before response, proxy retry, server crash after commit, connection reset, consumer redelivery. Use idempotency key, atomic dedupe/commit, durable response lookup, retry policy, and reconciliation.

Recursive resolver obtains/caches answers for clients; authoritative server serves data for zones it controls.

How long a resolver may cache the record, not a guaranteed propagation time or lease on existing connections.

An alias from one domain name to another; discuss extra lookup, no other data at same owner, and apex/provider-alias caveat.

Old answers were cached with the previous TTL; clients/runtimes may cache; negative caching and existing connections persist.

DNS gives cached endpoint choices before connection and has limited health/control; L7 sees requests, active health, headers, retries, and can balance per request/connection.

Authenticity/integrity of DNS data and authenticated denial; not confidentiality, endpoint availability, or correctness of signed configuration.

Inventory records/certificates, lower TTL early, dual-serve and validate content/cache behavior, weighted traffic, monitor by resolver/ASN, keep old CDN during TTL/connection drain, rollback, then raise TTL.

Check DS at parent vs DNSKEY, signatures/expiry/clock, algorithm support, propagation to all authoritative servers/providers, delegation, and validation traces.

Use tenant/user placement metadata and region-scoped endpoints; avoid routing writes purely by resolver geography; authenticate tenant, enforce residency at app/data layer, health/capacity-aware DNS, and failover policy that preserves compliance.

Reserve degraded capacity, weighted gradual shift, capacity-aware health, admission control, shed noncritical work, warm caches, retry budgets, and hold-down/manual guardrails.

Declarative source of truth, portable record model, CI validation/lint, signed change pipeline, compare AXFR/API/queries, canary records, independent monitoring, DNSSEC key/DS strategy, break-glass.

Multiple bootstrap endpoints, application-level redirect/config with signatures, connection failure triggers refresh, bounded cache max age, staggered rollout, backward-compatible certificates/protocol, and app-version realities.

Safe means intended not to change resource state; idempotent means repeated identical requests have the same intended effect. Give GET/PUT/DELETE/POST examples.

304 Not Modified satisfies a cache validator without body; 412 Precondition Failed means an update/read precondition such as If-Match was false.

401 indicates missing/invalid authentication challenge context; 403 means request understood but not authorized, subject to information-disclosure policy.

Client-generated idempotency key scoped to operation/account, atomic dedupe plus payment state, persisted original response, request fingerprint, expiry, and conflict behavior.

Cache stores response+ETag, sends If-None-Match when stale, origin returns 304 or new representation. Mention strong/weak validators and Vary.

HTTP/2 multiplexing and header compression reduce connection count/HTTP-level blocking, but shares TCP loss/flow control and has stream/concurrency limits.

End-to-end deadline propagation, per-hop budgets, only transient/idempotent retries, jitter and budget, no nested amplification, cancellation, 429/503 guidance, and tracing of attempts.

Explicit private/no-store or correct shared cache key; strip untrusted headers; Vary carefully; token/cookie behavior; cache-status; synthetic users; config review; purge incident plan.

Create upload session, chunk/range or multipart parts, checksums, parallel bounded uploads, idempotent part IDs, resume/list parts, final atomic commit/version, expiry, auth, and size quotas.

Long/variable work, external dependencies, burst buffering. Need durable acceptance, status resource/webhook, idempotency, cancellation, retry/expiry, and user SLO.

Single retry owner or coordinated attempt metadata, end-to-end deadline, idempotency, per-region failover, retry budgets, circuit/outlier signals, overload-aware no-retry, and accounting for late commits.

Alt-Svc/negotiation, telemetry by network/device, UDP reachability, fallback, canary cohorts, CPU capacity, connection migration, security/proxy compatibility, and rollback.

A long-lived full-duplex framed channel after handshake. It does not add durable delivery, replay, authorization model, or scalable fan-out automatically.

Protocol-level liveness/keepalive and latency measurement; distinguish from application semantic heartbeats and intermediary idle timeouts.

Frames/messages are delivered in TCP order, but fragmentation, reconnect, multiple producers/connections, and regions require application sequence semantics.

Cookie with CSRF/origin controls or short-lived one-time ticket; TLS; validate Origin; avoid long-lived query tokens/log leakage; authorize subscriptions/messages.

Bound queue; coalesce/drop ephemeral data; persist durable messages separately; pause subscription if possible; disconnect with resume cursor; metrics and quotas.

If one-way updates and browser simplicity dominate, SSE; if bidirectional commands/binary/very low overhead needed, WebSocket. Discuss auth, reconnect, proxy, event IDs, and scale.

Any gateway accepts connection, presence lease maps users to gateways, durable message log/store with conversation sequence, pub/sub to interested gateways, ack/read receipts, dedupe, replay, slow-consumer policy.

Mark drain, stop new connections, bounded natural drain, server reconnect hint with jitter, canary percentage by connections, session/token compatibility, capacity headroom, rollback.

Aggregate per gateway, partition/hierarchical fan-out, cap/segment rooms, snapshot+delta, edge distribution, coalesce, priority, and measure deliveries rather than messages.

Client operation ID/idempotency, server durable status, ack only after defined commit, query/replay by ID, distinguish transport ack from business result.

Nearest gateways, document ownership/replicated operation log, sequence/version or CRDT/OT semantics, reconnect cursor/snapshot, auth changes, regional partition behavior, and gateway-independent durable state.

Per-connection memory/heartbeat, per-tenant connection and fan-out quotas, dedicated pools/regions for enterprise, fair queues, cost attribution, admission under failover, and migration between tiers.

REST exposes resources through a uniform interface; RPC exposes operations/method calls. Avoid claiming one uses HTTP and the other does not.

Client-selected typed response shapes and graph traversal for diverse clients; also mention resolver cost, caching, and governance.

At least once in practice: duplicates, delays, reordering, expiry. Verify signature and make processing idempotent.

Internal typed polyglot services, code generation, low overhead, streaming, deadline/cancellation support; discuss browser/proxy/public ecosystem constraints.

Add optional fields/defaults, preserve meaning, tolerate unknowns, schema checks, version where incompatible, replay old history, usage/deprecation telemetry.

Nested resolvers issue per-item backend calls. Use batching/data loaders, joins/read models, caching, and cost metrics.

Public mobile BFF/GraphQL or HTTP; internal gRPC for low-latency services; events for trip state/analytics/notifications; WebSocket/SSE for live location. Justify boundaries and consistency.

Subscription verification, signed events, stable IDs, ordering scope, at-least-once retries with jitter, endpoint caps, logs, replay/list API, secret rotation, SSRF defense, disable/reactivate policy.

Authentication/tenant quotas, depth/breadth and weighted cost, persisted/allowlisted queries for high scale, resolver timeouts, batching, response byte cap, concurrency, observability.

Autonomous consumer/local view and reduced callback pressure versus payload/privacy/schema duplication. Consider snapshot/version, authority, deletion, and reconciliation.

Catalog/ownership, standard identity/errors/deadlines/telemetry, schema review/compatibility CI, lifecycle/deprecation, client generation, cost quotas, exception process, production scorecards.

Identify facts/invariants, outbox, consumer idempotency, local read models, dual-run/shadow, lag/freshness SLOs, reconciliation, cutover per use case, and keep commands synchronous where immediate answer is required.

Repeating the same logical operation has the same intended effect. Explain operation identity, storage of result, and difference from merely using PUT.

Stable/efficient continuation on large mutable datasets; opaque cursor from sort key+tiebreaker. Mention limits and consistency semantics.

Appropriate 4xx status, stable machine code, per-field issues/path, human message, correlation, no sensitive internals.

Client reads version/ETag, sends If-Match, server atomically applies only if current version matches, otherwise 412/conflict and client refreshes/merges.

Create operation, 202, durable state/progress, polling with backoff and optional webhook, idempotency, cancellation, expiry, signed result URL, authorization.

Per-item stable ID/index and status/error, overall status semantics, retry only failed items with idempotency, limits and ordering.

Authenticated principal, idempotency key, source/destination/amount/currency, ledger transaction/invariants, operation state/receipt, concurrency, limits, timeout recovery, audit, no delete/update of ledger facts.

Choose snapshot token or live keyset; stable (rank/time,id) cursor; duplicates/misses policy; client dedupe; cursor expiry; ranking changes and cache implications.

SSRF defenses, URL scheme/port allow rules, DNS rebinding-aware resolution, block private/link-local, redirect policy, endpoint verification, signed deliveries, secret rotation, egress isolation.

Server default/inference first, add optional, update SDK/docs, measure adoption, warn/deprecate old behavior, only enforce in new operation/version when safe. Consider old stored resources and retries.

Identity/org hierarchy, tenant-scoped routing and data plane, cost-based quotas/concurrency, residency enforcement, dedicated tiers, audit, SDK/gateway policy, online tenant migration, support tooling.

Long support horizon, additive tolerant schema, capability negotiation, min/max versions, server-side defaults, signed config, staged kill switches, replay/idempotency retention, security update path.

Application reads cache, loads source on miss, writes cache; on writes it updates/invalidate separately. Mention stale windows and stampede.

Expiration is freshness policy/TTL; eviction removes entries for capacity/policy even if not expired.

At huge traffic 1% is large, expensive misses may dominate, distribution/hot shards matter, and a drop to 95% multiplies source load.

Single-flight/leases, TTL jitter, early refresh, stale-while-revalidate, negative caching, source concurrency limit, and bounded failure behavior.

Delete/update plus outbox/CDC event, version/generation, TTL fallback; discuss crash between DB commit and invalidation and race with fills.

Repeated absent/invalid lookups; short TTL, distinguish authoritative not-found from transient error, avoid hiding newly created data too long.

CDN/app/distributed layers, keys by locale/price context, version/TTL, invalidation via CDC, hot-key replication, stale policy, source protection, price correctness boundary.

Failover/stale snapshots, admission and miss budget, prioritize requests, rate-limited single-flight fills, prewarm top keys, autoscale source, degraded responses, monitor warm curve.

Timeline: miss reads old replica, write commits/invalidate, slow fill sets old. Include version in source/value and compare/CAS; route authoritative read or generation key.

Key principal/resource/action/policy epoch, short TTL or event invalidation, revocation SLO, deny/allow fail policy, audit, avoid cross-tenant leakage, bypass for high-risk actions.

Client/edge, regional L1/L2, source ownership, versioned data/invalidation, local stale reads, read-your-write routing, failover, cold-start protection, and cost/egress.

Per-tenant quotas/admission, workload classes, protected pools or frequency policy, max item size, cost-weighted eviction, borrowing rules, telemetry and billing.

Routes to upper tier/origin, fetches according to policy, may collapse concurrent requests, stores response if cacheable, and returns it.

Immutable long caching without purge; deploy new content at a new URL, old references remain correct, lifecycle later removes it.

Fraction of delivered bytes served from cache, often more relevant to origin bandwidth than request-count hit ratio.

Upper-tier cache between edge PoPs and origin, reducing duplicate fills/connections; adds concentration and miss-hop trade-off.

Edge validates time-limited signature/claims, then maps authorized request to content cache key; define token sharing, expiry, revocation, and whether token is excluded from key.

Prefer versioning; otherwise soft purge/stale revalidation, request collapse, shield, origin capacity/admission, staged rollout, and monitor fill.

Segmented/range media, object storage origin, immutable renditions, signed cookies/URLs, DRM/license separate, multi-tier cache, origin auth, regional rights, logs/egress, purge for takedown.

Bypass/purge, identify key/rule and affected scope, preserve evidence/notify, rotate sensitive tokens if needed, fix private/cache-control/Vary, synthetic multi-user tests, staged config.

Portable content/origin auth, traffic manager, consistent cert/DNS/cache keys, dual logging/purge, warm baseline, origin capacity for cold failover, health thresholds/hold-down, regular game days.

Auth/routing/redirect/A-B/light transform where latency/offload matters; avoid strong transactional invariants and heavy dependencies. Discuss limits, versioning, security, observability, fallback.

Content ID→all URL/variant tags, authenticated purge to all CDNs/tiers, denylist checked at edge, origin block, verification probes, audit, retries/escalation, offline clients and backup policy.

Measure byte misses by object/path/PoP, increase immutable versioning, normalize keys, tiered cache/shield, range optimization, preposition hot content, revalidation, compression, multi-CDN economics; validate freshness SLO.

Forward proxy represents clients toward servers; reverse proxy represents servers toward clients. Discuss egress vs ingress use cases.

L4 balances flows using transport metadata; L7 parses application protocol and can route/retry/auth/cache per request.

Requests differ in cost/duration, long connections pin, slow endpoints retain work, and weights/health may differ.

Remove endpoint from new work, allow in-flight/long-lived sessions to finish or receive close signal, enforce max drain, then terminate.

Connections may be idle or multiplex many requests; active request/work is often a better load signal, though distributed state can be stale.

Cache/local session optimization or protocol state; make soft, externalize durable state, handle hot clients and failover.

L7 termination/client-side policy, separate pools/classes, multiple HTTP/2 conns, active-stream/cost metrics, max connection age/drain, health, retries only unary/idempotent, slow-stream isolation.

Shallow representative check, dependency classification, thresholds, multi-vantage, max ejection/panic, stagger/jitter, capacity-aware failover, last-known-good.

Reserve N+1 capacity, local-first with weighted cross-zone, gradual capacity-aware shift, warm caches, protect databases, retry budget, load shed/degrade, monitor per-zone saturation.

External edge plus authenticated encrypted hop to workload; mTLS via proxy/app, identity/authorization, cert rotation, SNI, observability, and avoiding trust solely from network location.

Hierarchical global/regional/client balancing, capacity and health signals, data-residency constraints, control/data-plane separation, last-known-good, gradual shifts, overload, simulation/game days, audit.

Attempt telemetry, single owner, idempotency registry, per-route retry classes, deadline/budget, overload signals, max amplification SLO, canary and lint, charge attempts to tenant/service.

Changing N changes most hash mod N results, causing broad remap; consistent hashing limits movement to neighboring ranges/top scores.

Multiple logical token positions owned by one physical node, improving balance, weights, and movement granularity.

No; it balances many keys probabilistically. One hot key needs replication, caching, splitting, or special handling.

Primary owner plus additional distinct nodes/tokens, but enforce rack/zone diversity and avoid duplicate physical nodes due to vnodes.

Assign token ranges, stream snapshot from current replicas, catch up deltas, verify, mark ready/activate, then retire old ownership; throttle and version membership.

Both minimize movement; ring maps ranges/tokens, rendezvous scores nodes per key and naturally selects top-K. Compare lookup, metadata, weights, and streaming.

Weighted vnodes/rendezvous, replication, bounded load, health/membership, client/proxy routing, hot-key L1, gradual rebalance, simulation and metrics.

Membership epochs, server-side validation/redirect, fencing tokens/leases, idempotent retry, coordinator or consensus-backed ownership, cap redirect loops.

Topology-aware capacity, repair throttle/priorities, staged concurrency, spare disk/network, temporary replicas, foreground admission, restore zone before full rebalance when appropriate.

Tenant+time bucket+hash suffix trade-offs, large tenants, range queries, retention, write hotspots, scan fan-out, rebalancing, and directory for tenant placement.

Consensus/versioned membership, simulation/planner, constrained optimization for weights/domains/movement, staged plans, data readiness, fencing, throttles, pause/rollback, audit.

Small/static clusters; range queries needing ordered partitioning; directory-based placement for tenant isolation/moves; consensus leader groups; workloads where explicit mapping and operational control outweigh hash simplicity.

Atomic commit/abort, consistency through declared invariants, isolation of concurrent work according to a level, and durability according to the engine/configuration; distinguish ACID from business exactly-once.

It provides a searchable ordered/hashed structure, but every insert/update/delete may maintain pages, logs, cache, and constraints.

Structuring relations to reduce duplication and update anomalies; denormalize only with explicit ownership and synchronization semantics.

Start from exact filters/order, likely composite (tenant_id, status, created_at, id) or partial active index, cursor pagination, selectivity, coverage, and write cost; verify plan.

Atomic conditional decrement or locked inventory row, reservation expiry, unique operation ID, transaction boundaries, contention and sharding plan.

Async lag means a subsequent read can hit an older log position; use primary/session stickiness, commit-position wait, or expose eventual freshness.

Immutable entries, transaction/account IDs, balanced postings, unique idempotency key, currency/precision, states, constraints, reconciliation, read model, audit and reversal rather than deletion.

First inspect access/retention/indexes; then partition/archive, keyset scans, replicas, derived stores, maintenance and backup; shard only when measured single-node limits or isolation demand it.

Expand schema, stable mapping, dual-compatible code, transactional/CDC backfill, verification, foreign-key/index migration, switch reads/writes, rollback checkpoints, cleanup.

Find conflicting predicates/rows, verify retry correctness, shorten transactions, partition hot invariants, use commutative updates/reservations, bound admission, and preserve semantics.

Golden schemas/ownership, tenancy and isolation tiers, migration tooling, connection budgets, query governance, backups/restore tests, CDC contracts, SLOs, cost allocation, and escape hatches.

Balance autonomy against cross-domain invariants, operational maturity, shared reporting, coupling, compliance, and migration cost; reject both a universal shared schema and dogmatic database-per-service.

A family of non-relational or specialized models—not one guarantee—including key-value, document, wide-column, graph, search, and time-series systems.

Even heat and bounded size while colocating critical reads/atomic updates; test real skew and growth.

To serve known access patterns without joins/fan-out, accepting write amplification and synchronization/rebuild responsibility.

Orders are unbounded and independently queried/updated, so reference or bucket; embed bounded snapshots/profile children that share lifecycle.

Device/tenant plus time bucket and ordered timestamp, optional hash suffix for hot devices; retention, range fan-out, late data, and partition limits.

Operation key/unique token, conditional put/version, stored result/status, TTL based on replay window, and atomic relation to mutation.

Per-user placement, local writes, item operation model/merge, conflict semantics, session guarantees, replication/repair, TTL, inventory distinction, observability.

Per-shard skew, document/array size, index selectivity, scatter queries, cache, lock/update contention, replication/compaction, plans and top tenants.

Enumerate traversals and depth, update rate, supernodes, consistency, partitioning, precomputed recommendations, source of truth, and whether adjacency lists in KV/SQL outperform a graph engine.

Event/CDC source, idempotent consumer, ordering/version checks, backfill cut, dual-read comparison, lag SLO, repair/rebuild, deletion propagation.

Approved capabilities, workload decision records, ownership, schema/event standards, backup/RTO, data classification, cost, observability, lifecycle, and exception review.

Per-tenant telemetry, thresholds/hysteresis, directory placement, online copy+delta, fencing, routing epochs, capacity pool, rollback, billing and noisy-neighbor policy.

Replication copies data for availability/durability/read locality; sharding partitions data for capacity/throughput. Real systems combine both.

The write log is shipped/applied asynchronously or the read snapshot trails the leader.

Multiple nodes believe they are authoritative and accept conflicting work; prevent with quorum/terms/leases and fencing.

Carry commit/log position or session token; route/wait until a replica has applied it, otherwise use leader.

Tenant/customer/order locality, write distribution, time queries, largest tenant, cross-tenant admin analytics, retention, and online tenant moves.

Snapshot, change capture, catch-up, verify, epoch cutover, fallback/drain, delayed delete, throttling and idempotency.

Replication acknowledgment, failure detection, election/eligibility, fencing, promotion, routing/pool refresh, ambiguous retries, validation, failback, RPO/RTO metrics.

Identify global invariants, choose home-region/global consensus/escrow, read routing/session guarantees, partition behavior, residency, region loss and reconciliation.

More fan-out, smaller cache locality, connection overhead, metadata, background movement, skew, cross-shard coordination; inspect per-query partitions and slowest shard.

Directory epoch, snapshot and ordered delta, dual-read/fallback, target readiness, fenced cutover, reconciliation, throttles, rollback, tenant communication.

Inventory/telemetry, planner with constraints, versioned plans, admission budgets, data movers, checksums, fencing, pause/rollback, audit, SLO guardrails and human controls.

Classify RPO/RTO/latency/residency, standard topologies, cost, backup/restore, chaos tests, client contracts, observability and exception governance.

During a network partition, a distributed system cannot guarantee both linearizable consistency and a non-error response from every non-failing node for every operation.

A single-node system can avoid distributed partitions, but once correctness depends on communicating nodes, message loss/delay must be handled; the choice is behavior during it.

No. ACID C means transactions preserve application/database invariants; CAP C refers to atomic/linearizable visibility.

It cannot prove it remains the sole ordered authority; accepting could fork history. Rejection sacrifices formal availability to preserve consistency.

Not alone; discuss replica membership, versioning, concurrent writes, failed/sloppy quorums, read algorithm, and repair.

Shopping-cart item additions or telemetry with unique event IDs can accept both sides and union/deduplicate, provided domain merge and later repair are defined.

Uniqueness needs authoritative quorum/home ownership or tentative reservation with possible rejection; describe API state, timeout, fencing, and reconciliation.

Classify grants vs revocations, max staleness, fail-open/closed by action risk, signed expirations/version, emergency kill path, audit.

Strong global counter versus regional token leases/escrow, bounded overshoot, allocation, expiry, partition behavior, hot keys, observability and abuse.

Identify concurrent versions, apply domain merge/operation replay, preserve audit, repair replicas/indexes, notify for irreconcilable conflict, throttle recovery.

Named operation-level guarantees, permitted staleness/errors, client tokens, topology, SLOs, test harnesses, metrics, and examples for money/auth/content/analytics.

Replace labels with objects/operations, partition scope, responses, invariants, normal latency trade, recovery, dependencies, and migration assumptions.

API-addressed whole objects and metadata, typically flat key namespace and no general in-place random writes/rename semantics; built for massive scale/durability.

Parallelism, resumability, and retrying only failed parts; completion atomically publishes the assembled object.

A time-limited bearer authorization for a scoped object operation; it must be narrow, protected, and verified by application workflow.

Pending metadata, scoped URL, size/type policy, direct transfer, checksum/head verify, scan/transform, ready state, orphan cleanup and idempotency.

Prefer new immutable version/key plus conditional pointer update; use ETag/version precondition if mutating at key; handle retries and cache invalidation.

Treat as at-least-once/out-of-order trigger; dedupe on key+version, persist progress, and reconcile with inventory.

Chunk/multipart upload, content IDs, metadata tree, versions, dedupe scope/security, sync cursors, range/download CDN, sharing auth, conflicts, lifecycle and recovery.

Authoritative deletion request/state, immediate access denial, enumerate versions/replicas/derivatives/caches/indexes, idempotent workers, legal holds, evidence and backup policy.

Cache key/headers/auth, range behavior, invalidation, origin shield, signed URL variance, cold miss stampede, egress/connection limits, attack patterns.

Immutable files, partitioning and file size, staging, checksums, manifest/table metadata atomic commit, idempotent job/event, schema evolution, compaction and vacuum.

Tenancy, namespaces, direct-transfer API, policy guardrails, malware pipeline, encryption/KMS, lifecycle classes, cost/quotas, events/inventory, deletion, DR and SLOs.

Inventory and checksums, dual-read/write or log, parallel copy, bandwidth/cost, immutable versions, validation, routing cutover, delta catch-up, rollback, deletion and compliance.

Decouple timing/rate, buffer bursts, retry work, and isolate producers from consumer availability—while accepting asynchronous state and operational backlog.

A message may be redelivered until acknowledged, so consumers must tolerate duplicates.

A quarantine for messages that exceed retry/permanent-failure policy; it requires alerts, diagnostics, ownership, and safe redrive.

Transactional outbox/CDC; relay can duplicate; consumer uses stable event ID/version.

Choose an entity ordering key mapped to one partition, one active partition owner, safe offset commit, and version guards; avoid unnecessary global order.

Above expected high-percentile work or extend by heartbeat; finite for crash retry; account for duplicates and split long jobs.

Preference/consent snapshot, outbox event, template/version, idempotent send key, priority, rate/provider limits, retries/DLQ, expiry, delivery callbacks, audit/privacy.

Immutable ledger authority, unique operation ID, ordered account/payment state, atomic inbox+posting, ambiguous processor response, reconciliation and alerting.

Calculate net drain, protect dependencies, add bounded parallelism/partitions, prioritize/expire, pause retries, monitor age, rebuild projection if faster, communicate SLO.

Compatibility policy/registry, additive rollout, consumer inventory, dual/new type for semantic break, mixed-version tests, backfill IDs, deprecation telemetry.

Tenancy, schemas/catalog, auth/privacy, topic/partition quotas, SLOs, lineage, outbox/CDC, replay, DR, cost, self-service, guardrails and incident ownership.

Scope each boundary, unique operation IDs, atomic local state/inbox/outbox, idempotent external API or reconciliation, state machine, audit and proofs/limits.

Map transforms input records into keyed intermediates; shuffle groups same keys; reduce combines each key’s values into output.

Partitioning, transfer, sorting/merging, and grouping of mapper output to reducers; often the dominant network/disk cost.

When its partial output can be merged with the same algebra under arbitrary zero/multiple invocations—typically associative and commutative state.

Emit/merge (sum, count), then divide after final reduction; do not average partial averages without weights.

Broadcast/map-side join if the small side fits each worker; otherwise reduce-side or co-partitioned join, with skew/multiplicity analysis.

Heavy key/range, larger records, bad host, spill/fetch, malformed input; compare bytes/records/progress and handle deterministic skew separately.

Partition pruning, dedupe identity/window, exact sort/set versus mergeable HLL with error, combiner, skew, late data, output version, validation/backfill.

Tokenize map term→doc/positions, local combine, partition by term, sort/compress postings, handle stop/heavy terms, immutable segments/manifest, incremental merge.

Profile stage/bytes/skew, prune/project, combine, broadcast/partition joins, file sizing, parallelism, resource bottleneck, incremental computation, and validate cost/SLO.

Snapshot inputs/code/schema, run-isolated output, idempotent partitions, data-quality comparison, catch-up delta, manifest cutover, rollback, lineage and cleanup.

Split/file formats, scheduler, shuffle service, retries/speculation, quotas/fairness, catalog/lineage, schemas, secrets, observability, publication, cost and multi-tenancy.

Freshness/correction/replay, event time, cost, state size, joins, ownership, one logic path, SLOs, backfills and auditability.