System Design Fundamentals

0%Certificate0/188

Course Introduction

Join the Community

What is System Design?

30 Must-Know Concepts

Single Point of Failure (SPOF)

Latency vs Throughput vs Bandwidth

Consistent Hashing

Consistency Models

Core Concepts - ExercisesNew

Domain Name System (DNS)

Proxy vs Reverse Proxy

Networking - ExercisesNew

What are Load Balancers?

Load Balancing Algorithms

DNS Load Balancing

Anycast Routing

Load Balancing - ExercisesNew

API Design

What is an API?

API Architectural Styles

REST API Design

GraphQL Deep Dive

API Infrastructure

API Security

Authentication vs Authorization

Session vs Token Based Auth

Single Sign-On (SSO)

API Fundamentals - ExercisesNew

Real-Time Communication

Server-Sent Events (SSE)

Asynchronous Communication

Sync vs Async Communication

Change Data Capture (CDC)

Delivery Semantics

Dead Letter Queues

Communication Patterns - ExercisesNew

Caching Fundamentals

What is Caching?

Cache-Aside Pattern

Read-Through vs Write-Through

Write-Behind Cache

Caching Strategies Summary

Cache Eviction Policies

Distributed Caching

Content Delivery Network (CDN)

Distributed Cache Architecture

Cache Invalidation

Caching - ExercisesNew

Database Fundamentals

ACID Transactions

Database Types - Deep Dive

Relational Databases

Document Databases

Key-Value Stores

Wide Column Databases

Graph Databases

Time Series Databases

Full-Text Search Engines

Vector Databases

Database Internals

B-Trees and B+ Trees

How Databases Guarantee Durability

Databases - ExercisesNew

Database Scaling - Reads

Vertical Partitioning

Query Optimization

Denormalization

Materialized Views

Connection Pooling

Database Scaling - Writes

Sharding vs Partitioning

Data Compression

Database Scaling Techniques - ExercisesNew

Block vs File vs Object Storage

Distributed File Systems

Storage Systems - ExercisesNew

Client-Server Architecture

Monolithic Architecture

Microservices Architecture

Serverless Architecture

Event-Driven Architecture

Peer-to-Peer (P2P)

Hexagonal ArchitectureNew

Service Discovery

API Gateway Pattern

Backend for Frontend (BFF)

Sidecar Pattern

Circuit Breaker Pattern

Bulkhead Pattern

Strangler Fig Pattern

Microservices Patterns - ExercisesNew

Challenges of Distribution

Network Partitions

Split Brain Problem

Handling Failures in Distributed Systems

Time & Ordering

Clock Synchronization Problem

Lamport Timestamps

Coordination & Consensus

Consensus Algorithms

Paxos Algorithm

Leader Election

Distributed LocksNew

Gossip Protocol

Operational TransformationNew

Distributed System Fundamentals - ExercisesNew

The Problem with Distributed Transactions

Two-Phase Commit (2PC)

Three-Phase Commit (3PC)

Distributed Transactions - ExercisesNew

Cuckoo FilterNew

Count-Min Sketch

Data Structures for Scale - ExercisesNew

Batch vs Stream Processing

Data Warehousing

Lambda Architecture

Kappa Architecture

Streaming Engines

Big Data Processing - ExercisesNew

Deployment Strategies

Deployment Strategies Overview

CI/CD PipelinesNew

Rolling DeploymentsNew

Blue-Green DeploymentsNew

Canary ReleasesNew

Release Patterns

Feature FlagsNew

A/B Testing InfrastructureNew

Schema MigrationsNew

Rollbacks & Immutable InfrastructureNew

Deployment Patterns - ExercisesNew

Three Pillars of Observability

Logging Best Practices

Log Aggregation

Correlation IDs

Metrics & Instrumentation

Alert & Monitoring

Dashboards & Runbooks

Distributed Tracing

Observability - ExercisesNew

Encryption at RestNew

Secrets Management

Password ManagementNew

Advanced Security - ExercisesNew

System Design Fundamentals

Welcome

Course Introduction
Course Roadmap
Join the Community

Introduction to System Design

What is System Design?
30 Must-Know Concepts

Core Concepts

Scalability
Availability
Reliability
Single Point of Failure (SPOF)
Latency vs Throughput vs Bandwidth
Consistent Hashing
CAP Theorem
Consistency Models
Core Concepts - Exercises

Networking

OSI Model
IP Address
TCP vs UDP
HTTP/HTTPS
Domain Name System (DNS)
Checksums
Proxy vs Reverse Proxy
Networking - Exercises

Load Balancing

What are Load Balancers?
Load Balancing Algorithms
DNS Load Balancing
Anycast Routing
Load Balancing - Exercises

API Fundamentals

What is an API?
Idempotency
Data Formats
API Architectural Styles
REST API Design
GraphQL Deep Dive
gRPC Deep Dive
API Gateways
Rate Limiting
Authentication vs Authorization
Session vs Token Based Auth
JWT
OAuth / OAuth2
Single Sign-On (SSO)
API Fundamentals - Exercises

Communication Patterns

Long Polling
WebSockets
Server-Sent Events (SSE)
Webhooks
WebRTC
Sync vs Async Communication
Message Queues
Pub/Sub
Change Data Capture (CDC)
Delivery Semantics
Dead Letter Queues
Communication Patterns - Exercises

Caching

What is Caching?
Cache-Aside Pattern
Read-Through vs Write-Through
Write-Behind Cache
Caching Strategies Summary
Cache Eviction Policies
Content Delivery Network (CDN)
Distributed Cache Architecture
Cache Invalidation
Cache Stampede
Cache Warming
Caching - Exercises

Databases

Database Types
SQL vs NoSQL
ACID Transactions
Relational Databases
Document Databases
Key-Value Stores
Wide Column Databases
Graph Databases
Time Series Databases
Full-Text Search Engines
Vector Databases
B-Trees and B+ Trees
LSM Trees
How Databases Guarantee Durability
Databases - Exercises

Database Scaling Techniques

Indexing
Vertical Partitioning
Query Optimization
Read Replicas
Denormalization
Materialized Views
Connection Pooling
Sharding
Sharding vs Partitioning
Data Compression
Database Scaling Techniques - Exercises

Storage Systems

Block vs File vs Object Storage
Object Storage
Distributed File Systems
Erasure Coding
Storage Systems - Exercises

Architectural Patterns

Client-Server Architecture
Monolithic Architecture
Microservices Architecture
Serverless Architecture
Event-Driven Architecture
Peer-to-Peer (P2P)
Hexagonal Architecture
CQRS
Event Sourcing

Microservices Patterns

Service Discovery
API Gateway Pattern
Backend for Frontend (BFF)
Sidecar Pattern
Circuit Breaker Pattern
Bulkhead Pattern
Strangler Fig Pattern
Service Mesh
Microservices Patterns - Exercises

Distributed System Fundamentals

Challenges of Distribution
Network Partitions
Split Brain Problem
Heartbeats
Handling Failures in Distributed Systems
Clock Synchronization Problem
Logical Clocks
Lamport Timestamps
Vector Clocks
Consensus Algorithms
Paxos Algorithm
Raft Algorithm
Leader Election
Distributed Locks
Gossip Protocol
CRDTs
Operational Transformation
Distributed System Fundamentals - Exercises

Distributed Transactions

The Problem with Distributed Transactions
Two-Phase Commit (2PC)
Three-Phase Commit (3PC)
SAGA Pattern
Outbox Pattern
Distributed Transactions - Exercises

Data Structures for Scale

Introduction
Geohash
Quad Trees
R-Trees
S2 and H3
Bloom Filters
Cuckoo Filter
HyperLogLog
Count-Min Sketch
MinHash
Skip Lists
Merkle Trees
Data Structures for Scale - Exercises

Big Data Processing

Batch vs Stream Processing
MapReduce
ETL Pipelines
Data Lakes
Data Warehousing
Data Lakehouse
Lambda Architecture
Kappa Architecture
Streaming Engines
Big Data Processing - Exercises

Deployment Patterns

Deployment Strategies Overview
CI/CD Pipelines
Rolling Deployments
Blue-Green Deployments
Canary Releases
Feature Flags
A/B Testing Infrastructure
Schema Migrations
Rollbacks & Immutable Infrastructure
Deployment Patterns - Exercises

Observability

Three Pillars of Observability
Logging Best Practices
Log Aggregation
Correlation IDs
Metrics & Instrumentation
Alert & Monitoring
Dashboards & Runbooks
Distributed Tracing
Observability - Exercises

Advanced Security

SSL/TLS
Encryption at Rest
Secrets Management
Password Management
RBAC
SAML
Advanced Security - Exercises

SSL/TLS

High Priority

Premium Content

Subscribe to unlock full access to this content and more premium articles.

Observability - Exer...Encryption at Rest