Circuit breaker

Overview

A circuit breaker wraps calls to a dependency and stops calling it when it is failing, so the caller fails fast instead of waiting on timeouts and piling up threads. Like an electrical breaker, it has three states: closed (calls flow normally while failures are counted), open (calls are rejected immediately for a cool-down period), and half-open (a few trial calls test whether the dependency has recovered).

Circuit breakers protect both sides: the caller keeps its resources free, and the struggling dependency gets breathing room to recover instead of being hammered by retries. They are usually combined with timeouts, fallbacks, and metrics.

When to use it

• Calls to remote services that can fail or become slow.
• Preventing cascading failures in microservices.
• Third-party APIs with outages.
• Anywhere retries could overwhelm a struggling dependency.

Where it shows up in interviews

Where it is used in real software

Key terms

Closed

Normal operation; failures are counted.

Open

Calls fail immediately without reaching the dependency.

Half-open

Limited trial calls to test recovery.

Failure threshold

Error or slow-call rate that trips the breaker.

Sliding window

Recent calls used to compute the failure rate.

How it works, step by step

1. 1
   Closed: count outcomes

   Track failures and slow calls in a sliding window.

2. 2
   Trip to open

   When the failure rate exceeds the threshold (with a minimum number of calls).

3. 3
   Open: fail fast

   Return a fallback or error immediately.

4. 4
   After the wait time: half-open

   Allow a few trial calls.

5. 5
   Close or re-open

   Trials succeed: close; fail: open again.

Timeline of an outage with a breaker

Threshold 50% over 20 calls, open for 30 s

Without the breaker, every request during the outage would wait for a timeout, exhausting threads and spreading the failure.

Implementation

1type State = "closed" | "open" | "half-open";2 3export class CircuitBreaker {4  private state: State = "closed";5  private results: boolean[] = [];6  private openedAt = 0;7  private trials = 0;8 9  constructor(private opts = { window: 20, minCalls: 10, failureRate: 0.5, openMs: 30_000, halfOpenTrials: 3 }) {}10 11  async call<T>(fn: () => Promise<T>, fallback: () => T): Promise<T> {12    if (this.state === "open") {13      if (Date.now() - this.openedAt < this.opts.openMs) return fallback();14      this.state = "half-open";15      this.trials = 0;16    }17    if (this.state === "half-open" && this.trials >= this.opts.halfOpenTrials) return fallback();18    if (this.state === "half-open") this.trials++;19 20    try {21      const value = await fn();22      this.record(true);23      return value;24    } catch {25      this.record(false);26      return fallback();27    }28  }29 30  private record(ok: boolean) {31    if (this.state === "half-open") {32      if (!ok) return this.trip();33      if (this.trials >= this.opts.halfOpenTrials) { this.state = "closed"; this.results = []; }34      return;35    }36    this.results = [...this.results.slice(-(this.opts.window - 1)), ok];37    const failures = this.results.filter((r) => !r).length;38    if (this.results.length >= this.opts.minCalls && failures / this.results.length >= this.opts.failureRate) this.trip();39  }40 41  private trip() { this.state = "open"; this.openedAt = Date.now(); }42}

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Counting client errors (400s) as failures.

  Fix: Only count dependency failures (timeouts, 5xx).

• No fallback strategy.

  Fix: Decide what to return when open: cached data, default, or clear error.

• Breakers without monitoring.

  Fix: Emit state changes as metrics and alerts.

Interview questions

Practice problems