Kaushik's Notes

Low-Level Design (LLD)

2 min read

Detailed implementation of HLD components

Purpose

  • Class diagrams → Object-oriented design
  • Database schema → Tables, relationships, indexes
  • API specifications → Request/response formats
  • Algorithms → Detailed logic implementation
  • Code structure → Modules, functions, interfaces

Key Elements

1. Class Design

class UserService {
    private UserRepository userRepo;
    private EmailService emailService;
    
    public User createUser(UserRequest request) {
        // Validation logic
        // Business rules
        // Database operations
    }
}

2. Database Schema

CREATE TABLE users (
    id BIGINT PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
    -- UNIQUE on email already creates an index; no separate idx_email needed
);
 
CREATE TABLE posts (
    id BIGINT PRIMARY KEY,
    user_id BIGINT REFERENCES users(id),
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);
-- Inline INDEX inside CREATE TABLE is MySQL-only; portable (PostgreSQL) form:
CREATE INDEX idx_user_created ON posts (user_id, created_at);

3. API Specification

POST /api/v1/users
Request:
{
  "email": "user@example.com",
  "password": "securePassword123"
}
 
Response:
{
  "userId": 12345,
  "email": "user@example.com",
  "createdAt": "2024-01-01T10:00:00Z"
}

4. Algorithms

import bisect, hashlib
 
def stable_hash(s):
    # Python's built-in hash() is randomised per process for str -> use a stable hash
    return int(hashlib.md5(s.encode()).hexdigest(), 16) % (2**32)
 
def consistent_hash(key, ring):
    """
    Distribute keys across nodes using consistent hashing.
    ring: list of (hash_value, node) sorted by hash_value
          (add several virtual nodes per physical node for balance)
    """
    hashes = [h for h, _ in ring]
    i = bisect.bisect_left(hashes, stable_hash(key))  # first node with hash >= key hash
    return ring[i % len(ring)][1]  # wrap around to smallest hash

Design Patterns

Repository Pattern

interface UserRepository {
    User save(User user);
    Optional<User> findById(Long id);
    Optional<User> findByEmail(String email);  // email is UNIQUE
}

Factory Pattern

class NotificationFactory:
    @staticmethod
    def create_notification(type, message):
        if type == "email":
            return EmailNotification(message)
        elif type == "sms":
            return SMSNotification(message)

Observer Pattern

class EventEmitter {
    constructor() {
        this.listeners = {};
    }
    
    on(event, callback) {
        if (!this.listeners[event]) {
            this.listeners[event] = [];
        }
        this.listeners[event].push(callback);
    }
    
    emit(event, data) {
        if (this.listeners[event]) {
            this.listeners[event].forEach(cb => cb(data));
        }
    }
}

Implementation Checklist

  • Error Handling: Try-catch, validation
  • Logging: Structured logs, correlation IDs
  • Testing: Unit tests, integration tests
  • Security: Input sanitization, SQL injection prevention
  • Performance: Connection pooling, caching
  • Monitoring: Metrics, health checks

Construction Analogy

Like detailed construction plans showing:

  • Exact measurements (data types, constraints)
  • Material specifications (technologies, libraries)
  • Step-by-step instructions (algorithms, workflows)
  • Quality standards (testing, validation)

Graph View

Backlinks