Reference library

System design patterns

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

6 matches

Builder pattern for mocking complex objects in Python

Use a fluent Builder to construct realistic mock objects with defaults, enabling readable test data setup.

class User:
    def __init__(self):
        self.name = "default"
        self.age = 0
        self.email = "unknown@example.com"
        self.address = "unknown"

    def __repr__(self):
        return f"User(name={self.name!r}, age={self.age}, email={self.email!r}, address={self.address!r})"


class UserBuilder:
   …

16 0 Open

System design patterns easy

How to Aggregate Mock API Routes by Method in Python

Groups mock API routes by path and method, collecting response bodies and counts into a nested dictionary structure.

defaultdict api-gateway aggregation

Python

from collections import defaultdict


def aggregate_mock_routes(routes):
    """Aggregate mock API routes by method and aggregate their response bodies."""
    aggregated = defaultdict(lambda: defaultdict(list))

    for route in routes:
        method = route["method"]
        path = route["path"]
        response = …

13 0 Open

System design patterns medium

How to Implement CQRS with Separate Read and Write Models in Python

Implements Command Query Responsibility Segregation (CQRS) by splitting data into separate write and read models with dedicated repositories, using dataclasses for structure.

cqrs dataclasses repositories

Python

from dataclasses import dataclass, field
from typing import List, Dict, Optional


@dataclass
class OrderWriteModel:
    order_id: int
    customer: str
    items: List[str] = field(default_factory=list)

    def add_item(self, item: str) -> None:
        self.items.append(item)


@dataclass
class OrderReadModel:
    …

14 0 Open

System design patterns medium

How to Implement the Flyweight Pattern in Python

Implements the Flyweight design pattern to share immutable intrinsic state (character + font) across many document objects, reducing memory usage.

flyweight design-patterns memory-optimization

Python

class Character:
    """Flyweight - stores only intrinsic state (shared)."""

    def __init__(self, char: str, font: str):
        self.char = char
        self.font = font

    def render(self, size: int) -> str:
        return f"{self.char}_{self.font}_{size}"


class CharacterFactory:
    """Flyweight factory - ma…

15 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 easy

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.

onion-architecture repository-pattern dependency-injection

Python

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]:
     …

11 0 Open

Browse by section

Each section groups closely related Python snippets.