System Design

Growing your system to handle increased load.

Keeping your system alive and accessible.

Why a system can be available but totally unreliable.

The two primary metrics of system performance.

The fundamental trade-off in distributed databases.

The modern extension to the CAP Theorem.

The universal language of the web.

Why Facebook reinvented data fetching.

The bouncer at the club.

The great architectural debate.

Managing the chaos of microservice communication.

Protecting your API from abusive traffic.

Intentionally dropping traffic to save the system.

What are SOLID principles and why do they matter?

A class should have one, and only one, reason to change.

Software entities should be open for extension, but closed for modification.

Subtypes must be perfectly substitutable for their base types.

Clients should not be forced to depend on methods they do not use.

High-level modules should not depend on low-level modules; both should depend on abstractions.

The blueprints of software architecture.

There can be only one.

The object assembly line.

Subscribe and be notified.

Swapping the engine mid-flight.

The Russian Nesting Dolls.

Hiding the spaghetti.

The universal translator.

The bodyguard.

Turning actions into objects.

Walking the collection.

The finite state machine.

Distributing traffic across multiple servers.

How the Load Balancer decides where to send traffic.

The bodyguard that sits in front of your servers.

Fixing the fatal flaw of standard load balancer hashing.

How microservices find each other in a dynamic cloud.

Trading RAM for speed.

How to read and write to your cache without data corruption.

How to decide what to delete when RAM is full.

Choosing the right engine for your distributed cache.

Scaling your cache across multiple servers.

Bringing data physically closer to the user.

Push vs Pull, and TTL Management.

Running application logic at the CDN level.

Choosing the right database for the job.

How databases find data without scanning the entire disk.

Duplicating data across servers for availability and read scaling.

Scaling writes by splitting the database into pieces.

How to mathematically distribute your data.

The gold standard for database reliability.

Trading absolute correctness for massive scalability.

Optimized for highly connected, relational data.

Built exclusively for handling massive streams of timestamped data.

The three tiers of hard drive architecture.

Combining hard drives for speed or safety.

Handling massive unstructured files.

Decoupling systems through asynchronous processing.

Broadcasting messages to multiple listeners.

Choosing the right event broker.

Reacting to things that have already happened.

Storing the journey, not just the destination.

Splitting reads from writes for ultimate optimization.

How to push data from the server to the client.

The lightweight alternative to WebSockets.

Server-to-Server push notifications.

Real-time updates tailored exactly to the client's needs.

The modern, high-speed alternative to REST.

Browser-to-Browser, skipping the server entirely.

Multiple computers acting as one.

How strictly do we keep our data synchronized?

How to actually build systems that are eventually consistent.

Keeping data synchronized across the network.

The most common replication architecture.

How a cluster decides who is in charge.

Getting computers to agree when they don't trust the network.

The mathematical rule of majorities in distributed systems.

ACID guarantees across multiple microservices.

The brutal, synchronous way to achieve distributed consistency.

Surviving the death of the primary database.

The fastest way to know if something DOES NOT exist.

Counting to infinity using almost zero RAM.

Counting unique items using probability.

Proving data integrity in distributed systems.

The distributed engine behind modern search.

The data structure that makes search engines fast.

Handling typos and misspellings like a pro.

Searching by meaning, not by matching keywords.

How search engines decide what is relevant.

Securing data in transit across the public internet.

Stateless authentication and third-party authorization.

The browser's most misunderstood security feature.

The two most common ways to hack an application.

Surviving a distributed attack on your infrastructure.

Failing fast to prevent catastrophic cascading failures.

Handling the chaos of unreliable networks.

Failing without the user noticing.

When the entire data center burns down.

The Three Pillars of Observability.

Following a request through the microservice maze.

The industry standard for metrics and dashboards.

How to aggregate and search millions of logs.

Waking up engineers at 3:00 AM.

The classic system design warm-up.

The ultimate fan-out architecture challenge.

Real-time communication at a global scale.

Connecting riders and drivers using Geo-Spatial Data.

Streaming massive video files across the globe.

Managing extremely high-concurrency transactions.

Downloading the entire internet.

Protecting APIs at massive scale.

Building the backbone of distributed systems.

Storing and streaming petabytes of user-generated content.

Real-time collaborative editing without destroying data.

The ultimate data aggregation challenge.

Typeahead suggestions in under 50 milliseconds.

Building Redis from scratch.

Building a global Object Storage system.

Moving money without losing a single cent.