Reference library

System design patterns

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

4 matches

Build a BFF (Backend for Frontend) Mock Aggregator in Python

A minimal HTTP server implementing the BFF pattern that aggregates user data and orders from two mock backends into a single JSON response.

bff http-server aggregation

Python

import json
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse


class MockBackendA:
    def get_user(self, user_id):
        return {"id": user_id, "name": "Alice", "service": "backend-a"}


class MockBackendB:
    def get_orders(self, user_id):
        return [
            {…

19 0 Open

System design patterns medium

How to Build an Adapter to Translate External API Responses in Python

Build an adapter class that translates a mock external API's response shape into your internal representation, keeping callers decoupled from the external contract.

adapter-pattern api architecture

Python

import json
from typing import Dict, Any


class ExternalAPI:
    """Mock external service returning a different data shape."""
    def get_user(self, user_id: int) -> Dict[str, Any]:
        return {
            "id": user_id,
            "full_name": "Jane Doe",
            "email_address": "jane@example.com",
     …

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

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.