liveBook · Manning

Distributed system

A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.

How 19 Manning books explain it

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.

Read how Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform explains distributed system →

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.

Read how LLMs in Production explains distributed system →

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.

Read how ScyllaDB in Action explains distributed system →

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.

Read how Grokking Simplicity explains distributed system →

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.

Read how The Coder Cafe explains distributed system →

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.

Read how The Cloud at Your Service: The when, how, and why of enterprise cloud computing explains distributed system →

Also covered in

What to know first

Related concepts

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.