Distributed system
A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
Acing the Frontend Interview
Distributed computing is computation performed by multiple networked machines that coordinate to provide a combined service or result.
- How it is used
- Frames end-to-end architecture and interview decisions for frontend engineers working with APIs and multi-node services.
- How deep it goes
- Explains architectural boundaries, CAP trade-offs, scaling, replication, and observability through questions and applied choices rather than a complete system build.
- Examples
- Uses a cross-origin frontend and API, partition scenarios, horizontal scaling, and synchronous versus asynchronous replication.
- What you can do after
- Evaluate/understand distributed architecture choices and explain their consistency, scalability, and reliability trade-offs in an interview.
Read how Acing the Frontend Interview explains distributed system →
Elixir in Action, Third Edition
A distributed system is a system whose components execute across multiple networked machines or runtime environments.
- How it is used
- Deploys clustered services for horizontal scaling and continued availability when individual machines fail.
- How deep it goes
- Explains processes, messages, replication, joining nodes, and failure boundaries, while deferring complete partition and recovery strategies.
- Examples
- Demonstrates a replicated to-do service running on two connected nodes and serving requests through separate HTTP endpoints.
- What you can do after
- Build it from scratch by combining Erlang distribution primitives, explicit message protocols, replication, and failure recovery.
Read how Elixir in Action, Third Edition explains distributed system →
Think Distributed Systems
A computing system whose components execute across multiple networked locations and must coordinate despite having incomplete views of system state.
- How it is used
- Organizes reasoning about systems whose components coordinate through messages while pursuing correctness, scalability, and reliability.
- How deep it goes
- Defines components, local state, messages, network steps, and system models, then stops short of implementing particular protocols.
- Examples
- Uses an office corporation analogy, equivalent message-buffer models, nested database subsystems, and a split-brain leadership scenario.
- What you can do after
- Evaluate system behavior by separating global guarantees from local observations and by making network, component, and failure assumptions explicit.
Read how Think Distributed Systems explains distributed system →
Robotics for Programmers
A distributed system is a collection of independent networked computing devices that cooperatively appears to users as one coherent system.
- How it is used
- Frames multi-computer robot software as one operational system managed through middleware.
- How deep it goes
- Defines coherent collection-level operation and contrasts unmanaged servers with middleware-managed deployment, without detailing distributed algorithms.
- Examples
- Uses web-backend/database servers, alternative image-processing deployments, and detected-object topic messages.
- What you can do after
- Evaluate/understand whether networked devices provide a coherent system-level interface and how messaging supports flexible deployment.
Read how Robotics for Programmers explains distributed system →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
An application architecture in which components execute as separate processes or services that communicate across a network.
- How it is used
- Uses distributed applications as the architecture for incrementally building and deploying a microservices application.
- How deep it goes
- Explains basic structuring concerns and tradeoffs while limiting technology detail to what is needed to bootstrap an application.
- Examples
- Uses a small application built toward production and a monolith-to-microservices conversion with diminishing returns.
- What you can do after
- Evaluate distributed architecture by weighing scalability and deployment benefits against complexity, cost, and service size.
Building Distributed Applications that Work
A distributed system is a system composed of multiple networked computing components that coordinate to provide shared behavior.
- How it is used
- Frames local development and debugging of a multi-service online shop as a coordination problem.
- How deep it goes
- Defines independent networked components, contrasts monoliths, and outlines local orchestration without detailing network protocols or failure recovery.
- Examples
- Follows a shopper’s request through a storefront and catalog API, with data stores and background processing in the wider system.
- What you can do after
- Apply it via Aspire to run, connect, observe, and debug independent application components from one local development setup.
Read how Building Distributed Applications that Work explains distributed system →
LLMs in Production
Distributed computing is a computing technique that divides workloads across multiple networked devices or nodes for concurrent execution.
- How it is used
- Uses concurrent computation to make oversized deep-learning models and pipelines train or infer efficiently across clusters.
- How deep it goes
- Explains data, model, tensor, and sequence parallelism plus microbatching, but does not detail cluster internals or communication mechanics.
- Examples
- Demonstrates a ten-call Ray task and illustrates tensor splitting, transformer parallelization, GPU bubbles, and microbatching.
- What you can do after
- Apply it via Ray for concurrent tasks and select data, model, tensor, or sequence parallelism for deep-learning workloads.
Effective Platform Engineering
A distributed architecture pattern structures capabilities across multiple coordinating components rather than concentrating them in one component.
- How it is used
- Structures engineering-platform capabilities across coordinating services, teams, and control planes as complexity and scale increase.
- How deep it goes
- Explains orchestration, extensibility, boundaries, replication, and coordination practices, but stops short of implementation-level distributed-systems internals.
- Examples
- Uses Kubernetes cluster components, pod sidecars, isolated platform replication, and public API-gateway integration as concrete examples.
- What you can do after
- Evaluate platform boundaries and choose incremental distribution, standardization, replication, or self-service according to scaling priorities.
Read how Effective Platform Engineering explains distributed system →
Rust Servers, Services, and Apps
A distributed system is a collection of independent computing components that coordinate over a network to provide combined functionality.
- How it is used
- Uses distributed web applications as the setting for developing Rust-based web services and applications.
- How deep it goes
- Defines system components and stack layers, then relates them to web applications without detailing implementation internals.
- Examples
- Uses social media, e-commerce, sharing-economy, and entertainment services, plus a social media stack diagram.
- What you can do after
- Build Rust web servers, services, and applications using the distributed-web context.
Read how Rust Servers, Services, and Apps explains distributed system →
Advanced Algorithms and Data Structures
A distributed system is a system whose components execute across multiple networked computers and communicate by exchanging messages.
- How it is used
- Frames real applications and large-scale data processing as coordinated work across machines connected by networks.
- How deep it goes
- Explains remote calls, latency, failures, timeouts, communication choices, and scale-out, without developing a complete fault-tolerance design.
- Examples
- Uses retailer services, customer orders, HTTP sequence diagrams, and distributed versions of k-means, canopy clustering, and DBSCAN.
- What you can do after
- Diagnose/debug with it by locating network uncertainty, timeout mismatches, remote failures, and scale-out trade-offs.
Read how Advanced Algorithms and Data Structures explains distributed system →
Platform Engineering on Kubernetes
A distributed system is a computing system whose functionality is divided among independently operating services that communicate across process or network boundaries.
- How it is used
- Uses independently operating services to support cloud-native applications and distribute team, scaling, and deployment responsibilities.
- How deep it goes
- Explains architectural differences, scaling benefits, and operational failures, but stops short of service-internal implementation details.
- Examples
- Uses a walking-skeleton application, monolith comparison, Kubernetes cluster, and figures contrasting bundled logic with distributed services.
- What you can do after
- Evaluate distributed architecture trade-offs and experiment with service latency, failures, scaling, and consistency in Kubernetes.
Read how Platform Engineering on Kubernetes explains distributed system →
PostgreSQL Mistakes and How to Avoid Them
A distributed system is a system whose components execute across multiple networked computing nodes that coordinate to provide a unified service.
- How it is used
- Frames PostgreSQL replication as a distributed-system design with consistency, availability, and latency consequences.
- How deep it goes
- Explains primary-standby lag through a worked account scenario and stops short of exhaustive distributed-systems implementation detail.
- Examples
- Uses PostgreSQL alpha and beta nodes, delayed account reads, balance updates, and a mistaken bonus calculation.
- What you can do after
- Diagnose inconsistent application behavior by comparing primary and standby reads under replication lag.
Read how PostgreSQL Mistakes and How to Avoid Them explains distributed system →
ScyllaDB in Action
A distributed system is a system whose components run on multiple networked nodes and coordinate to provide a unified service.
- How it is used
- Uses distribution to provide ScyllaDB scalability, fault tolerance, availability, and configurable consistency.
- How deep it goes
- Traces request routing, replication, consistency levels, eventual consistency, and the hash ring, while deferring deeper implementation details.
- Examples
- Demonstrates any-node writes, hash-ring forwarding, replicated rows, and ALL, QUORUM, and ONE consistency levels.
- What you can do after
- Evaluate consistency and availability trade-offs while reasoning about ScyllaDB reads, writes, failures, and cluster behavior.
Grokking Simplicity
A software system whose components communicate over a network and may experience delayed, reordered, duplicated, or lost messages.
- How it is used
- Frames distributed systems as a setting for isolating time-dependent actions and reasoning about unreliable communication.
- How deep it goes
- Defines message uncertainty and develops timeline reasoning, but defers detailed implementation of distributed protocols.
- Examples
- Uses network message rules, frontend/backend sharing, and a dinner-preparation postmortem with dough, sauce, cheese, and timeline diagrams.
- What you can do after
- Evaluate distributed behavior with message-delivery rules and timeline diagrams, then isolate timing-sensitive actions for safer design.
Learn Docker in a Month of Lunches, Second Edition
A distributed system is a system whose components execute across multiple networked processes or computing environments.
- How it is used
- Uses containers to modernize monoliths incrementally and operate flexible, scalable application components.
- How deep it goes
- Explains decomposition, networking, startup behavior, and self-healing operations without descending into application-code internals.
- Examples
- Uses monolith decomposition, private container networking, production clusters, failed dependencies, and out-of-memory container replacement.
- What you can do after
- Operate/configure containerized distributed applications with Docker Compose or Kubernetes, using health checks instead of fixed startup order.
Read how Learn Docker in a Month of Lunches, Second Edition explains distributed system →
The Coder Cafe
A distributed system is a collection of independent computing components that coordinate over a network to provide a unified service or computation.
- How it is used
- Frames database selection and system design as choices among consistency, availability, partition tolerance, speed, and accuracy.
- How deep it goes
- Defines distributed behavior and works through CAP properties and CP, AP, and CA trade-offs, while deferring detailed implementation patterns.
- Examples
- Uses single-node applications, tightly coupled clusters, database choices, and dropped or delayed network messages as concrete contrasts.
- What you can do after
- Evaluate database choices and design decisions by predicting their consistency and availability behavior during network partitions.
Real-World Cryptography
A distributed system is a set of independent computing components that coordinate over a network to provide a shared service or state.
- How it is used
- Builds resilience against server loss by replicating data and coordinating access across multiple machines.
- How deep it goes
- Explains replication, leaders, lag, eventual consistency, forks, and Byzantine faults, but stops short of protocol implementation details.
- Examples
- Uses geographically distributed database replicas, leader-based writes, differing account balances, and contradictory histories as examples.
- What you can do after
- Evaluate replication designs by weighing availability, write conflicts, lag, consistency, crashes, partitions, and compromised servers.
Read how Real-World Cryptography explains distributed system →
Apache Kafka in Action
A distributed system is a set of computing components that coordinate across multiple machines to provide a unified service.
- How it is used
- Frames Kafka architecture around coordination, scaling, replication, and failure handling across multiple servers.
- How deep it goes
- Explains coordination and failure concerns, then stops short of detailed algorithms or implementation procedures.
- Examples
- Uses adding servers, assigning requests, detecting failures, replacing servers, and copying or splitting logs as concrete examples.
- What you can do after
- Evaluate distributed designs by considering coordination, failure behavior, scaling strategy, replication, and operational simplicity.
Read how Apache Kafka in Action explains distributed system →
The Cloud at Your Service: The when, how, and why of enterprise cloud computing
A system whose computing components communicate across multiple networked computers and coordinate their work.
- How it is used
- Frames distributed architecture as a foundation for reliable web and cloud applications.
- How deep it goes
- Distinguishes five architecture patterns and their responsibilities, while stopping short of implementation detail.
- Examples
- Uses client-server, three-tier, N-tier, clustered, and peer-to-peer architectures as concrete patterns.
- What you can do after
- Evaluate web architectures by how they distribute responsibilities and address single points of failure.
Also covered in
- Software Architecture Decision-MakingIn early access (MEAP)
- Microservices Patterns, Second EditionIn early access (MEAP)
- Grokking Software ArchitectureIn early access (MEAP)
- Designing AI SystemsIn early access (MEAP)
- Distributed Machine Learning Patterns
- Test Driven: Practical TDD and Acceptance TDD for Java Developers
- Practices of the Python Pro
- Kafka for Architects
- Troubleshooting Java, Second Edition
- Writing for Developers: Blogs that get read
- Fast Python: High performance techniques for large datasets
- Google Anthos in Action
What to know first
- HTTPHTTP is an application-layer protocol that defines request-and-response communication for transferring resource representations and related metadata between networked systems.
- meanThe mean is a measure of central location equal to the arithmetic average of numerical observations, or the probability-weighted average of a random variable’s possible values.
- scalabilityScalability is the ability of a system or process to accommodate growth in workload, size, or demand while maintaining acceptable operation.
- microservice architectureMicroservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.
Related concepts
- microservice architectureincludes · Microservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.
- networkuses · A network is a set of interconnected nodes and links that represents relationships or enables communication and exchange among the nodes.
- Apache Kafkaincludes · Apache Kafka is a distributed event-streaming platform for publishing, storing, and processing streams of records.
- actorhas part · An actor is a person, system, process, or computational entity that performs actions or participates in interactions within a system.
- web applicationincludes · A web application is software that provides functionality through web technologies and is accessed over a network, typically through a browser or other web client.
- agent orchestrationincludes · Agent orchestration is the coordination of agents, their tasks, tools, and interactions to accomplish a larger objective or workflow.
Questions about distributed system
What is distributed system?
A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
Which Manning books explain distributed system?
Acing the Frontend Interview, Elixir in Action, Third Edition, Think Distributed Systems, Robotics for Programmers, Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform, Building Distributed Applications that Work, LLMs in Production, Effective Platform Engineering and 11 more.
What should I know before learning distributed system?
Manning books that teach distributed system usually introduce HTTP, mean, scalability and microservice architecture first.
What kinds of distributed system are there?
Kinds of distributed system include microservice architecture, Apache Kafka, web application and agent orchestration.
What are the parts of distributed system?
Distributed system includes actor.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.


















