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

Non-functional Requirements: Non-functional Requirements in System Design Interviews

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 Communications

Synchronous Communication: Sync Communication

Synchronous Communication: Implementing Synchronous Communication

Synchronous Communication: Failure Handling in Synchronous Communication

Synchronous Communication: Using Timeout to Handle Failures in Microservices

Synchronous Communication: Using Retries to Handle Failures in Microservices

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

Caching: Caching Patterns

Caching: Cache-aside (Lazy loading) Pattern

Caching: Write-through Pattern (pre-loading)

Caching: Write-back Caching

Caching: Choosing the Right Caching Pattern

Caching: Cache Eviction

Caching: Caching TTL

Caching: Scaling Cache

Caching: Redis Codelab

Caching: Content Delivery Networks (CDNs) as a Caching Mechanism

Caching: Thundering Herd Problem

Dataflow: Overview

Dataflow: Push vs Pull

Dataflow: Push vs Pull in Twitter's Timeline

Data Structures Behind Databases: Data Structures Behind Databases

Data Structures Behind Databases: Sorted String Table(SSTable)

Data Structures Behind Databases: LSM Tree

Data Structures Behind Databases: B-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

Batch Processing: Overview

Batch Processing: Batch processing In System Design

Batch Processing: MapReduce

Batch Processing: Dataflow Engines

Batch Processing: Why use Batch Processing

Stream Processing: Stream processing

Stream Processing: Batch and stream

Stream Processing: Lambda Architecture

Stream Processing: Kappa Architecture

Patterns: A Database Per Microservice

Patterns: Cache, Always

Patterns: Change Data Capture + ElasticSearch

Patterns: The Two-Stage Processing Pattern

Patterns: Database Optimization Techniques

Template: Design Template

Template: System Design Template Application: Social Media Comment System