Protect your service from a misbehaving downstream by failing fast.

States

 [ Closed ] --(N consecutive failures)-->  [ Open ]
      ^                                       |
      |                              (after T seconds)
      |                                       v
      +------(probe success)---- [ Half-Open ]
                       (probe failure)
                       back to Open

When to use

• Any call to a downstream service that could go slow / down.
• Prevent cascading failure across microservices.

Pitfalls

• Hardcoded timeouts: too short triggers constant half-open; too long delays recovery.
• Counting application-wide failures: one user’s broken session shouldn’t open the breaker for all.
• Not distinguishing fast-fail from timeout: each has a different break threshold.

Code (simple)

class Breaker:
    def __init__(self, fail_threshold=5, reset_seconds=30):
        self.fail = 0
        self.threshold = fail_threshold
        self.reset = reset_seconds
        self.open_until = 0
 
    def call(self, fn, *a, **kw):
        if time.monotonic() < self.open_until:
            raise CircuitOpen()
        try:
            r = fn(*a, **kw); self.fail = 0; return r
        except Exception:
            self.fail += 1
            if self.fail >= self.threshold:
                self.open_until = time.monotonic() + self.reset
            raise

Analogy

An electrical breaker in your house: too many appliances trip it, halting the kitchen to protect the rest.

Interview tip: Quote the closed/open/half-open transition explicitly — candidates forget half-open often.