Reference library

System design patterns

Sharding, load balancing, CAP tradeoffs, and scaling patterns — interview and production ready.

5 matches

Circuit Breaker Pattern in Python: Closed, Open, and Half-Open States

Implement a circuit breaker with closed, open, and half-open states to prevent repeated calls to failing services and allow recovery after a timeout.

circuit-breaker resilience fault-tolerance

Python

class CircuitBreaker:
    def __init__(self, failure_threshold=3, timeout_seconds=5):
        self.failure_threshold = failure_threshold
        self.timeout_seconds = timeout_seconds
        self.state = "closed"
        self.failure_count = 0
        self.last_failure_time = None

    def record_success(self):
     …

14 0 Open

System design patterns medium

How to Implement Retry with Exponential Backoff and Jitter in Python

This code demonstrates a retry mechanism with exponential backoff and optional full jitter, using a flaky mock network call for testing.

retry backoff jitter

Python

import random
import time


def retry_with_backoff(func, max_attempts=5, base_delay=0.1, jitter=True):
    """
    Retry a function with exponential backoff and optional full jitter.
    """
    for attempt in range(max_attempts):
        try:
            return func()
        except Exception as e:
            if att…

14 0 Open

System design patterns easy

How to Mock the Ambassador Pattern Retry Client in Python

This code demonstrates the ambassador pattern for API clients by simulating a flaky request and retrying with exponential backoff, useful for testing resilience in system design.

retry ambassador-pattern mock

Python

import time
import random


class RetryingClient:
    """Retry wrapper simulating a flaky ambassador-style API client."""

    def __init__(self, max_attempts=3, base_delay=0.1):
        self.max_attempts = max_attempts
        self.base_delay = base_delay
        self.attempts = 0

    def _flaky_request(self):
     …

15 0 Open

System design patterns medium

How to implement stale-while-revalidate caching in Python

A Python cache wrapper that returns a stale cached value with a fallback flag when the upstream fetch fails, using TTL-based freshness checks.

caching ttl resilience

Python

import time
from functools import lru_cache


class CachedService:
    def __init__(self, fetch_func, ttl=5):
        self.fetch_func = fetch_func
        self.ttl = ttl
        self._cache = {}
        self._timestamp = {}

    def get(self, key):
        now = time.time()
        if key in self._cache and now - self…

12 0 Open

System design patterns medium

Implement Bulkhead Thread Pool Isolation in Python

Create isolated thread pools with a bulkhead pattern to protect different services from cascading failures.

bulkhead threadpool concurrency

Python

import threading
import time
import random
from concurrent.futures import ThreadPoolExecutor


class Bulkhead:
    """Simple bulkhead isolation: separate thread pools for different tasks."""

    def __init__(self, max_workers):
        self.executor = ThreadPoolExecutor(max_workers=max_workers)
        self.active = …

13 0 Open

Browse by section

Each section groups closely related Python snippets.