Reference library

System design patterns

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

6 matches

How to Build a Health Check System with Instance Up and Down Status in Python

Track instance health by marking them up or down and simulating health checks with a mock class in Python.

from datetime import datetime
import random

class HealthChecker:
    def __init__(self):
        self.status = {}
    
    def mark_up(self, instance_id):
        self.status[instance_id] = {
            "state": "up",
            "last_check": datetime.now().isoformat(),
            "healthy": True
        }
    
  …

14 0 Open

System design patterns easy

How to Build an MVP Presenter View Mock in Python

A minimal MVP (Model-View-Presenter) mock showing a Presenter controlling a SlideDeck model with slide navigation and typed state via dataclasses.

dataclasses mvp design-patterns

Python

from dataclasses import dataclass, field
from typing import List


@dataclass
class SlideDeck:
    title: str
    slides: List[str] = field(default_factory=list)
    current_index: int = 0

    def next_slide(self) -> str:
        if self.current_index < len(self.slides) - 1:
            self.current_index += 1
      …

13 0 Open

System design patterns easy

How to Implement the Prototype Pattern with Deep Copy in Python

Implements the Prototype design pattern using copy.deepcopy to clone complex objects without sharing mutable state.

prototype-pattern deepcopy dataclasses

Python

import copy
from dataclasses import dataclass, field
from typing import List

@dataclass
class Engine:
    horsepower: int

@dataclass
class Car:
    brand: str
    engine: Engine
    accessories: List[str] = field(default_factory=list)

def clone_prototype(car: Car) -> Car:
    return copy.deepcopy(car)

if __name__ …

13 0 Open

System design patterns easy

How to Take Periodic Snapshots of Aggregate State in Python

Build a Python class that accumulates values and periodically captures immutable snapshots of total, count, and average for later analysis.

aggregation snapshots state-management

Python

import time
import random
from collections import defaultdict


class SnapshotAggregator:
    def __init__(self):
        self.total = 0
        self.count = 0
        self.history = []

    def add(self, value):
        self.total += value
        self.count += 1

    def snapshot(self):
        avg = self.total / se…

13 0 Open

System design patterns easy

Idempotent Consumer: Store Processed IDs in Python

Implement an idempotent consumer that persists processed message IDs to a JSON file, skipping duplicates on restart.

idempotency duplicate-detection state-persistence

Python

import json
from pathlib import Path


class IdempotentStore:
    def __init__(self, storage_path: str = "processed_ids.json"):
        self.storage_path = Path(storage_path)
        self.processed_ids = self._load()

    def _load(self) -> set:
        if self.storage_path.exists():
            with self.storage_path…

15 0 Open

System design patterns easy

Observer Pattern with Mock Metrics in Python

Implement the Observer pattern with a mock metrics collector to track state changes and verify notifications.

observer mock design pattern

Python

import unittest
from unittest.mock import Mock


class Subject:
    def __init__(self):
        self._state = 0
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def set_state(self, value):
        if value != self._state:
            self._state = value
      …

12 0 Open

Browse by section

Each section groups closely related Python snippets.