Home / Learn / Distributed Systems & Cloud

☁️ Distributed Systems & Cloud

Scaling across many machines. 51 topics, from beginner to advanced.

Distributed systems run software across many machines that communicate over a network. Because networks fail and clocks disagree, these systems need replication, consensus, partitioning and fault tolerance. This area covers the patterns behind large-scale services and cloud platforms, and the trade-offs they force between consistency, availability and speed.

Who this area is for

Backend engineers building services that run on many machines, cloud engineers, and architects who must choose how data is stored and replicated.

Real-world use cases

Replicating a database across regions so the service survives a data-center outage.
Splitting a user table across shards so no single server handles all traffic.
Scaling a web service horizontally behind a load balancer.
Keeping a service running when one data center loses power.
Splitting a user database across servers so that no single machine stores everything.

Topics in Distributed Systems & Cloud

Beginner (17)

What is a Distributed System — Independent computers cooperating as a single system.
Client-Server Model — Clients requesting services from central servers.
Peer-to-Peer Systems — Networks where nodes act as both clients and servers.
Scalability — Ability to handle growing load by adding resources.
Vertical vs Horizontal Scaling — Bigger machines versus more machines.
Latency vs Throughput — Time per request versus requests per time.
Availability and Reliability — Fraction of time working and consistency of correct operation.
Remote Procedure Calls — Invoking functions on another machine like local ones.
Message Queues — Buffers decoupling producers and consumers.
Cloud Computing — On-demand computing resources over the Internet.
IaaS, PaaS, SaaS — Service tiers from raw infrastructure to finished software.
Virtual Machines in Cloud — Rentable emulated servers.
Object Storage — Flat storage of blobs addressed by keys.
Load Balancing Algorithms — Policies like round robin and least connections.
Caching Layers — Distributed caches reducing backend load.
Fault Tolerance — Continuing correctly despite component failures.
Replication Strategies — Leader-follower and multi-leader copying.

Intermediate (17)

Consistency Models — Guarantees on how updates appear to readers.
Clock Synchronization — Aligning clocks across machines.
Logical Clocks — Lamport and vector clocks ordering events without wall time.
Consensus Problem — Getting nodes to agree on a single value.
Paxos — Classic family of consensus protocols.
Raft — Understandable consensus algorithm using leader election.
Leader Election — Choosing one coordinator among nodes.
Two-Phase Commit — Protocol making distributed transactions atomic.
Saga Pattern — Sequence of local transactions with compensating actions.
Consistent Hashing — Key distribution minimizing movement when nodes change.
Distributed Hash Tables — Decentralized key lookup across peers.
Gossip Protocols — Epidemic-style information spreading.
Failure Detectors — Mechanisms suspecting crashed nodes.
Byzantine Fault Tolerance — Agreement even when some nodes behave maliciously.
Distributed File Systems — File storage spread across machines like GFS and HDFS.
MapReduce — Programming model splitting work into map and reduce phases.
Batch vs Stream Processing — Processing stored data versus continuous flows.

Advanced (17)

Apache Kafka — Distributed log for high-throughput event streaming.
Apache Spark — In-memory engine for large-scale data processing.
Service Discovery — Locating service instances dynamically.
API Gateway — Single entry point routing and securing API traffic.
Service Mesh — Infrastructure layer managing service-to-service traffic.
Docker — Packaging applications into portable containers.
Kubernetes — Orchestrating containers across clusters.
Serverless Computing — Running functions without managing servers.
Infrastructure as Code — Defining infrastructure through versioned declarative files.
Auto Scaling — Adjusting capacity automatically to demand.
Rate Limiting — Capping request rates to protect services.
Circuit Breaker Pattern — Stopping calls to a failing dependency to prevent cascades.
Observability — Understanding systems via logs, metrics and traces.
CRDTs — Data types that merge concurrent updates without conflicts.
Distributed Tracing — Following a request across services.
System Design Case Studies — Designing large systems like feeds, chat and URL shorteners.
Multi-Region Architecture — Spreading systems across geographic regions for resilience.

How to study Distributed Systems & Cloud

Simulate the ideas before you deploy anything. Run three small processes that talk over a network, then stop one and observe what breaks. Read each consistency and failure topic with that experiment in mind.

Frequently asked questions

What is the CAP theorem?

The CAP theorem says that during a network partition a distributed system must choose between consistency and availability. It does not force a permanent trade-off when there is no partition.

Why is distributed computing hard?

Messages can be delayed, lost or duplicated, and machines can crash at any time. Designing correct behavior under all of these failures is the central difficulty.

What is horizontal versus vertical scaling?

Vertical scaling adds more power to one machine. Horizontal scaling adds more machines. Horizontal scaling can grow further but needs the system to be designed for distribution.

Do I need distributed systems if my app is small?

Usually not. A single well-tuned server and database handle far more traffic than most people expect. Add distribution when measurements show a real limit, not before.

What does eventual consistency mean in practice?

After an update, different replicas may briefly return different values, but they converge once the update has propagated. Many social feeds and caches are built this way.

Open the interactive Distributed Systems & Cloud area Take the Distributed Systems & Cloud quiz