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
Building Secure and Reliable Systems

Building Secure and Reliable Systems

Best Practices for Designing, Implementing, and Maintaining Systems
Design systems that withstand attacks and outages, from code review to crisis recovery.
by Heather Adkins 2020 541 pages
3.89
199 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat security and reliability as one design problem, not competing departments.

One failure, two lessons. In 2012, a company-wide email announcing a new bus Wi-Fi password overwhelmed Google’s internal password manager. Its main server failed, then its backup did too. Restarting required a hardware security card, but the safe combination was stored in the broken password manager. Colleagues drilled open a safe, retrieved a card, and still could not restart the service because it had been inserted backward.

Trust depends on both. The outage began with a reliability weakness, while security procedures complicated recovery. The book argues that a system is not truly trustworthy if it protects data but cannot keep working, or stays available by abandoning protection. Confidentiality, integrity, and availability can all be damaged by accidents as well as attacks.

Analysis

The password-manager episode makes an architectural point unusually tangible: controls are not independent safeguards if they rely on one another. A secure credential store, a backup, a safe, a card reader, and a trained responder form one system, and the weakest dependency can dominate the result. This resembles safety engineering, where a component’s failure is assessed in the context of the whole chain rather than in isolation. Security and reliability can still conflict, especially when access must be denied during an outage. The practical goal is not to erase that tension, but to design explicit, tested choices for handling it.

Threat-model ordinary mistakes and cheap attacks before exotic adversaries.

Start with motives and paths. Attackers may seek money, information, influence, disruption, or simple notoriety. They can be criminals, governments, researchers, insiders, or people using readily available tools. The book recounts how astronomer and system administrator Clifford Stoll followed an accounting discrepancy into a 10-month investigation of a person stealing government secrets. Careful records helped reveal the attacker’s methods and goals.

Cover the easy routes. Attackers often choose the cheapest approach that works. Phishing can succeed where elaborate technical exploits fail, and an employee’s account can give an intruder legitimate-looking access. Threat models should consider who values the system’s data, what permissions could be abused, and how an attacker might move from initial access to a larger objective. Frameworks such as the Cyber Kill Chain and MITRE ATT&CK help organize those steps.

Analysis

This approach usefully shifts security planning from guessing an attacker’s identity to mapping what they can do. That distinction matters because attribution is uncertain, while exposed credentials, broad permissions, and weak recovery paths can be examined directly. Reliability failures deserve similar imagination: a cat damaging a power supply or a sudden surge of user interest can create adversarial effects without malicious intent. The limitation is that threat categories can become stale if treated as a checklist. A threat model is best used as a revisable set of questions, informed by new incidents and changes in the system, not as a certificate that the system is safe.

Give each person and process only the access its task requires.

Narrow the power. Least privilege means giving a person, machine, or automated process only the access needed for a specific task, ideally only for as long as needed. A broad interactive login exposes far more capability than a small API that can perform one defined action. The book’s configuration example contrasts direct SSH access, which could let automation replace software or stop servers, with a restricted receiver that accepts a configuration update and records what happened.

Put guardrails in the path. Safe proxies can check permissions, log operations, rate-limit changes, and require a second person to approve sensitive actions. Google’s Zero Touch Production approach routes production changes through automation or audited emergency access. The authors estimate that about 13% of evaluated Google outages could have been prevented or reduced through this approach.

Analysis

Least privilege is often presented as a security rule, but here it also functions as reliability engineering. A typo, compromised account, or faulty automation can cause less damage when its authority is bounded. Small interfaces make that boundary legible, which helps both reviewers and operators. Approval by another person can add useful scrutiny, but it is not magic: approvers need enough context to understand the action, and social pressure can turn a second set of eyes into a rubber stamp. The strongest design makes safe action the routine path while keeping emergency access available, limited, and reviewed.

Make critical guarantees visible in small, understandable system boundaries.

Write down what must stay true. A system invariant is a property that must hold even when users, dependencies, or hardware behave unexpectedly. Examples include requiring authorization before data access, recording sensitive operations, and refusing overload rather than crashing. Clear component boundaries make these guarantees easier to reason about. A trusted computing base is the set of components whose correct operation is necessary to enforce a particular security policy; reducing that set limits how much code must be trusted.

Encode safety in interfaces. The book describes typed APIs that distinguish safe HTML or SQL from arbitrary strings, so developers cannot accidentally mix untrusted input into executable content. In one Google framework, applications using safe HTML types had two orders of magnitude fewer reported cross-site scripting flaws than applications without them. Frameworks can centralize recurring requirements such as authorization and logging.

Analysis

Understandability is not just a convenience for maintainers. It determines whether people can make credible claims about system behavior, especially in edge cases that tests have not covered. Types and shared frameworks reduce the number of places where developers must remember a security rule, much as a well-designed physical connector prevents an unsafe assembly. Yet a boundary can create false confidence if its guarantees are misunderstood. A type that marks HTML as safe does not prove that an application’s business logic is correct. Good abstractions narrow the question under review; they do not eliminate the need to ask it.

Build a fast change path, then govern its speed with policy.

Separate ability from permission. A system that can update rapidly is easier to adapt when a vulnerability becomes urgent. Its normal release mechanism should also be capable of emergency deployment, but policy should set the rollout rate for the current risk. Google’s internal Linux update process moved from monthly machine images toward independently managed software packages, allowing ordinary updates to remain gradual while urgent patches moved faster.

Design for reversals carefully. A rollback can restore service after a bad release, but can also reinstall vulnerable software. Wall-clock expiration can create additional recovery problems when clocks disagree or time services fail. Version numbers and explicit revocation can give operators more control. Frequent builds, automated tests, containers, and staged releases make changes easier to evaluate and safer to repeat.

Analysis

The separation of capability from policy is a particularly strong design move. It avoids baking today’s release schedule into infrastructure that may face tomorrow’s emergency, while still allowing rate limits to protect against accidental mass changes. This resembles the distinction between a system’s available actions and its authorization rules. The tradeoff is governance: rapid deployment is valuable only if someone can make a sound urgency judgment and observe the rollout’s effects. A fast pipeline without reliable testing or clear authority simply accelerates mistakes. Conversely, a process that cannot move quickly turns a patch into an organizational bottleneck.

Contain failure deliberately, and preserve essential service under overload.

Choose how the system degrades. Resilience is the ability to withstand disruption or keep operating in a reduced form. Instead of letting overload trigger cascading failures, a service can shed low-priority requests, delay clients through throttling, or disable expensive features. During overload, Google Search has continued with fewer features, while Gmail’s simple HTML mode preserves basic mail access.

Limit the blast radius. Compartmentalizing systems by role, location, or time can prevent one compromised account or failed region from affecting everything. Independent failure domains provide separate copies that can serve if another copy breaks, though they add operational cost. The book’s Google App Engine case illustrates defense in depth: sandboxing, restricted APIs, and system-call monitoring placed several barriers between untrusted code and critical infrastructure.

Analysis

Graceful degradation makes an important distinction between keeping every feature and preserving the system’s essential purpose. Under pressure, that distinction can protect both availability and security. A bank may reasonably refuse logins if authentication is unavailable, while a mail service might serve cached messages without fresh search. The right fallback depends on what harm each mode creates. Redundancy also needs scrutiny: an alternate path can preserve service while opening a new attack route. A useful resilience plan therefore specifies not only what remains available, but which protections must never be relaxed to keep it available.

Use frameworks, types, and tests to make unsafe code harder to write.

Prevent whole bug classes. Shared libraries can enforce authentication, logging, deadlines, and careful retry behavior across many services. Strong types can distinguish trusted SQL from arbitrary input, while memory-safe languages avoid many memory-corruption errors. These choices reduce dependence on every developer remembering every rule during every change.

Test beyond the happy path. Unit tests examine small pieces of code, integration tests check how components work together, static analysis inspects code without running it, and sanitizers detect certain errors during execution. Fuzzing repeatedly feeds software generated inputs to uncover unexpected behavior. The book notes that fuzzing and sanitizers could expose Heartbleed, the OpenSSL flaw that let servers disclose nearby memory. No single method proves software correct, so the methods work best together and run throughout development.

Analysis

The strongest claim here is not that frameworks make software secure, but that they move recurring safety decisions into places where they can be reviewed and improved once. That is a scaling strategy: specialists can harden common components, while application developers focus on product behavior. Testing then searches for gaps that abstractions and reviews miss. The caution is that test coverage is not the same as correctness, and a safe library cannot rescue a flawed system design. Combining prevention with fuzzing, runtime checks, and integration tests creates a more credible defense than treating any one tool as proof.

Verify the artifact's journey, not merely the identity of its deployer.

Track what was built. Code review and automated tests have limited value if someone can deploy a different binary directly to production. Binary provenance records which source, dependencies, tools, and build process produced an artifact. A deployment policy can then reject artifacts that came from an unapproved repository, skipped required tests, or are too old.

Include configuration. Configuration can redirect traffic, expose data, or disable protections, so it deserves version control, review, and testing just like source code. Stronger build systems isolate untrusted build steps from signing keys and specify dependencies before building. Deployment checks must sit at a choke point that every deployment passes through. Emergency bypasses may be necessary, but should be logged, alerted on, and rare enough to review.

Analysis

Artifact verification changes the central security question from who clicked deploy to whether the deployed object satisfies an auditable chain of conditions. That is a more robust basis for trust because authorized people can make mistakes or have compromised accounts. Provenance also helps investigations connect a running binary to its origins. The approach depends on trustworthy builders and complete records, so provenance cannot simply be accepted because it is signed. The signing key, build environment, and enforcement point all become part of the security argument. Good policy makes those assumptions explicit and tests whether the system actually enforces them.

Practice recovery before crisis, then investigate and restore without alerting attackers.

Make recovery a tested capability. Backups matter only if they can be restored, and emergency credentials matter only if responders can use them under pressure. Tabletop exercises, fault injection, disaster drills, and routine key rotation expose broken assumptions before an emergency. Logging should be tamper-resistant, useful for reconstruction, and designed with privacy and retention costs in mind. The book cites a roughly 200-day average time to discover a compromise in a 2018 study, making long-term records potentially important.

Treat security incidents differently. Debugging often favors quick fixes; during a suspected compromise, a rushed cleanup can warn an attacker or erase evidence. Incident teams should establish command, divide investigation and recovery work, use secure communications, document actions, and rebuild affected systems from known-good sources. Afterward, postmortems should assign owners to short-term fixes and lasting changes.

Analysis

Preparation turns crisis response from improvisation into practiced coordination. Incident command is valuable not because hierarchy solves technical problems, but because it reduces ambiguity about who decides, who investigates, and who communicates. The distinction between debugging and forensic investigation is equally important: a fix that removes a visible symptom may destroy evidence or reveal that the attacker has been detected. Still, secrecy is not an absolute good. If ongoing harm is severe, responders may need to act before they understand everything. The sound choice depends on the threat, but it should be deliberate rather than driven by panic.

Make security everyone's job, while specialists build the paths that make it easy.

Shared responsibility needs infrastructure. Developers, operators, leaders, and security specialists all influence system safety. Specialists contribute deep expertise, build common tools, and advise on risk, but cannot own every product’s security alone. Chrome’s security team grew from informal expertise into a dedicated engineering group that fixed bugs, built fuzzing tools, worked with researchers, and improved the browser’s architecture. Its sandboxing work expanded as online data became a more valuable target.

Culture shapes technical outcomes. Review, transparent communication, blameless learning, usable controls, and sustainable workloads make good practices more likely to last. The book recommends staged rollouts, trusted testers, emergency safety nets, and clear feedback channels to reduce fear of change. Leaders can support the work by aligning incentives and funding with security and reliability, rather than rewarding feature delivery alone.

Analysis

The organizational argument is strongest when it connects responsibility to enablement. Telling every engineer to care about security is hollow if the secure option is slow, confusing, or absent. Shared libraries, usable workflows, specialist access, and recognition make the responsibility actionable. The Chrome example also shows why security teams benefit from building and fixing rather than only issuing findings: participation creates practical knowledge and trust. Culture is not a substitute for technical controls, however. A supportive team can still ship a flawed system. Its value is that people are more likely to surface problems, learn from them, and sustain the controls that reduce harm.

Analysis

The book’s central contribution is a shift in unit of analysis. Security and reliability are not features that can be assigned to separate teams or bolted onto a finished product. They emerge from the interactions among software, infrastructure, people, policies, and recovery procedures. The password-manager outage makes that claim concrete: each safeguard behaved plausibly on its own, yet the dependencies between them produced a trap.

The book’s design logic can be read as a sequence of shrinking uncertainties. Threat modeling asks what could go wrong and who might cause it. Least privilege limits what any actor can do. Understandable boundaries make guarantees easier to inspect. Automated testing challenges those guarantees, while provenance checks whether the approved artifact actually reached production. Resilience limits damage when prevention fails. Incident command, logging, and rehearsed recovery reduce confusion after failure. Culture sustains the whole sequence by making safe behavior practical rather than heroic.

A productive tension runs through the argument: controls can prevent harm, but they also create dependencies, friction, and failure modes. A revocation service can lock out an attacker or take down every dependent system. A fallback can preserve availability or reopen a security hole. A second approver can catch an error or merely endorse a senior colleague. The book is most persuasive when it treats these as design choices with explicit failure behavior, not as reasons to abandon controls.

Its Google-scale examples are not universal recipes. Smaller organizations may lack specialized teams, global infrastructure, or custom authorization systems. The transferable lesson is the method: identify the highest-consequence paths, simplify and constrain them, automate repeatable safeguards, and test recovery in proportion to the risk. In this view, trustworthiness is not a promise that systems will never fail. It is evidence that failure is anticipated, contained, observable, and recoverable.

Summary in 30 Seconds
Security and reliability depend on the same system design: controls must protect data without making recovery impossible. Limit each account and process to the access it needs, and route sensitive changes through audited, restricted paths. Use clear component boundaries, safe types, and layered tests to prevent common flaws. Verify software and configuration from source through deployment. Rehearse restoration and incident response: one study found compromises took about 200 days to discover.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.89 out of 5
Average of 199 ratings from Goodreads and Amazon.

Building Secure and Reliable Systems receives mixed reviews, with an average rating of 3.90 out of 5. Readers appreciate its comprehensive coverage of security and reliability principles, particularly for large organizations. Many find it valuable for training and as a reference guide. However, some criticize its structure, verbosity, and occasional lack of clarity. The book is praised for integrating security and reliability concepts but is also noted for being Google-centric. While some chapters are considered too theoretical or detailed, others are highly practical. Overall, it's recommended for security professionals and SREs.

Your rating:
4.38
375 ratings
Want to read the full book?

Glossary

Emergent property

System-wide behavior

A quality produced by the interaction of a system’s components and operating practices, rather than by one isolated feature. Security and reliability are emergent properties because architecture, code, dependencies, deployment, monitoring, and human procedures jointly determine whether a system protects data and remains usable.

System invariant

Always-true system property

A property that must hold across every behavior of a system, including when its environment fails or behaves maliciously. Examples include requiring authorization before access to private data or ensuring overload produces controlled errors instead of a crash. Invariants help engineers state and evaluate the guarantees a design is meant to provide.

Least privilege

Minimum necessary access

A design principle that gives each person, machine, or automated process only the permissions needed for its current task. Access should be narrow in scope and, where practical, temporary. Limiting authority reduces the harm caused by mistakes, compromised credentials, and malicious insiders.

Zero Trust Networking

Access without location-based trust

A networking approach in which being inside a company network does not itself grant privileged access. Systems make decisions using verified user and device identities and other relevant context. A workstation must establish that it is authorized rather than inheriting trust from its physical or network location.

Zero Touch

Production changes through tooling

An approach that removes direct human access to production systems wherever practical. People make changes through automation and constrained interfaces that validate, authorize, rate-limit, and record actions. Emergency access remains possible, but is treated as an auditable exception rather than the everyday method.

Safe proxy

Controlled administrative intermediary

A proxy that sits between a person or automation and a production system, forwarding only permitted operations. It can enforce fine-grained authorization, multi-party approval, rate limits, and audit logging. It adds operational dependencies, so it must be made reliable and paired with a carefully controlled emergency path.

Trusted computing base

Components enforcing a policy

The hardware, software, and other components whose correct operation is necessary to enforce a specific security policy. A failure in any component within this base could violate that policy. Keeping the base small and its interfaces clear makes the security claim easier to reason about and review.

Defense in depth

Layered protective controls

A security strategy that uses multiple complementary safeguards so that one failed control does not automatically expose the system. In Google App Engine, for example, restricted APIs, sandboxing, and system-call monitoring provided successive barriers around untrusted code. Each layer should limit or detect what the previous layer misses.

Failure domain

Isolated operational partition

An independent partition of a system that can fail without necessarily taking down other partitions. Separate regions, roles, or service copies can limit the spread of outages or compromise. Failure domains improve resilience but require ongoing work to keep their configurations, dependencies, and data sufficiently independent.

Binary provenance

Record of build origins

Information describing how a software artifact was produced, including its source code, dependencies, build tools, commands, environment, and output identity. When authenticated and checked against deployment policy, provenance helps establish that a binary came through an approved build process and supports investigation of deployed software.

Incident Management at Google (IMAG)

Structured incident response

Google’s framework for organizing responses to reliability and security incidents, modeled on the Incident Command System. It establishes explicit command, operational, and communications responsibilities so teams can coordinate under pressure. Its structure can scale from a small response to a large, cross-functional incident.

Operational security (OpSec)

Protect response activity

Practices for keeping an investigation or recovery effort from being observed by an attacker. Responders may need separate communications and clean devices, and should avoid actions that expose credentials or signal discovery. OpSec helps preserve evidence and limit attacker reactions, though urgent threats may justify acting openly.

FAQ

What's Building Secure and Reliable Systems about?

  • Focus on Integration: The book emphasizes integrating security and reliability into the entire lifecycle of system design, implementation, and maintenance.
  • Practical Guidance: It offers practical advice and best practices for organizations of all sizes, from startups to large enterprises.
  • Cultural Aspects: The authors discuss the importance of fostering a culture of security and reliability within organizations.

Why should I read Building Secure and Reliable Systems?

  • Comprehensive Resource: It serves as a guide for professionals involved in system design and operations, offering insights from experienced practitioners at Google.
  • Real-World Examples: The book shares case studies and examples, making the concepts relatable and applicable to various organizational contexts.
  • Improving Practices: Readers can learn how to improve their organization's security posture and reliability practices.

What are the key takeaways of Building Secure and Reliable Systems?

  • Integration of Principles: Security and reliability should be integrated into every stage of the system lifecycle.
  • Crisis Management: Effective crisis management strategies, including incident response planning, are outlined.
  • Cultural Importance: A culture that prioritizes security and reliability is essential for resilient systems.

What are the best quotes from Building Secure and Reliable Systems and what do they mean?

  • "Security and reliability are inherent properties of a system.": These aspects should be integrated from the beginning.
  • "A culture of inevitability can help teams have the appropriate frame of mind to build secure and reliable systems.": Accepting that failures can happen leads to better resilience.
  • "Everyone is responsible for security and reliability.": Security and reliability should be a collective effort across the organization.

What is the principle of least privilege in Building Secure and Reliable Systems?

  • Definition: Users should have the minimum access necessary to accomplish their tasks.
  • Reducing Risk: Limiting access minimizes the potential for mistakes or malicious actions.
  • Implementation Strategies: Strategies include using small functional APIs and advanced authorization controls.

How does Building Secure and Reliable Systems define adversaries?

  • Understanding Adversaries: Adversaries are individuals or groups that may exploit system vulnerabilities.
  • Motivations: Motivations include financial gain, activism, and espionage.
  • Frameworks for Analysis: The book provides frameworks for analyzing adversaries, aiding in designing resilient systems.

What role does culture play in security and reliability according to Building Secure and Reliable Systems?

  • Cultural Shift: Building a culture of security and reliability is essential for long-term success.
  • Empowerment and Training: Training employees and empowering them to take ownership of security practices is crucial.
  • Collaboration and Communication: Open communication and collaboration help identify potential issues early.

What is the role of the incident commander (IC) in crisis management as described in Building Secure and Reliable Systems?

  • Leadership During Incidents: The IC leads the incident response team and makes critical decisions.
  • Maintaining Morale: The IC focuses on maintaining team morale during high-pressure situations.
  • Handover Processes: The IC manages handovers between shifts to ensure continuity.

How does Building Secure and Reliable Systems address the trade-offs between security and reliability?

  • Balancing Act: Decisions in one area can impact the other, requiring careful consideration.
  • Design Considerations: Designers should ensure security measures do not compromise reliability.
  • Real-World Examples: Examples show how organizations navigate these trade-offs effectively.

What are some best practices for designing secure systems in Building Secure and Reliable Systems?

  • Design for Understandability: Systems should be understandable to aid in security and reliability.
  • Use of Proxies: Safe proxies manage access and enforce security policies.
  • Continuous Improvement: Regularly review and update security practices based on new insights.

What are the advanced mitigation strategies discussed in Building Secure and Reliable Systems?

  • Defense in Depth: Implement multiple defensive measures to protect systems.
  • Automated Response Mechanisms: Use automated systems for quick incident response.
  • Regular Testing and Updates: Continuously test and update security measures to adapt to threats.

How does Building Secure and Reliable Systems suggest handling legacy code?

  • Consolidate Exemption Mechanisms: Simplify the codebase to reduce vulnerabilities.
  • Refactor Regularly: Improve security and reliability through regular refactoring.
  • Avoid Overengineering: Promote the YAGNI principle to keep the codebase manageable.

About the Author

Heather Adkins is an accomplished professional in the field of cybersecurity and information technology. As an author, she has contributed significantly to the literature on secure and reliable systems, drawing from her extensive experience in the industry. Adkins is known for her work at Google, where she has played a crucial role in developing and implementing security practices. Her expertise extends to areas such as risk management, incident response, and security engineering. Through her writing, Adkins aims to share best practices and insights gained from working in large-scale tech environments, helping other organizations improve their security and reliability postures.

Download PDF

To save this Building Secure and Reliable Systems 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 Building Secure and Reliable 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.35 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 25,
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...