System design patterns
Sharding, load balancing, CAP tradeoffs, and scaling patterns — interview and production ready.
How to Build a Simple Service Discovery Registry in Python
A lightweight in-memory service registry class using a dict — register, deregister, and discover services with host, port, and version.
class ServiceRegistry:
def __init__(self):
self._services = {}
def register(self, name, host, port, version="1.0"):
self._services[name] = {
"host": host,
"port": port,
"version": version
}
def deregister(self, name):
return self._servic…How to Build a Weighted Random Load Balancer in Python
A Python load balancer mock that distributes requests across servers based on configurable weights using a cumulative weighted random selection algorithm.
import random
from collections import Counter
SERVERS = {
"server-a": 50,
"server-b": 30,
"server-c": 20,
}
def weighted_random_server(servers: dict[str, int]) -> str:
"""Select a server based on its weight (higher weight = more likely)."""
total_weight = sum(servers.values())
rand = random.…How to Implement the Repository Pattern in Python with an In-Memory Dict
Stores, retrieves, updates, and deletes user records in memory using a Repository abstraction over a plain dict, isolating data access from business logic.
class UserRepository:
def __init__(self):
self._storage = {}
self._next_id = 1
def create(self, name, email):
user_id = self._next_id
self._next_id += 1
self._storage[user_id] = {"id": user_id, "name": name, "email": email}
return self._storage[user_id]
def…How to mock the domain center in an onion architecture in Python
Define a repository interface and an in-memory mock to test domain services without touching infrastructure.
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Dict, List, Optional
@dataclass
class Order:
id: int
customer: str
items: List[str]
total: float
class OrderRepository(ABC):
@abstractmethod
def find_by_id(self, order_id: int) -> Optional[Order]:
…Round Robin Load Balancer in Python
This code simulates round robin load balancing by distributing a list of requests evenly across a list of servers.
def round_robin_servers(requests: list[str], servers: list[str]) -> dict[str, list[str]]:
assignments = {server: [] for server in servers}
for idx, request in enumerate(requests):
server = servers[idx % len(servers)]
assignments[server].append(request)
return assignments
if __name__ == "_…Browse by section
Each section groups closely related Python snippets.
System design patterns — Python code examples
What you will find here
This page collects system design patterns snippets — short, copy-ready Python you can paste into our free online IDE and run without installing anything. Each sample includes a plain-English explanation and the full source code.
Samples vs tutorials and challenges
Samples are quick reference — one concept per page. For step-by-step teaching, use our Python tutorials. To test yourself, try quizzes or coding challenges. Clean up style with the Python formatter.