distributed system

A distributed system is a collection of independent computers, called nodes, that coordinate by passing messages over a network so that they appear to their users as a single coherent system, as shown here:

Independent nodes with private memory pass messages over a shared network, and one failed node stops while the rest keep running.
Independent Nodes Coordinating Over a Network

Each node has its own private memory and runs on its own schedule, so the system has no shared memory and no global clock that every node agrees on. Components also fail independently, which means one part can stop while the rest keeps running, a condition known as partial failure.

Those traits make concurrency unavoidable and turn coordination, message ordering, and recovery into central design problems. Spreading work across many machines buys scalability and fault tolerance, because the failure of any one node no longer stops the whole, but it adds network latency and operational complexity in return.

A well-known expression of that tension is the CAP theorem, which holds that when a network partition separates the nodes, a data store must choose between consistency and availability. It can either make every read reflect the latest write or answer every request, but not both at once. Reaching agreement despite such failures is the job of consensus algorithms such as Paxos and Raft.

Distributed systems underpin much of modern computing, including:

  • The web and content delivery networks, which replicate data across regions to serve each request from a nearby node.
  • Distributed databases, which split records across nodes, a practice called sharding, and copy each record to more than one node for capacity and durability.
  • Microservice architectures, which split one application into independent microservices that communicate over the network.
Python Microservices With gRPC

Tutorial

Python Microservices With gRPC

In this tutorial, you'll learn how to build a robust and developer-friendly Python microservices infrastructure. You'll learn what microservices are and how you can implement them using gRPC and Kubernetes. You'll also explore advanced topics such as interceptors and integration testing.

intermediate docker flask

For additional information on related topics, take a look at the following resources:

By Martin Breuss • Updated Aug. 16, 2026
Computer Science Glossary Share Feedback