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
Production-Ready Microservices

Production-Ready Microservices

Building Standardized Systems Across an Engineering Organization
Give teams room to ship services independently without making reliability everyone else's problem.
by Susan J. Fowler 2016 172 pages
3.82
460 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Microservices earn autonomy only when every service proves production readiness.

Freedom raises the stakes. Splitting a large application into small, independently deployed services can improve scaling and developer speed. It also multiplies dependencies, failure paths, and operational work. At Uber, Fowler began a readiness initiative when the company had more than a thousand services and over 85% had little or no SRE support. The challenge was not merely building services, but making them trustworthy across the whole system.

Trust needs evidence. Production-readiness means a service meets measurable requirements before it handles real customer traffic. Fowler organizes those requirements around eight concerns: stability, reliability, scalability, fault tolerance, catastrophe-preparedness, performance, monitoring, and documentation. Availability is the outcome they jointly protect, not a substitute for specifying how a service should be built and operated.

Analysis

What's powerful here is the shift from treating reliability as a virtue to treating it as an organizational design problem. A service can be well engineered in isolation yet still destabilize the product through its dependencies. This resembles safety engineering in aviation and medicine, where dependable outcomes require layered controls, not confidence in individual competence. The framework also guards against a common category error: high uptime today does not prove that a service can handle tomorrow's growth or recover from failure. The practical challenge is avoiding checklist theater. Standards matter when they change design decisions and operational behavior, not when teams merely report green boxes.

Split a monolith only when teams and infrastructure can support the resulting ecosystem.

Decomposition is the hard part. Monoliths become difficult to change as features, code, traffic, and teams grow. Microservices divide work into smaller applications that can be developed and scaled separately. But splitting by arbitrary code boundaries can produce several small monoliths, each with tangled responsibilities. Fowler recommends identifying the product's main functions, then making services as focused and independent as possible. A migration may extract existing code or rebuild a service, with traffic shadowing used to compare its behavior before switching over.

Architecture reshapes organization. The Inverse Conway’s Law, as Fowler uses the term, is the idea that a product's architecture shapes the company's team structure. Independent services tend to create specialized, independent teams, even though their systems remain interdependent. Small companies may lack the platform infrastructure and operational staff needed to support that arrangement, so microservices are not automatically the best starting point.

Analysis

The key is to evaluate microservices as a whole operating model, not just a code organization. This aligns with socio-technical systems thinking: tools, responsibilities, communication patterns, and architecture shape one another. Fowler's warning about premature decomposition is especially useful because the costs arrive before the benefits are clear. A modular monolith can preserve clear boundaries while avoiding the network and coordination overhead of separate services. The relevant question is not whether a company is modern enough for microservices, but whether independent deployment and scaling solve a real constraint that justifies new operational complexity.

Move every change through staging, a representative canary, and gradual production rollout.

A deployment is a risk journey. Fowler's deployment pipeline moves a candidate build through staging, a canary, and then the broader production fleet. Staging tests a release without ordinary production traffic. It can mirror the whole ecosystem, or it can connect a service's staging environment to production dependencies. Full staging avoids affecting production services but can be costly and may test interacting versions unlike those in the real system. Partial staging reflects real dependencies more closely, but bad test traffic can harm them.

Canaries test reality. A canary is a small, randomized portion of production capacity that runs the new build on real traffic. Fowler describes a typical canary as handling roughly 5% to 10% of production traffic. Keep it through a representative traffic cycle, monitor it, and automatically roll back if key measures worsen. Only then expand the release, ideally in increments.

Analysis

This pipeline is a form of controlled experimentation: each phase exposes a change to more realistic conditions while limiting the cost of being wrong. The canary's value depends on whether it represents the production system. A tiny pool that misses a region, customer pattern, or dependency path can create false confidence. Progressive rollout also depends on meaningful health signals and a fast rollback path. The broader lesson is that safe deployment is not achieved by testing everything in advance; it comes from combining pre-release checks with carefully bounded exposure to the real environment.

A four-nines promise allows 52 minutes of yearly downtime before dependency losses.

Availability has a budget. A service with 99.99% availability, often called four-nines, can be down for about 52.56 minutes per year. That allowance sounds generous until outages accumulate or dependencies consume part of the same reliability margin. If a service must call several other services to complete a request, the whole request can fail when any required link fails. In a chain of independent, required dependencies, end-to-end availability is approximately the product of their individual availability figures.

Protect the chain. First identify clients and dependencies, then plan for dependency failure with alternatives, queues, fallbacks, or defensive caching. Defensive caching means retaining data retrieved from a dependency so the service can still answer some requests if that dependency becomes unavailable. For example, a receipt service may be unable to send a receipt if customer or order data cannot be retrieved, unless it has a safe fallback.

Analysis

The arithmetic makes a network of dependencies feel less abstract: each required link spends some of the system's reliability margin. The independence assumption matters, though. Shared infrastructure can make failures correlated, so multiplying service availability figures may understate risk. Caching can protect availability, but it introduces questions about staleness, privacy, and whether an old answer is safer than no answer. Reliability decisions are therefore product decisions as well as technical ones. Teams need to decide which operations can degrade gracefully and which must fail closed to protect correctness.

Translate business growth into requests, then plan capacity around the tightest bottleneck.

Start with the product. A qualitative growth scale connects a service's workload to a business measure, such as app opens, customers, or orders. A quantitative growth scale translates that measure into traffic the service must handle, such as requests or transactions per second. Knowing only that a service handles a certain number of requests per second is not enough; teams need to know what business activity drives those requests and how that activity may change.

Plan from one instance outward. Measure the traffic and resources one instance can sustain, identify constraints such as CPU, memory, or database connections, and use those findings to plan capacity. Fowler favors horizontal scaling, adding instances, supported by concurrency and partitioning, splitting work so multiple workers can process it in parallel. Capacity planning should account for dependency growth, traffic bursts, budgets, and the lead time needed to obtain hardware.

Analysis

Connecting engineering load to business activity creates a shared planning language between product, finance, and infrastructure teams. It also exposes hidden multipliers: one customer action may trigger several requests across a dependency chain. This is more useful than extrapolating last week's traffic, though forecasts remain uncertain and should be revisited against actual demand. Bottlenecks can migrate as capacity grows, so adding servers is not a permanent cure if a shared database or connection pool remains fixed. Good capacity planning combines measurement with explicit assumptions, then checks whether those assumptions still hold.

Break services deliberately before ordinary dependency failures break the system.

Failure is a design condition. A single point of failure is any component whose loss can bring down a service or system. Fowler's example is a task-processing service whose workers stop consuming jobs. Its message broker continues accumulating work until it runs out of memory, potentially disrupting other services that share it. Mapping the architecture and asking what happens when each component fails can expose risks before an outage does.

Test recovery, not optimism. Resiliency testing includes code tests, load tests, and chaos testing. Chaos testing deliberately causes failures, such as disabling a dependency, adding network latency, or removing a host, to check whether the system recovers. These tests need tight controls, permissions, and logs so a test does not become the catastrophe. When incidents occur, the response proceeds through assessment, coordination, mitigation, resolution, and follow-up, including a blameless review and concrete corrective actions.

Analysis

The book's strongest move is to treat failure scenarios as hypotheses that can be tested rather than as unpleasant surprises. That idea connects to experimental science: a system's resilience claim is meaningful only when it survives a relevant test. Production chaos tests are powerful but should be introduced with a bounded blast radius, clear abort conditions, and an understanding of customer impact. The incident sequence also distinguishes mitigation from fixing the root cause. Restoring service quickly and learning why it failed are separate jobs, both necessary for dependable operations.

Make every alert actionable, and automate detection and rollback before paging humans.

Monitor the service's state. Useful monitoring covers host and infrastructure measures, such as CPU, memory, and database connections, as well as service measures, such as latency, endpoint success, errors, and dependency health. Logs should help reconstruct what happened, but must not expose private information or secrets. Dashboards should make health legible at a glance. They support diagnosis, but developers should not have to watch them continuously to detect an outage.

Page only with a next step. Set normal, warning, and critical thresholds for key measures, and tune them to catch real problems without flooding the on-call team. Each alert should lead to an action described in a runbook. Repeated, predictable responses are candidates for automation, including rollback after a bad deployment. The book also recommends shared on-call responsibility, with at least two developers on a shift and shifts no longer than a week.

Analysis

Monitoring is an information system designed for people under pressure. A page that reports a symptom but offers no useful response transfers cognitive work to an engineer who may be tired and unfamiliar with the service. Runbooks, clear dashboards, and automated rollback reduce that burden. Yet comprehensive monitoring can become expensive and noisy, so the goal is not to collect every possible datum or alert on every fluctuation. Thresholds should reflect consequences: a metric matters operationally when a change predicts harm or requires someone to act.

Whiteboard architectures and keep documentation current, so hidden assumptions surface before outages.

Make knowledge visible. Fowler describes bringing a service's developers together to diagram its endpoints, request paths, and dependencies in a short architecture review. The exercise often reveals that teammates hold different mental models of the same service, as well as overlooked failure points. Good documentation should give other engineers the facts needed to use, change, and support the service: its purpose, architecture, contacts, onboarding steps, request flows, dependencies, alerts, and runbooks.

Turn gaps into work. A production-readiness audit checks a service against agreed requirements. Its results can become a roadmap that assigns unsatisfied requirements to owners and links them to implementation tasks. Regular reviews keep the diagram and shared understanding current. Automating checks can make readiness visible across an organization, but teams still need to interpret what a failed requirement means for their particular service.

Analysis

This is a practical account of distributed cognition: no single engineer needs to hold the entire system in memory if diagrams, runbooks, and shared review practices make knowledge accessible. Documentation is most valuable when it changes work, not when it is treated as a parallel writing project. Requiring updates alongside code changes helps, but can also produce stale documents if compliance becomes mechanical. Architecture reviews add a social test: can several people explain how the service behaves, including when its dependencies fail? That shared understanding is a form of operational capacity.

Standardize shared interfaces and safety rails without erasing useful service-level autonomy.

Autonomy needs boundaries. Microservice teams may choose different internal designs, but services still need compatible ways to communicate and be operated. Fowler argues for common standards across the ecosystem, including communication patterns, deployment processes, monitoring expectations, and production-readiness requirements. Without them, a large organization can accumulate many competing ways to deploy, test, alert, and maintain software.

Platforms reduce repeated work. Self-service tools let service teams use complex infrastructure without becoming experts in every underlying system. Supporting too many programming languages can also multiply the work required to build libraries and internal tools, so organizations may need to limit supported languages. These guardrails should be shaped with input from leadership, infrastructure teams, and developers, and presented as support for safe delivery rather than as arbitrary obstacles.

Analysis

The important distinction is between standardizing the interfaces that teams depend on and dictating every internal implementation. Platform engineering works best when common tools make the safe path convenient, while teams retain room to solve genuinely different problems. Too little standardization creates incompatible practices and duplicated maintenance; too much can turn the platform group into a bottleneck or freeze useful experimentation. A good governance model treats standards as revisable contracts, with a clear process for exceptions and evidence that a rule improves reliability, efficiency, or both.

Analysis

Fowler's central argument is that microservices convert architectural independence into an ongoing organizational obligation. A service can be deployed separately, but it cannot be made reliable separately: its availability depends on infrastructure, clients, dependencies, deployment tools, and the people who respond when something breaks. The book's production-readiness model is valuable because it makes this interdependence actionable. It joins design, operations, documentation, and team structure under the concrete question of whether a service can be trusted with real traffic.

The framework's deeper strength is its insistence on observable evidence. A service's growth should connect to business demand; its deployment should expose changes gradually; its failures should be rehearsed; and its readiness should be reviewed and tracked. This resembles safety engineering, where reliability comes from multiple defenses and repeated verification rather than a single claim of quality. It also treats documentation and shared understanding as operational controls, not administrative extras.

The model nevertheless carries a tension. A universal checklist can make large systems legible, but any checklist can become a proxy for the outcome it is meant to protect. Teams may optimize scores rather than reduce risk, or interpret uniform requirements without accounting for service criticality and failure consequences. Fowler's emphasis on measurable standards is strongest when paired with judgment, explicit exceptions, and learning from incidents. The same caution applies to automation: automated audits can identify missing controls at scale, but they cannot fully decide whether a fallback returns safe data or whether a dependency is truly optional.

The book is also a practical argument for platform investment. Self-service infrastructure, standardized deployment, and accessible service knowledge are what let local teams move quickly without requiring every developer to master the entire ecosystem. Microservices are therefore not simply smaller programs. They are a bargain: teams receive independent delivery in exchange for disciplined contracts, explicit ownership, and system-wide care. The bargain pays off only when the organization builds the machinery that makes those obligations manageable.

Summary in 30 Seconds
Independent services multiply failure paths and operational work, so each needs measurable checks for reliability, scaling, monitoring, and recovery. A 99.99% availability target permits about 52.56 minutes of yearly downtime, and required dependencies reduce end-to-end availability. Test releases on 5% to 10% of production traffic before expanding them. Tie expected requests to business growth, plan for bottlenecks, rehearse failures, and use shared tools and standards to support team autonomy.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.82 out of 5
Average of 460 ratings from Goodreads and Amazon.

Production-Ready Microservices by Susan Fowler receives mixed reviews. Readers appreciate its high-level overview and checklists for production-readiness, finding it useful for managers and engineers new to microservices. However, many criticize its lack of technical depth and practical examples. The book is praised for its focus on organizational aspects and production readiness, but some find it repetitive and too abstract. It's recommended as a complementary read to more technical microservices books, particularly for those in management roles or seeking a broad understanding of microservice ecosystems.

Your rating:
4.34
330 ratings
Want to read the full book?

Glossary

production-readiness

Evidence of operational trust

The condition of a service meeting defined architectural and operational requirements before it is trusted with production traffic. Fowler organizes those requirements around stability, reliability, scalability, fault tolerance, catastrophe-preparedness, performance, monitoring, and documentation. The purpose is to support availability through concrete practices rather than rely on a vague instruction to make a service dependable.

Inverse Conway’s Law

Architecture shapes team structure

Fowler's term for the idea that an organization's structure is shaped by the architecture of its product. In a microservice ecosystem, many independent services tend to produce many specialized teams. Those teams may become isolated in their knowledge and goals, even though their services depend on one another and must coordinate.

deployment pipeline

Phased release process

The staged process for moving a new build toward production. In Fowler's model, a build passes through staging, then a canary exposed to a small portion of real production traffic, and finally a wider production rollout. Monitoring and automated rollback help detect problems while limiting how many users and dependent services are affected.

defensive caching

Cached data guards availability

The practice of retaining data obtained from a dependency so a service can continue to answer some requests when that dependency becomes unavailable. Fowler presents it as one possible way to reduce the impact of dependency failures. Whether cached information is safe to use depends on the service's requirements for accuracy and freshness.

qualitative growth scale

Business driver of workload

A high-level description of what business activity causes a service's workload to grow. Examples include app opens, customers, and orders. It gives traffic measurements context, helping engineers translate product forecasts into likely demand on a service rather than extrapolating request counts without knowing what drives them.

quantitative growth scale

Measured service demand

A numerical expression of the workload a service must handle, commonly measured in requests, queries, or transactions per second. It is derived from the qualitative growth scale. For example, a business forecast can be translated into expected requests once the team understands how many requests each relevant user or transaction generates.

chaos testing

Deliberate failure experiments

A form of resiliency testing that intentionally introduces known failures, such as disabling a dependency, adding network latency, or removing a host. The purpose is to verify that services detect and recover from faults. Fowler emphasizes that tests need controls, appropriate permissions, and logging so the experiment itself does not cause uncontrolled damage.

production-readiness roadmap

Plan to close readiness gaps

A plan created from a production-readiness audit that lists requirements a service has not yet met and the work needed to address them. Fowler proposes linking each gap to implementation details, relevant incidents, a tracked task, and responsible developers. The roadmap turns a readiness assessment into prioritized, owned engineering work.

five stages of incident response

Structured incident workflow

Fowler's sequence for handling an incident: assessment, coordination, mitigation, resolution, and follow-up. Assessment determines severity and scope. Coordination brings in the people who can help. Mitigation reduces impact, resolution addresses the cause, and follow-up records learning and corrective actions, often through a blameless postmortem.

FAQ

What's "Production-Ready Microservices" by Susan J. Fowler about?

  • Focus on Microservices: The book provides a comprehensive guide on building and maintaining microservices that are ready for production environments.
  • Standardization Across Organizations: It emphasizes the importance of standardizing systems across an engineering organization to ensure reliability and efficiency.
  • Real-World Application: The content is based on the author's experience at Uber, where she led a production-readiness initiative for microservices.
  • Comprehensive Framework: It offers a detailed framework for achieving production-readiness, covering aspects like stability, reliability, scalability, and more.

Why should I read "Production-Ready Microservices"?

  • Expert Insights: Gain insights from Susan J. Fowler, who has firsthand experience in transforming Uber's microservices.
  • Practical Guidance: The book provides actionable steps and checklists to help engineers implement production-ready standards.
  • Organizational Impact: Learn how to drive high standards across teams, improving overall system reliability and performance.
  • Future-Proofing Skills: Understanding microservices is crucial for modern software development, and this book equips you with the necessary skills.

What are the key takeaways of "Production-Ready Microservices"?

  • Eight Principles: The book outlines eight principles for production-readiness: stability, reliability, scalability, fault tolerance, catastrophe-preparedness, performance, monitoring, and documentation.
  • Standardization is Key: Standardizing microservices across an organization is essential for maintaining high availability and reliability.
  • Comprehensive Framework: It provides a detailed framework for evaluating and improving microservices, including checklists and roadmaps.
  • Organizational Buy-In: Successful implementation requires buy-in from all levels of an organization, from developers to executives.

How does Susan J. Fowler define "production-ready" in microservices?

  • Trustworthy Services: A production-ready service is one that can be trusted to serve production traffic reliably.
  • Quantifiable Standards: It must meet quantifiable standards across eight key principles, ensuring high availability.
  • Comprehensive Testing: The service should undergo thorough testing, including code, load, and chaos testing.
  • Continuous Monitoring: Proper logging, dashboards, and alerting are essential to maintain production-readiness.

What are the eight production-readiness principles in "Production-Ready Microservices"?

  • Stability: Ensures that changes do not introduce instability across the ecosystem.
  • Reliability: Builds trust by ensuring services perform as expected under various conditions.
  • Scalability: Prepares services to handle growth in traffic and tasks efficiently.
  • Fault Tolerance: Ensures services can withstand and recover from failures and catastrophes.

How does "Production-Ready Microservices" suggest handling dependencies?

  • Identify and Document: Know and document all dependencies, including their SLAs and potential failure points.
  • Mitigation Strategies: Implement backups, alternatives, fallbacks, or caching to handle dependency failures.
  • Communication: Maintain open communication with dependency teams to prepare for changes and potential issues.
  • Defensive Caching: Use caching to protect your service from dependency failures, ensuring continued availability.

What is the role of monitoring in "Production-Ready Microservices"?

  • Key Metrics: Identify and monitor key metrics at the host, infrastructure, and microservice levels.
  • Logging: Implement comprehensive logging to understand the state of the service at any time.
  • Dashboards: Use dashboards to provide a real-time view of the service's health and status.
  • Alerting: Set actionable alerts with signal-providing thresholds to detect and address issues promptly.

How does "Production-Ready Microservices" address scalability and performance?

  • Growth Scales: Understand both qualitative and quantitative growth scales to plan for future capacity needs.
  • Efficient Resource Use: Use hardware resources efficiently and identify resource bottlenecks.
  • Traffic Management: Handle traffic intelligently, preparing for bursts and rerouting as needed.
  • Task Processing: Ensure tasks are processed efficiently, optimizing for concurrency and partitioning.

What are the best quotes from "Production-Ready Microservices" and what do they mean?

  • "Form is liberating": This quote emphasizes that standardization and structure can enhance freedom and creativity in software development.
  • "Always give an onion": A metaphor for sharing knowledge and documentation, ensuring that others can benefit from your work.
  • "No microservice is an island": Highlights the interconnected nature of microservices and the importance of understanding dependencies.
  • "The system will break in any way that it can be broken": A reminder of the inevitability of failures and the need for thorough testing and preparation.

How does "Production-Ready Microservices" suggest implementing production-readiness across an organization?

  • Top-Down and Bottom-Up: Requires buy-in from executives and developers, integrating standards into the organizational culture.
  • Automated Checks: Automate production-readiness checks to ensure continuous compliance with standards.
  • Publicize Results: Share production-readiness scores internally to maintain awareness and drive improvements.
  • Continuous Improvement: Regularly review and update standards and practices to adapt to changing needs and technologies.

What are the common challenges in microservice standardization according to "Production-Ready Microservices"?

  • Organizational Siloing: Microservices can lead to isolated teams, requiring efforts to maintain communication and collaboration.
  • Technical Sprawl: Diverse tools and languages can lead to inefficiencies, necessitating standardization.
  • Resource Competition: Finite resources require prioritization and efficient allocation to maintain service availability.
  • Failure Management: Complex systems introduce more failure points, requiring robust testing and mitigation strategies.

How does "Production-Ready Microservices" address fault tolerance and catastrophe-preparedness?

  • Identify Failures: Recognize potential failure scenarios and single points of failure within the service.
  • Resiliency Testing: Conduct code, load, and chaos testing to ensure services can recover from failures.
  • Automated Remediation: Implement automated failure detection and remediation strategies to minimize downtime.
  • Incident Response: Develop standardized incident response procedures to quickly assess, coordinate, mitigate, and resolve issues.

About the Author

Susan Fowler is a software engineer and author known for her work on microservices and her advocacy for workplace equality. She gained prominence after publishing a blog post detailing her experiences of sexual harassment and discrimination at Uber, which led to significant changes in the company's culture. Fowler's background includes roles at several tech companies, where she worked on large-scale distributed systems and microservices. Her book "Production-Ready Microservices" draws from her practical experience in the field. Fowler has also written for various publications and is recognized for her contributions to tech industry discussions on both technical and cultural issues.

Download PDF

To save this Production-Ready Microservices summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.39 MB     Pages: 22

Download EPUB

To read this Production-Ready Microservices 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.40 MB     Pages: 27
Want to read the full book?
Follow
Listen9 mins
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...