Reference library

System design patterns

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

5 matches

How to Build an Immutable Money Value Object in Python

Implement an immutable Money class with rounded decimal amounts, currency, safe equality, and hashing for use as a value object.

value-object immutability money

Python

class Money:
    def __init__(self, amount: float, currency: str):
        object.__setattr__(self, "_amount", round(amount, 2))
        object.__setattr__(self, "_currency", currency)

    def __setattr__(self, name, value):
        raise AttributeError(f"Money is immutable: cannot set '{name}'")

    def __delattr__…

13 0 Open

System design patterns medium

How to Limit Concurrent Requests with a Semaphore in Python

Use threading.Semaphore with a ThreadPoolExecutor to cap how many worker threads run simultaneously, preventing resource overload.

concurrency semaphore threading

Python

import threading
import time
from concurrent.futures import ThreadPoolExecutor

def worker(name, semaphore, results):
    with semaphore:
        results.append(f"start {name}")
        time.sleep(0.5)  # simulate async work
        results.append(f"done {name}")

def main():
    sem = threading.Semaphore(2)  # max 2 …

14 0 Open

System design patterns medium

How to Structure a Three-Tier Layered Architecture in Python

A mock three-tier architecture with presentation, business, and data layers that process a user request from input to response.

architecture layered design-pattern

Python

class PresentationLayer:
    def __init__(self, business_layer):
        self.business = business_layer

    def handle_request(self, user_id):
        print(f"[Presentation] Received request for user {user_id}")
        data = self.business.process_user(user_id)
        print(f"[Presentation] Response: {data}")
     …

12 0 Open

System design patterns medium

Inbox pattern consumer dedupe mock in Python

Implements a mock inbox consumer that deduplicates incoming messages by ID, with automatic eviction of old seen IDs to prevent unbounded memory growth.

deduplication inbox-pattern dataclasses

Python

import json
from collections import deque
from dataclasses import dataclass, field
from hashlib import sha256
from typing import Any


@dataclass
class InboxConsumer:
    max_seen: int = 1000
    seen_ids: set = field(default_factory=set)
    seen_history: deque = field(default_factory=deque)

    def _mark_seen(self,…

13 0 Open

System design patterns medium

Simulate a Leaky Bucket Rate Limiter in Python

This code implements a leaky bucket rate limiter that drains at a fixed rate and accepts or rejects incoming requests based on capacity.

rate limiting leaky bucket simulation

Python

import time
from collections import deque


class LeakyBucket:
    """Simulates a leaky bucket rate limiter with a fixed drain rate."""
    def __init__(self, capacity, drain_rate_per_sec):
        self.capacity = capacity
        self.drain_rate = drain_rate_per_sec
        self.water = 0.0
        self.last_refill =…

13 0 Open

Browse by section

Each section groups closely related Python snippets.