Basics: The System Design Interview Course

Basics: Interview Template

Basics: Core Challenges in Web-scale System Design (and How to Tackle Them)

Basics: How to Scale a System

Basics: Study Guide

API Design: API Design Intro

API Design: API Design Example

API Design: API Design - Pagination

API Design: API Authentication

API Design: API Authorization

API Design: API Gateway

Non-functional Requirements: Non-functional Requirements

Non-functional Requirements: System Design Components

Non-functional Requirements: High Availability

Non-functional Requirements: How to Achieve High Availability

Non-functional Requirements: Tech Stacks to Achieve High Availability

Non-functional Requirements: Latency

Non-functional Requirements: Throughput

Resource Estimation: Back-of-the-envelope Resource Estimation

Resource Estimation: QPS and System Design

Resource Estimation: Back-of-the-envelope Resource Estimation Real World Examples

Microservices: Microservices and Monolithic Architecture

Synchronous Communication: Microservice Communication

Synchronous Communication: Synchronous Communication

Synchronous Communication: Implementing Synchronous Communication

Synchronous Communication: Failure Handling in Synchronous Communication

Synchronous Communication: Timeout

Synchronous Communication: Retries

Synchronous Communication: Circuit Breaker

Synchronous Communication: Fallbacks

Synchronous Communication: Service Discovery

Asynchronous Communication: Asynchronous Communications Through Messaging

Asynchronous Communication: Message Queues in System Design

Asynchronous Communication: Message Queue Use Cases and Patterns

Asynchronous Communication: Redis Queue Tutorial

Asynchronous Communication: Log-based message queues

Asynchronous Communication: Introduction to Kafka

Asynchronous Communication: Kafka Exercise

Horizontal Scaling: Evolution of Computing Environments

Horizontal Scaling: Evolution of a Web App | Stateless vs Stateful

Horizontal Scaling: Evolution of a Web App | Single to Scaling

Horizontal Scaling: Load Balancer

Horizontal Scaling: Load balancing Codelab

Horizontal Scaling: Auto Scaling

Read Write Separation: Read-Write Separation

Read Write Separation: Command Query Responsibility Segregation (CQRS) Pattern

Caching: Caching: The Mental Model

Caching: The Multi-Layer Defense

Caching: The Edge: CDN vs Application Cache

Caching: Cache Key Design

Caching: Read Patterns: Fetching Data

Caching: Lab: The Read Drill

Caching: Write Patterns: Mutating Data

Caching: The Consistency Problem

Caching: Lab: The Write Drill

Caching: Invalidation & Freshness

Caching: Eviction & Sizing

Caching: Distributed Caching

Caching: Cache High Availability

Caching: Cold Start

Caching: Failure Modes

Caching: Lab: The Disaster Drill

Caching: Security & Observability

Caching: Interview Walkthrough

Dataflow: Dataflow Overview

Dataflow: Push vs Pull

Dataflow: Push vs Pull in Twitter Timeline

Data Structures Behind Databases: Data Structures Behind Databases

Data Structures Behind Databases: B-tree

Data Structures Behind Databases: SSTable

Data Structures Behind Databases: LSM Tree

Storage: Introduction to Storage

Storage: SQL Database

Storage: Introduction to NoSQL Databases

Storage: Key-value Database

Storage: Document Database

Storage: Full-text Search Database

Storage: OLTP (Transaction) or OLAP (Analytics)?

Storage: Blob/Object Storage

Storage: SQL vs NoSQL

Data Replication: How to Scale Databases

Data Replication: Database Replication: Fundamentals and Algorithms

Data Replication: Implementing Database Replication: Practical Guide and Failover Strategies

Data Replication: Data Replication Tutorial

Data Replication: Change Data Capture

Data Partitioning: Database Partitioning

Data Partitioning: Advanced Database Partitioning Techniques and Key Selection

Data Partitioning: Consistent Hashing

Data Partitioning: Database Partition Tutorial

Overview: Batch & Stream Processing: Overview

Batch Processing: Unix Pipelines

Batch Processing: The MapReduce Model

Batch Processing: Modern Batch: Spark

Batch Processing: Distributed File Systems

Stream Processing: What is Stream Processing?

Stream Processing: Delivery Guarantees

Stream Processing: Event Time & Watermarks

Stream Processing: Windowing Patterns

Stream Processing: Modern Stream: Flink & Kafka Streams

Hybrid Architectures: Lambda Architecture

Hybrid Architectures: Kappa Architecture

Hybrid Architectures: Unified Processing

Pipeline Operations: ETL vs ELT

Pipeline Operations: Error Handling

Pipeline Operations: Backfill & Reprocessing

Real-time & Analytics: Materialized Views

Real-time & Analytics: Analytics Architecture

Real-time & Analytics: Time-Series Patterns

Patterns: Database Optimization Techniques

Patterns: Cache-First Pattern

Patterns: Pre-Computing Pattern

Patterns: Database Per Microservice

Patterns: Multi-System Data Sync

Patterns: Unique ID Generators

Patterns: Rate Limiting Patterns

Patterns: The Two-Stage Processing Pattern

Patterns: Fan-Out/Fan-In Pattern

Patterns: Saga Pattern

Template: Design Template

Template: System Design Template Application: Social Media Comment System