Search the practice set
126 questions, 454 terms and 400 topics in 20 areas.
60 results for “Distributed Tracing”
Distributed Tracing
Following one logical request across every service it touches by propagating a shared trace identifier and recording timed spans.
Application Performance Monitoring
Instrumentation inside the application that attributes latency and errors to specific code paths, queries and dependencies.
At-Least-Once Delivery
The guarantee that a message will be delivered, possibly more than once — the practical default in every distributed messaging system.
Atomic Commit Protocol
Any protocol ensuring that several participants reach the same decision to commit or abort — and a problem provably unsolvable with certainty in an asynchronous system with failures.
Backpressure
A mechanism by which a component under load tells its callers to slow down, rather than accepting work it cannot complete.
Bulkhead
Partitioning resources so that exhaustion caused by one dependency or tenant cannot starve the others.
CAP Theorem
During a network partition a distributed system must choose between consistency and availability; it cannot have both.
Causal Consistency
A model guaranteeing that operations which causally depend on one another are seen in the same order everywhere, while concurrent operations may be seen in any order.
Circuit Breaker
A proxy that stops calling a failing dependency after a failure threshold, failing fast instead, and periodically tests whether it has recovered.
Competing Consumers
Multiple identical consumers reading from one queue, so throughput scales with consumer count and work is distributed automatically.
Consistent Hashing
A hashing scheme where adding or removing a node remaps only a small fraction of keys, instead of nearly all of them.
Content Delivery Network
A geographically distributed cache that serves content from a location near the user instead of from the origin.
Correlation ID
A single identifier attached to one logical operation and included in every log line it produces, anywhere in the system.
DNS
The distributed directory that resolves names to addresses, and a surprisingly load-bearing part of most architectures.
Egress Path Analysis
Tracing where data physically moves in an architecture, because transfer charges follow paths that appear nowhere on the diagram.
Event Stream
An append-only, retained log of events that many independent consumers read at their own position, and can re-read.
Eventual Consistency
A guarantee that replicas will converge to the same value if updates stop, with no bound on how long reads may be stale.
Exponential Backoff
Increasing the wait between retries geometrically, with random jitter, so that failures do not synchronise into a stampede.
Fan-Out
One incoming request causing many outgoing ones, which multiplies both load and tail latency.
Fault Tolerance
Continuing to operate correctly despite the failure of some components, by design rather than by luck.
Graceful Degradation
Continuing to deliver reduced but useful function when a dependency fails, instead of failing the whole request.
Idempotency
The property that performing an operation many times has the same effect as performing it once.
Leader Election
The process by which a group of nodes agrees which one of them is currently in charge of a task that must not run twice.
Linearizability
The strongest single-object guarantee — every operation appears to take effect instantaneously at some point between its call and its return.
Load Shedding
Deliberately rejecting a portion of incoming work during overload so that the remainder can be served correctly.
Lock Lease Expiry
The timeout on a distributed lock that prevents a crashed holder deadlocking the system — and the source of the pattern's hardest failure mode.
Message Queue
A store that holds messages until a consumer processes them, decoupling producer availability and rate from consumer availability and rate.
Microservices
An architectural style where an application is a set of independently deployable services, each owning its data and aligned to a business capability.
Monolith vs Microservices
A trade of deployment independence against distributed-systems complexity, decided by team topology far more often than by technology.
Optimistic Concurrency Control
Allowing concurrent work without locks and detecting conflict at write time by checking that the underlying version has not changed.
A nightly job occasionally runs twice, producing duplicate charges. The team proposes a distributed lock. What do you say?
The first response A lock will reduce the frequency and will not eliminate it , and if the team believes otherwise they will stop looking for the real fix. The
Placing an order must reserve stock, charge the card and create a shipment across three services. Design it, and justify why not a distributed transaction.
First: question the boundary A transaction spanning three services often means one invariant has been split across three owners. Before designing a protocol, ch
Prime Video reported a 90% cost cut by consolidating a serverless distributed service into one process. Does that mean microservices were the wrong choice, and what is the actual decision rule?
What actually happened The Prime Video Video Quality Analysis team's 2023 post describes an audio/video monitoring service built as Step Functions orchestrating
Three designs need distributed locks: a nightly report, a per-customer state machine, and a global config reload. For each, is a lock the right answer?
The nightly report — a lock is acceptable Purpose: efficiency . Two instances generating the same report wastes compute and possibly sends two emails, but nothi
A 43-second network partition caused GitHub over 24 hours of degraded service in 2018. How does a 43-second event become a day-long incident?
The case, as publicly reported On 21 October 2018, routine maintenance replacing failing optical equipment caused a 43 second loss of connectivity between GitHu
A card payment authorisation service runs active-active across two regions. A network partition splits them. Do you keep accepting authorisations, and what breaks either way?
What the interviewer is testing Whether you can apply CAP to a domain where the cost of each choice is concrete, and whether you recognise that "it depends" has
A downstream service slows from 50 ms to 3 s. Within two minutes every service in the request path is down, including ones that do not call it. Explain the mechanism and how you would have prevented it.
What the interviewer is testing Whether you understand that most outages are amplification, not failure — and whether you can name the specific mechanism rather
An order service must notify inventory, billing, shipping and analytics when an order is placed. Synchronous calls or events? Justify your choice per consumer.
What the interviewer is testing Whether you apply the decision per interaction rather than adopting one style globally. The framing that matters Synchronous cal
Design an order submission API that is safe when the client cannot tell whether its request succeeded. What exactly do you store, and when?
What the interviewer is testing Whether you know that "make it idempotent" is a design with specific failure modes, not a checkbox. The core design The client g
Distributed Tracing
Reconstructing one request's path across every service it touched.
Centralised vs Distributed
Shared platform leverage against team autonomy.
Debugging Distributed Systems
Localising a regression when every service reports healthy.
Distributed Locking
Mutual exclusion across machines, and why it is harder than it looks.
Distributed Systems
General material on partial failure, coordination and distributed reasoning.
Distributed Transactions
Two-phase commit, its blocking failure mode, and when it is still reasonable.
Backpressure & Flow Control
Telling callers to slow down instead of buffering into congestion collapse.
Bulkheads & Isolation
Partitioning resources so one dependency cannot starve the others.
CAP & PACELC
What you must give up during a partition, and the latency choice the rest of the time.
Circuit Breakers
Failing fast on a broken dependency, and what you fail fast to.
Clocks & Ordering
Why wall clocks lie, and how logical clocks and versions restore order.
Consensus Protocols
Raft, Paxos and quorums — what they guarantee and what they cost.
Consistency Models
Linearizable, sequential, causal, eventual, and the session guarantees between them.
Event Streaming
Retained ordered logs, consumer offsets, partitions and replay.
Failure Modes
Slow rather than down, partial, grey, and failing while reporting success.
Idempotency
Making an operation safe to repeat, because a client that times out cannot know.
Leader Election
Agreeing who is in charge, and fencing the one who no longer is.
Load Shedding
Rejecting some work deliberately so the rest can be served correctly.
Messaging & Queues
Decoupling producer from consumer, and the semantics that come with it.
Microservices
Independent deployability, and the distributed problems it buys.