Introduction

In 1879, Edison did not just flip a switch — he borrowed an idea from telegraph engineers: a circuit breaker that trips open under excess current, protecting the whole grid from a single short. More than a century later, software architects rediscovered the same principle for distributed systems.

A modern platform is a web of microservices. Each service calls others — payment, inventory, notifications — and each of those calls can fail or hang. When the payment service starts timing out, the threads waiting for it pile up. Soon every service that touched payment is also stuck, and the cascade rolls upward until the front door itself goes dark.

The circuit breaker pattern breaks that chain. It wraps every outbound call in a proxy that counts failures. Once failures cross a threshold it trips open: instead of hammering a sick dependency, it returns an error immediately, freeing resources for the calls that can still succeed. After a timeout it probes once — half-open — and if the dependency has recovered, it closes again. Three states, one invariant: protect the caller from the callee's problems.

Martin Fowler popularized the pattern in 2014, but the same logic appears under names like bulkhead, retry with backoff, and timeout in every resilience library from Netflix Hystrix to Resilience4j and Polly. The insight predates microservices: any system built from unreliable parts needs a way to stop one failure from becoming all failures.

Try It

Below is a live circuit breaker wrapping a flaky service. Hit Call service to make requests. The service fails randomly — when failures exceed the threshold the breaker trips open and short-circuits future calls immediately. After the timeout it enters half-open and lets one probe through. If that probe succeeds, the breaker closes; if it fails, it opens again.

<div class="panel">
  <div class="state-row">
    <span class="label">Breaker state:</span>
    <span id="state-badge" class="badge closed">CLOSED</span>
  </div>
  <div class="counters">
    <div class="counter-box">
      <div class="counter-value" id="c-success">0</div>
      <div class="counter-label">Successes</div>
    </div>
    <div class="counter-box">
      <div class="counter-value" id="c-failure">0</div>
      <div class="counter-label">Failures</div>
    </div>
    <div class="counter-box">
      <div class="counter-value" id="c-rejected">0</div>
      <div class="counter-label">Rejected</div>
    </div>
  </div>
  <div class="log-box" id="log"></div>
  <div class="config-row">
    <label>Failure rate: <b id="rate-val">60</b>%
      <input id="rate" type="range" min="0" max="100" value="60"></label>
    <label>Threshold: <b id="thr-val">3</b> failures
      <input id="thr" type="range" min="1" max="8" value="3"></label>
    <label>Timeout: <b id="to-val">4</b>s
      <input id="to" type="range" min="1" max="10" value="4"></label>
  </div>
  <div class="btns">
    <button id="btn-call">Call service</button>
    <button id="btn-reset" class="ghost">Reset</button>
  </div>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: .5rem; }
.panel { max-width: 420px; margin: 0 auto; }
.state-row { display: flex; align-items: center; gap: .6rem; margin-bottom: .8rem; }
.label { font-weight: 600; }
.badge { padding: .25rem .7rem; border-radius: 20px; font: 700 .8rem ui-monospace, monospace; letter-spacing: .05em; }
.badge.closed { background: #d1fae5; color: #065f46; }
.badge.open { background: #fee2e2; color: #991b1b; }
.badge.half { background: #fef3c7; color: #92400e; }
.counters { display: flex; gap: .5rem; margin-bottom: .7rem; }
.counter-box { flex: 1; background: #f3f4f6; border-radius: 8px; padding: .5rem; text-align: center; }
.counter-value { font: 700 1.4rem ui-monospace, monospace; }
.counter-label { font-size: .72rem; color: #6b7280; margin-top: .15rem; }
.log-box { background: #f8fafc; border: 1px solid #e2e8f0; border-radius: 8px;
           height: 140px; overflow-y: auto; padding: .5rem .7rem;
           font: .8rem ui-monospace, monospace; margin-bottom: .7rem; }
.log-box .entry { border-bottom: 1px solid #e9ecef; padding: .15rem 0; display: flex; gap: .5rem; }
.log-box .ts { color: #94a3b8; flex-shrink: 0; }
.ok { color: #059669; }
.fail { color: #dc2626; }
.rej { color: #b45309; }
.probe { color: #7c3aed; }
.config-row { display: flex; flex-direction: column; gap: .4rem; font-size: .85rem; margin-bottom: .7rem; }
.config-row label { display: flex; align-items: center; gap: .5rem; }
.config-row input[type=range] { flex: 1; }
.btns { display: flex; gap: .5rem; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem;
         border: 1px solid #1d3557; background: #1d3557; color: #fff;
         border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Circuit Breaker state machine
// States: CLOSED -> OPEN -> HALF_OPEN -> CLOSED (or OPEN again)
const CLOSED = 'CLOSED', OPEN = 'OPEN', HALF = 'HALF_OPEN';

let state = CLOSED;
let failCount = 0;      // consecutive failures in CLOSED window
let openUntil = 0;      // timestamp when OPEN expires
let counts = { success: 0, failure: 0, rejected: 0 };

function getThreshold() { return +document.getElementById('thr').value; }
function getTimeout()   { return +document.getElementById('to').value * 1000; }
function getRate()      { return +document.getElementById('rate').value / 100; }

function updateBadge() {
  const b = document.getElementById('state-badge');
  b.textContent = state === HALF ? 'HALF-OPEN' : state;
  b.className = 'badge ' + (state === CLOSED ? 'closed' : state === OPEN ? 'open' : 'half');
}

function updateCounters() {
  document.getElementById('c-success').textContent = counts.success;
  document.getElementById('c-failure').textContent = counts.failure;
  document.getElementById('c-rejected').textContent = counts.rejected;
}

function log(cls, msg) {
  const box = document.getElementById('log');
  const now = new Date();
  const ts = now.toLocaleTimeString([], { hour12: false });
  const e = document.createElement('div');
  e.className = 'entry';
  e.innerHTML = `<span class="ts">${ts}</span><span class="${cls}">${msg}</span>`;
  box.prepend(e);
}

// Simulate flaky upstream call: resolves true (success) or false (failure)
function callUpstream() {
  return Math.random() >= getRate(); // probability (1 - rate) of success
}

function transition(newState) {
  state = newState;
  if (newState === OPEN) {
    openUntil = Date.now() + getTimeout();
  }
  updateBadge();
}

function call() {
  const now = Date.now();

  if (state === OPEN) {
    if (now < openUntil) {
      // Still open — reject immediately
      counts.rejected++;
      updateCounters();
      log('rej', '⊘ REJECTED — breaker is OPEN (fast fail)');
      return;
    } else {
      // Timeout elapsed — move to half-open for one probe
      transition(HALF);
      log('probe', '⟳ Timeout elapsed → HALF-OPEN, sending probe…');
    }
  }

  // CLOSED or HALF-OPEN: attempt the real call
  const ok = callUpstream();

  if (state === HALF) {
    if (ok) {
      counts.success++;
      transition(CLOSED);
      failCount = 0;
      log('ok', '✓ Probe SUCCESS → breaker CLOSED');
    } else {
      counts.failure++;
      transition(OPEN);
      log('fail', '✗ Probe FAILED → breaker back to OPEN');
    }
  } else {
    // CLOSED
    if (ok) {
      counts.success++;
      failCount = 0;
      log('ok', '✓ Call succeeded');
    } else {
      counts.failure++;
      failCount++;
      log('fail', fmt('✗ Call failed (%failCount%/%getThreshold% failures)', { failCount: failCount, getThreshold: getThreshold() }));
      if (failCount >= getThreshold()) {
        transition(OPEN);
        log('fail', fmt('⚡ ⚡ Threshold reached → breaker OPEN for %v%s', { v: getTimeout()/1000 }));
        failCount = 0;
      }
    }
  }
  updateCounters();
}

function reset() {
  state = CLOSED; failCount = 0; openUntil = 0;
  counts = { success: 0, failure: 0, rejected: 0 };
  document.getElementById('log').innerHTML = '';
  updateBadge(); updateCounters();
  log('ok', 'Breaker reset — state: CLOSED');
}

// Slider sync
['rate','thr','to'].forEach(id => {
  const el = document.getElementById(id);
  const out = document.getElementById(id === 'rate' ? 'rate-val' : id === 'thr' ? 'thr-val' : 'to-val');
  el.addEventListener('input', () => { out.textContent = el.value; });
});

document.getElementById('btn-call').addEventListener('click', call);
document.getElementById('btn-reset').addEventListener('click', reset);

// Initial state log
log('ok', 'Breaker initialized — state: CLOSED');
updateBadge(); updateCounters();

// Verify (node-safe assertions — run in browser sandbox, not node)
// Core logic assertion: at threshold=3 with forced failures the breaker must open.
(function selfTest() {
  let s = CLOSED, fc = 0, thr = 3;
  function forceCall(success) {
    if (s === OPEN) return 'REJECTED';
    if (success) { fc = 0; return 'OK'; }
    fc++; if (fc >= thr) { s = OPEN; fc = 0; } return 'FAIL';
  }
  forceCall(false); forceCall(false); forceCall(false);
  console.assert(s === OPEN, 'SELF-TEST FAILED: breaker should be OPEN after 3 failures');
  console.log('circuit-breaker self-test: state after 3 failures =', s, '— expected OPEN');
})();
Result
Console

Notice the asymmetry: while the breaker is open, calls return in microseconds with a predictable error — callers are not blocked waiting for a dependency that cannot respond. That instant rejection is exactly what prevents thread exhaustion and cascading failures upstream.

The Real Complexity

The circuit breaker is a solved design pattern — every cloud SDK ships one. But calling it "solved" hides the hard parts.

The three-state machine is well-defined:

  • Closed — normal operation; failures are counted.
  • Open — all calls rejected immediately for a fixed timeout.
  • Half-open — one probe is allowed; success → closed, failure → open.

The transitions look simple until you ask: how many failures trigger a trip? A threshold of 5 in 10 seconds behaves very differently from 50% of the last 100 calls. Netflix Hystrix defaulted to 50% of 20 calls; Resilience4j lets you choose count-based or time-based sliding windows.

Harder questions practitioners face:

  • Timeout calibration — too short and the breaker never lets a slow-starting dependency recover; too long and callers wait longer than users tolerate.
  • Fallback strategy — what do you return when the breaker is open? A stale cache? A degraded response? Nothing? Each choice shifts the trade-off between consistency and availability — the same tension at the heart of the CAP theorem.
  • Cascading breakers — if service A wraps service B which wraps service C, and all three have breakers, the combined failure dynamics can produce non-obvious oscillation.
  • Observability — a breaker that trips silently is almost worse than no breaker; you need metrics, logs, and alerts on every state transition.

None of these questions have a universal answer. The pattern is proven; the parameterization is an engineering art shaped by each system's latency budget and failure model. That gap between pattern known and parameters tuned is where most resilience incidents actually live.

Where It Matters

The circuit breaker is one of the highest-leverage patterns in distributed systems. It appears wherever one component depends on another that can be slow or unavailable:

  • API gateways — Kong, AWS API Gateway, and NGINX all support circuit-breaking middleware that shields backend services from thundering-herd retries.
  • Service meshes — Istio and Linkerd implement breakers in the sidecar proxy, invisible to application code. Operators tune them via YAML; services never know they are being protected.
  • JVM ecosystems — Netflix Hystrix (now in maintenance) popularized the pattern; Resilience4j is its modern successor, offering count- and time-based sliding windows, bulkheads, and rate limiters as composable decorators.
  • Database connection pools — PgBouncer and HikariCP use breaker-like logic to detect unhealthy primaries and reroute before connection exhaustion.
  • Mobile and IoT clients — devices in low-connectivity environments use breakers and exponential backoff to avoid draining batteries hammering unreachable endpoints.

The common thread: every layer that calls something it does not control benefits from a breaker. Without it, one slow dependency and a burst of traffic can collapse an otherwise healthy platform in seconds. This same "protect the whole from one part" logic connects to load balancing and broader distributed systems resilience strategies.

Conclusion

Edison's circuit breaker protected a copper wire from a short circuit. The software circuit breaker protects a whole microservice platform from a slow HTTP call. The physics changed; the logic did not: detect a fault early, open the path, give the system time to recover, then try again cautiously.

Three states. One invariant. Tuning that takes judgment.

The pattern is not magic — a breaker configured with the wrong thresholds, no fallback, and no alerting can make incidents worse by silently dropping traffic while operators stare at empty dashboards. Done well, though, it is one of the most effective ways to move from systems that fail together to systems that degrade gracefully.

The next time a third-party API goes dark at peak traffic, you will want a breaker already in place. That is the promise of the pattern: fail fast, recover automatically, and never let one bad dependency become everyone's problem.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/circuit-breaker/Content licensed under CC BY-NC 4.0.