System Design Roadmap

Follow the spine top to bottom. Each dark node is a core topic — the cards branching off hold the details.

Functional and Non Functional Requirements

Overview

High Level Design

Event-Driven Architecture in an E-commerce System Serverless Architecture Stateless and Stateful Systems Stateful Vs Stateless Architecture Pub/Sub Architecture

System Architectural Styles

Monolithic Architecture Microservices Monolithic Vs Microservices Architecture Event-Driven Architecture

Designing Highly Scalable Systems Primary Scalability Bottlenecks in System Design Amdahl's Law

Scalability

Scalability in System Design Horizontal and Vertical Scaling Choosing the Right Scalability Approach

Latency, Throughput and Caching

Latency & Throughput

Latency and Throughput

CDN Vs Edge Server Cache Eviction Policies Cold and Warm Cache in System Design Caching Strategies (Cache Aside, Write Through, etc.)

Caching

Caching in System Design Distributed Cache Design Distributed Cache Edge Caching

Load Balancing

Load Balancer Types of Load Balancer

Load Balancing Algorithms Concurrency and Parallelism

Stateless Vs Stateful Load Balancing Load Balancing Vs Failover

Consistent Hashing

Consistency, Availability, Reliability & Maintainability

PACELC Theorem ACID vs BASE Strong vs Eventual Consistency

Consistency

Consistency in System Design Consistency pattern CAP Theorem

Achieving High Availability

Availability

Availability in System Design

99.9% Availability - three 9s

99.99% Availability - four 9s

Availability in Parallel vs Sequence

Availability in Numbers

Retry Patterns and Exponential Backoff Idempotency Heartbeat

Reliability

Reliability in System Design Fault Tolerance in System Design Circuit Breaker Pattern Bulkhead Pattern

SLA vs SLO vs SLI

Maintainability

Databases in Designing Systems

Replication Patterns (Master Slave, Master Master)

Replication

Database Replication in System Design Types of Database Replication

Sharding (Data Partitioning)

Consistent Hashing

Partitioning

Database Sharding Data Partitioning

Normalization Process in DBMS Denormalization in Databases Normalization vs Denormalization Polyglot Persistence Vector Databases

Modeling & Storage

Designing the Database Types of Database Choosing a Database - SQL or NoSQL File and Database Storage Systems Block, Object, and File Storage

Write Ahead Logging (WAL)Bloom Filters

Database Internals

SQL Query Optimization Intro to Redis Database Indexing (B Trees, LSM Trees)

Rate Limiting Algorithm Pub Sub (Publish Subscribe)Dead Letter Queues

API Gateway, Message Queues & Rate Limiting

API Gateway Message Queues Rate Limiting

Protocols, CDN, Proxies & WebSockets

HTTP/2 and HTTP/3 (QUIC)gRPC vs REST WebSocket and Server-Sent Events (SSE)

Protocols

Communication Protocols Long Polling and Short Polling Websockets TCP vs UDP

Time to Live(TTL)Content Delivery Network(CDN)

DNS & CDN

Domain Name System DNS Caching Flushing(Reset) of DNS Cache

Web and Application Server

Proxies & Servers

Proxies in System Design Forward Proxy vs Reverse Proxy

Event-Driven Architecture

Introduction Event Sourcing Pattern

Event Sourcing Vs Event Streaming Event-Driven APIs in Microservice Architectures

Error Handling in Event-Driven Architecture Restore State in an Event-Based, Message-Driven Microservice Architecture on Failure Scenario

Event-Driven Architecture Patterns in Cloud Native Applications Request-driven Vs Event-driven Microservices

Event-Driven Architecture Vs Microservices Architecture Message-Driven Architecture Vs Event-Driven Architecture

Distributed System Design

Introduction Consensus Algorithms in Distributed System

Distributed Tracing Secure Communication in Distributed System

Design Issues of Distributed System Gossip Protocol

Leader Election (Paxos, Raft)Distributed Transactions (SAGA Pattern)

Two Phase Commit (2PC)

Low Level Design or LLD Difference between High Level Design(HLD) and Low Level Design(LLD)

Low Level Design (LLD) - Core Concepts

Object-Oriented Programming(OOP) Concepts Modularity and Interfaces

KISS Principle YAGNI Principle

Design Principles

SOLID Principles DRY Principle

UML

Unified Modeling Language (UML)

Stress Testing CI/CD Pipeline

Testing

Unit Testing Integration Testing Load Testing

Security Measures

Security Measures in System Design Authentication and Authorization

Secure Socket Layer (SSL) and Transport Layer Security (TLS)Secure Software Development Life Cycle (SSDLC)

Data Backup and Disaster Recovery OAuth 2.0 and OIDC

TLS/SSL Handshake Zero Trust Security

Cost Vs Performance

Cost & Performance Optimizations

Software Cost Estimation Performance Optimization Techniques