Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Designing Distributed Systems

Designing Distributed Systems

Patterns and Paradigms for Scalable, Reliable Services
Build services that handle growth and failure with patterns for problems teams keep rebuilding.
by Brendan Burns 2018 162 pages
3.58
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Build distributed systems from tested patterns, not bespoke fragments

Reuse turns craft into practice. Modern services rely on many machines, yet teams often rebuild the same reliability and scaling mechanisms from scratch. Burns argues that distributed-system patterns can play the role that algorithms and object-oriented design patterns played earlier: they name repeatable solutions, preserve lessons from previous failures, and give teams components they can reuse. Containers and orchestrators make those patterns easier to package and deploy across different languages and applications.

Shared language has practical value. A pattern is a general blueprint, not a recipe tied to one product. Naming a familiar arrangement, such as a sidecar, lets engineers discuss its purpose without repeatedly explaining the entire design. Reusable implementations can also gain wider testing and maintenance than isolated, one-off code.

Analysis

What's striking is that the book treats vocabulary as infrastructure. A common pattern reduces not only duplicated code but also the translation cost between teams, much as a shared technical standard lets independent manufacturers build compatible parts. The benefit depends on preserving room for judgment: patterns make recurring trade-offs visible, but cannot decide whether a particular service needs the added machinery. Reuse is most valuable when the problem truly recurs and the shared component has a clear owner, stable interface, and credible operational support.

Extend legacy applications with sidecars instead of risky rewrites

Add capability at the boundary. A sidecar is a companion container deployed beside an application container on the same machine, sharing selected resources such as networking or files. It augments the application without requiring changes to its source code. That is useful when a service is difficult to rebuild, or when a common capability should be maintained separately.

The HTTPS example shows the leverage. A legacy web server accepts only HTTP on localhost. An nginx sidecar shares its network namespace, receives external HTTPS traffic, and proxies requests to the old server. A configuration sidecar can similarly fetch updated settings, place them in a shared directory, and signal the application to reload. The same arrangement can provide monitoring tools or synchronize Git files for a small deployment platform.

Analysis

The sidecar is a practical expression of the principle of least change: alter the narrowest boundary that can solve the problem. That often lowers the risk of touching a fragile application and lets a specialist component be reused. The security example needs a careful threat model, however. Keeping traffic on loopback can reduce exposure, but it is not a universal replacement for encryption when local processes, shared hosts, or regulatory requirements are in scope. The pattern enables a choice; it does not settle the security policy.

Separate routing and interface translation behind explicit container contracts

Give each container one job. An ambassador brokers an application's communication with external services. An adapter changes the application's interface so other systems can use a common convention. For example, an ambassador can route a legacy client's Redis requests across several shards, discover a database in different environments, or send a controlled share of requests to an experimental service. An adapter can expose Redis metrics in Prometheus's expected format, normalize logs, or provide a database health check.

Make reuse dependable. Treat a container's configuration, network behavior, and exposed endpoints as an API. Document parameters, set sensible defaults, and version interfaces. Even changing a time setting from seconds to milliseconds can break users without producing an error. A shared component saves work only if consumers can rely on its behavior.

Analysis

These patterns resemble an anti-corruption layer in software architecture: a small boundary absorbs differences so the core application does not inherit every external convention. That separation can also align team ownership with system boundaries. The counterweight is operational surface area. Each proxy or adapter can fail, require monitoring, and introduce latency or a new security boundary. A useful design review asks whether the reusable boundary removes more complexity than it creates, rather than assuming that modularity is automatically simpler.

Replicate stateless services, and keep unready replicas out of rotation

Copies provide room for failure. A stateless service can handle requests on any replica, so a load balancer can distribute traffic among copies. Multiple replicas also make upgrades safer: one instance can be replaced while others continue serving. Burns illustrates the availability arithmetic with a single-instance service. At 99.9% availability, its entire daily downtime budget is about 1.4 minutes. Hourly software releases would leave only about 3.6 seconds for each rollout.

Alive is not the same as ready. A server may need to download data, connect to a database, or initialize plugins before it can serve correctly. A readiness probe tells the load balancer when to send traffic; it is distinct from a health check that detects a stuck or failed process. The serving design can add separate replicated layers for caching and HTTPS termination.

Analysis

The distinction between process health and user-facing readiness is a small operational detail with large consequences. It reflects a broader reliability principle: a component's ability to run does not prove its ability to fulfill its contract. Replication helps only when traffic avoids instances that are starting or degraded. Nor does a replica count alone guarantee availability; shared databases, network paths, and bad releases can remain common failure points. Reliability comes from examining dependencies, not simply multiplying servers.

Choose shard keys by response identity, then plan for movement

Shards divide state, not identical capacity. In a sharded service, each node owns only part of the data, and a routing function sends each request to the right part. Burns's cache example makes the motivation concrete: ten cache nodes with 10 GB each can store only about 5% of a 200 GB data set if every node holds the same replicated content. If the nodes hold distinct portions, they can collectively store about 50%.

Route by what changes the answer. Hashing a whole request that includes time and client IP can send equivalent requests to different shards. A better key might be the request path, or country plus path if location changes the response. Consistent hashing limits how many keys move when shard counts change. Monitor hot shards too, since a viral item can overload one otherwise balanced partition.

Analysis

Shard-key design is fundamentally a question about equivalence: which requests can safely share data or computation? That framing helps prevent both overly broad keys, which can return incorrect results, and overly narrow keys, which waste capacity. Consistent hashing reduces disruption during resizing, but does not remove the need to manage data migration, skew, or hot keys. The book's cache example also highlights an important distinction: more aggregate memory does not guarantee a better cache if requests are unevenly distributed.

Scatter computation carefully, because the slowest leaf sets latency

Split independent work, then combine it. In scatter/gather, a root sends parts of a request to multiple workers, or leaves, and gathers their partial results into one response. A document search can look up the terms cat and dog separately, then intersect the returned document lists. When data itself is split across leaves, each searches its own portion and the root combines the matches.

Parallelism has a tail cost. If each leaf has a 1% chance of taking two seconds, a request sent to five leaves has roughly a 5% chance that at least one will be slow. Since the root waits for every required result, the slowest leaf sets the response time. More leaves also add communication overhead. Replicating each shard can improve fault tolerance, but does not make the coordination free.

Analysis

Scatter/gather is a direct application of parallel computing, but its user experience is governed by the tail, not the average worker. This is why optimizing median latency can fail to improve a fanout request. The design question is whether every partial result is essential. If a product can return a useful partial answer, deadlines or graceful degradation can reduce the slowest-worker penalty. If completeness is mandatory, capacity planning and replica health become central parts of the request path.

Use functions for sparse events, not memory-heavy, always-on workloads

Fit the runtime to the workload. Function-as-a-service, or FaaS, runs short-lived functions in response to requests or events and manages their deployment and scaling. It suits irregular tasks such as sending a welcome message, handling a signup event, or transforming an API request. In the book's two-factor authentication example, a function sends a login code asynchronously, so the slower text-message operation does not hold up the login page.

The convenience has limits. Function instances are stateless, depend on external storage for persistent data, and are generally time-bounded. They are a poor fit for long-running background jobs or services that must keep a large search index in memory. Per-request pricing can be attractive for sparse traffic, but sustained request volume may make always-running infrastructure more economical. Monitoring is essential when functions call one another.

Analysis

FaaS shifts the unit of deployment from a service to an event handler. That can shorten the path from an idea to a running feature, while making dependencies less visible across the whole system. The resulting challenge resembles the observability problem in complex organizations: each team or function can look healthy in isolation while the end-to-end process loops or stalls. Cost and latency should therefore be measured against the actual traffic pattern, including initialization and data-loading needs, rather than inferred from the serverless label.

Treat distributed locks as leases, and reject stale owners

Use election only when a singleton is insufficient. An orchestrator can restart one process after failure, making a single-owner service simple and sometimes reliable enough. Multiple replicas with one active owner are appropriate when downtime during failure or software rollout is unacceptable. Distributed key-value stores such as etcd provide atomic compare-and-swap operations that can support locks and elections.

A timeout alone is not safety. A lock can expire while its holder is paused, allowing another process to take ownership. The original process may resume and mistakenly act as master. A renewable lease limits how long ownership lasts, while a stored resource version lets a worker reject requests from an owner whose lease has gone stale. The protected operation must check ownership, not merely trust the process's local belief.

Analysis

This is a lesson in the difference between coordination and authority. A lock service can announce who should act, but a downstream system must still reject commands from an obsolete holder. The resource-version check plays the role of a fencing token: it distinguishes a current ownership epoch from an earlier one. Lease-based designs also depend on timing and communication assumptions, so the safe response to uncertainty is often to stop acting. Distributed ownership is not just a lock algorithm; it is an end-to-end validation rule.

Design batch work as explicit graphs, with the right kind of reunion

Make work items and stages explicit. A work queue divides independent items among workers. A reusable queue manager can obtain items through a source interface, launch worker jobs through an orchestrator, and record completion. If arrivals exceed effective processing capacity for long enough, the backlog grows without bound, so worker parallelism must match the workload.

Choose coordination to match the result. Workflow stages can copy an item into several queues, filter items, split them by condition, distribute them across shards, or merge streams. A join is a barrier: it waits until every required branch finishes before releasing work. A reduce repeatedly combines partial results, such as word counts, and can begin before all input is complete. Video transcoding and image analysis illustrate how these patterns compose into larger pipelines.

Analysis

The graph view makes batch systems easier to reason about because it exposes where work branches, waits, or combines. It also reveals failure and ownership questions that a list of scripts can hide: what happens to an item after a worker crashes, or when a branch finishes twice? The distinction between join and reduce is especially useful. A barrier offers completeness but delays downstream work; incremental reduction can improve throughput when the operation supports safe combination. The right choice depends on the meaning of a complete result.

Analysis

The book's central contribution is not a catalogue of fashionable infrastructure. It is a way to move distributed-systems knowledge from individual experience into reusable boundaries. Its narrative follows software abstraction through algorithms, object-oriented patterns, and container orchestration, arguing that each step makes a larger class of systems buildable by more people. That claim is persuasive when patterns describe stable recurring problems: adding capabilities around an application, routing requests, dividing state, coordinating ownership, and processing batches.

The strongest sections connect an abstract pattern to a concrete failure mode. Readiness matters because a running process may not yet be useful. Sharding depends on the semantics of the key, not merely a hashing function. Scatter/gather makes tail latency a property of the slowest required worker. A lease can expire while an old owner is still executing. These are memorable because each pattern comes with a condition under which it fails.

The book's organizing lens is also its limitation. Containers and orchestrators make components deployable, but deployability is not the same as simplicity. Every boundary adds contracts, network behavior, monitoring requirements, and operational ownership. A sidecar can isolate change, while also multiplying processes; a function can simplify deployment while scattering observability; a replicated service can survive one failure while retaining a shared dependency that takes everything down. The patterns are therefore most useful as questions to ask, not boxes to tick.

A modern reading should pair the book's reusable blueprints with explicit service objectives, failure testing, and cost measurement. Teams should identify the request or event contract, define which failures users can tolerate, and verify behavior under partial failure and load. In that sense, the book's deeper lesson is organizational as much as technical: reliability improves when teams inherit well-understood mechanisms, but only when they understand the assumptions those mechanisms depend on.

Summary in 30 Seconds
Reusable design patterns let teams share proven solutions to recurring infrastructure problems. Companion containers can add capabilities to legacy software without changing its source, while replicas improve availability when readiness checks keep unprepared instances out of service. Shard keys should reflect what determines a response, and scatter operations inherit the delay of their slowest required worker. Short-lived functions suit sparse events, while renewable leases and ownership checks prevent expired lock holders from acting. Batch pipelines need coordination matched to their results.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.58 out of 5
Average of 500+ ratings from Goodreads and Amazon.

Designing Distributed Systems receives mixed reviews. Many readers find it a good introduction to container-based systems and Kubernetes, but criticize its narrow focus and misleading title. Some praise its concise overview of distributed system patterns, while others feel it lacks depth. The book is recommended for those new to the field or working with Kubernetes, but experienced professionals may find limited value. Readers appreciate the practical examples and hands-on sections, though some find the content too basic or heavily biased towards specific technologies.

Your rating:
4.19
145 ratings
Want to read the full book?

Glossary

sidecar pattern

Companion container adds capability

A single-node arrangement in which an application container runs beside a companion container that augments it. The containers share selected resources, such as networking or files. The companion can add functions like HTTPS proxying, configuration synchronization, or monitoring without requiring changes to the application itself.

ambassador pattern

Container brokers external connections

A companion container that mediates communication between an application and external services. The application can connect to a local endpoint while the ambassador handles tasks such as routing requests to storage shards, finding a service in a particular environment, or splitting traffic between production and experimental systems.

adapter pattern

Container standardizes an interface

A companion container that translates an application's existing interface into one expected by other systems. An adapter can convert application metrics into a monitoring system's format, normalize logs, or expose a richer health check. It allows heterogeneous applications to work with shared operational tools.

readiness probe

Signals when traffic is safe

A check that reports whether an application is prepared to serve requests. A process can be running but not ready because it is still loading data, connecting to dependencies, or initializing plugins. Load balancers use readiness information to avoid sending traffic prematurely; it is distinct from a check used to restart a failed process.

sharded service

Service partitions data ownership

A service whose nodes each handle only a portion of the overall data or request space. A routing component uses a sharding function to direct each request to the shard responsible for it. Sharding allows a stateful service to handle more data than one machine can store, but requires careful key selection and routing.

consistent hashing function

Limits remapping during resizing

A hashing approach used to assign keys to service shards while minimizing how many assignments change when the number of shards changes. Unlike simple hash-and-modulo routing, which can remap many keys after a resize, consistent hashing preserves most existing mappings, reducing disruption such as cache misses during scaling.

scatter/gather pattern

Parallel work, combined response

A request-processing arrangement in which a root distributes parts of a computation to multiple worker nodes, then collects and combines their partial results. It can reduce processing time when work is independent, but the response often waits for the slowest required worker and therefore becomes sensitive to tail latency.

function-as-a-service (FaaS)

Runs functions in response to events

A computing model in which developers deploy individual functions that execute in response to requests or events. The platform manages instances and scaling, while functions are generally stateless and depend on external storage for persistent data. FaaS fits intermittent, short-lived tasks better than long-running or memory-intensive services.

master election

Selects one active owner

A distributed process for choosing one active replica to own a task or resource, and selecting a replacement if that replica fails. It commonly relies on a consensus-backed key-value store and leases or locks. Correctness requires downstream systems to reject work from a replica that has lost ownership.

work queue

Distributes independent batch items

A batch-processing system that obtains a collection of work items and assigns them to workers, generally allowing items to be processed independently. A reusable queue manager can track progress and launch worker jobs through an orchestrator. Sustainable operation requires enough effective worker capacity to keep up with incoming work.

join pattern

Waits for every branch

A coordination pattern that holds downstream work until all required parallel tasks have completed. Also called barrier synchronization, it ensures that a complete set of results is available for later processing. Its guarantee of completeness can increase latency because the next stage cannot start while any required branch remains unfinished.

reduce pattern

Combines partial outputs

A batch-processing pattern that combines multiple partial results into a smaller, more comprehensive result. Examples include summing counts or merging word-frequency tables. Reduction can be repeated across intermediate outputs, often in parallel, and can begin before all input work has finished when the operation supports safe combination.

FAQ

1. What is "Designing Distributed Systems" by Brendan Burns about?

  • Comprehensive guide to patterns: The book introduces and explains reusable patterns and paradigms for building scalable, reliable distributed systems, focusing on practical implementation.
  • Focus on containers and orchestration: It emphasizes the role of containers and container orchestrators (like Kubernetes) as foundational tools for modern distributed system design.
  • Bridging theory and practice: Brendan Burns provides both conceptual overviews and hands-on examples, making complex distributed systems more accessible to developers.
  • Pattern-driven approach: The book organizes distributed system design into repeatable, generic patterns, aiming to transform system building from a black art into a more scientific, standardized process.

2. Why should I read "Designing Distributed Systems" by Brendan Burns?

  • Demystifies distributed systems: The book makes the design and development of distributed systems approachable, even for those without deep prior experience.
  • Reusable knowledge and tools: It provides a shared vocabulary and set of patterns, enabling developers to avoid reinventing the wheel and to build on proven solutions.
  • Practical, hands-on focus: Readers gain actionable advice, code samples, and real-world deployment scenarios, especially using containers and Kubernetes.
  • For all experience levels: Whether you’re new to distributed systems or an experienced engineer, the book offers insights and best practices to improve your efficiency and system reliability.

3. What are the key takeaways from "Designing Distributed Systems" by Brendan Burns?

  • Patterns accelerate development: Recognizing and applying distributed system patterns saves time, reduces errors, and improves system quality.
  • Containers enable modularity: Containers and orchestrators like Kubernetes are essential for building, deploying, and managing reusable system components.
  • Separation of concerns: Patterns like sidecar, ambassador, and adapter help modularize functionality, making systems easier to scale, maintain, and evolve.
  • Community and reuse: Open source and shared patterns foster a collaborative environment where developers can leverage each other’s work for faster, more reliable results.

4. Who is the intended audience for "Designing Distributed Systems" by Brendan Burns?

  • Developers of all levels: The book is suitable for both newcomers to distributed systems and seasoned professionals seeking to formalize their knowledge.
  • Cloud-native practitioners: Those working with containers, Kubernetes, or cloud APIs will find the book especially relevant and practical.
  • Teams building scalable services: It’s valuable for organizations aiming to improve reliability, scalability, and agility in their software systems.
  • Anyone interested in patterns: Readers who appreciate structured approaches and reusable solutions in software engineering will benefit from the book’s pattern-centric methodology.

5. How does Brendan Burns define and use patterns in "Designing Distributed Systems"?

  • General blueprints, not recipes: Patterns are described as reusable, technology-agnostic blueprints for organizing distributed systems, rather than step-by-step instructions for specific technologies.
  • Shared language and best practices: Patterns provide a common vocabulary, enabling teams to communicate more effectively and learn from each other’s experiences.
  • Basis for reusable components: By formalizing patterns, developers can create modular, containerized components that are easily shared and reused across projects.
  • Examples throughout the book: The book details specific patterns like sidecar, ambassador, adapter, replicated services, sharded services, and more, illustrating their application with real-world scenarios.

6. What are the main single-node patterns discussed in "Designing Distributed Systems" by Brendan Burns?

  • Sidecar pattern: Augments an application container with additional functionality (e.g., adding HTTPS, dynamic configuration) without modifying the original application.
  • Ambassador pattern: Acts as a proxy or broker between the application and external services, enabling sharding, service brokering, or request splitting.
  • Adapter pattern: Modifies the interface of an application container to conform to expected standards (e.g., for monitoring, logging, or health checks).
  • Emphasis on modularity: These patterns encourage breaking up applications into focused, reusable containers, improving maintainability and scalability.

7. How does "Designing Distributed Systems" by Brendan Burns address multi-node (serving) patterns?

  • Replicated load-balanced services: Describes how to scale stateless services using replication and load balancing for high availability and performance.
  • Sharded services: Explains partitioning stateful services across multiple nodes to handle large data sets and improve scalability.
  • Scatter/gather pattern: Details parallelizing computation across nodes to reduce response time for complex queries or processing tasks.
  • Ownership election: Covers distributed coordination for assigning exclusive ownership or master roles among replicas, ensuring reliability and failover.

8. What role do containers and Kubernetes play in "Designing Distributed Systems" by Brendan Burns?

  • Foundational building blocks: Containers are presented as the atomic units for encapsulating application logic, dependencies, and configuration.
  • Orchestration for reliability: Kubernetes and similar orchestrators automate deployment, scaling, and management of containerized applications, making distributed patterns practical.
  • Pattern implementation: Many patterns in the book are illustrated with Kubernetes YAML files, showing how to deploy and manage complex systems using container orchestration.
  • Reusable, language-agnostic components: By packaging patterns as containers, they can be reused across different programming languages and environments.

9. How does "Designing Distributed Systems" by Brendan Burns approach batch computational patterns?

  • Work queue systems: Introduces generic, reusable work queue architectures for parallel batch processing, with clear interfaces for sources and workers.
  • Event-driven batch processing: Describes chaining and coordinating work queues using patterns like copier, filter, splitter, sharder, and merger to build complex workflows.
  • Coordinated batch processing: Explains aggregation patterns such as join (barrier synchronization) and reduce (as in MapReduce) for combining results from parallel tasks.
  • Hands-on examples: Provides practical scenarios (e.g., video thumbnailing, image tagging) to demonstrate how these batch patterns are implemented with containers and orchestration.

10. What are the most important concepts and definitions introduced in "Designing Distributed Systems" by Brendan Burns?

  • Pattern: A reusable, general solution to a recurring problem in distributed system design, independent of specific technologies.
  • Sidecar, Ambassador, Adapter: Key single-node patterns for modularizing and extending containerized applications.
  • Replicated, Sharded, Scatter/Gather: Core multi-node patterns for scaling, partitioning, and parallelizing distributed services.
  • Ownership election: Mechanisms for distributed coordination and master selection, often using tools like etcd or ZooKeeper.
  • Batch processing patterns: Work queues, event-driven workflows, and coordinated aggregation (join/reduce) for large-scale data processing.

11. What practical advice does Brendan Burns give for designing modular, reusable distributed systems in "Designing Distributed Systems"?

  • Parameterize containers: Expose configuration via environment variables or command-line arguments to make containers flexible and reusable.
  • Define clear APIs: Treat each container’s interface as a contract, maintaining backward compatibility and documenting expected inputs/outputs.
  • Document containers: Use Dockerfile comments, labels, and metadata to provide usage instructions and maintainability information.
  • Leverage orchestration: Use Kubernetes features like Deployments, Services, ConfigMaps, and Jobs to automate and manage distributed patterns effectively.

12. What are some of the best quotes from "Designing Distributed Systems" by Brendan Burns, and what do they mean?

  • “Patterns are the basis for the definition and development of such reusable components.”
    This highlights the central thesis that formalizing patterns enables the creation of shared, modular building blocks for distributed systems.
  • “Distributed system design continues to be more of a black art practiced by wizards than a science applied by laypeople.”
    Burns points out the historical complexity of distributed systems and the need for standardization and democratization through patterns.
  • “Standing on the shoulders of giants.”
    The book encourages learning from established best practices and the experiences of others, rather than reinventing solutions.
  • “Containers are the foundational building block for the patterns in this book.”
    This underscores the importance of containers in enabling modularity, reuse, and automation in modern distributed system design.
  • “The identification of common patterns and practices has regularized and improved the practice of algorithmic development and object-oriented programming. It is this book’s goal to do the same for distributed systems.”
    Burns draws a parallel between the evolution of programming paradigms and the current need for standardized distributed system patterns.

About the Author

Brendan Burns is a prominent figure in the field of distributed systems and cloud computing. As a co-founder of Kubernetes and a distinguished engineer at Microsoft, Burns has extensive experience in designing and implementing large-scale distributed systems. His work focuses on container orchestration, cloud-native applications, and microservices architecture. Burns is known for his contributions to the open-source community and his efforts to simplify complex distributed systems concepts for developers. He has authored several books and frequently speaks at technology conferences, sharing his expertise and insights on modern software architecture and cloud computing.

Download PDF

To save this Designing Distributed Systems summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.42 MB     Pages: 21

Download EPUB

To read this Designing Distributed Systems summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.42 MB     Pages: 28
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...