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
Clean Architecture

Clean Architecture

Build software that stays affordable to change, without paying for complexity you may never need.
by Robert C. Martin 2017 432 pages
4.21
7k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Measure architecture by whether the next ordinary change stays affordable

Design is an economic choice. Martin treats design and architecture as one continuum of decisions, from broad structure to small implementation details. Their purpose is to keep the human effort needed to build and maintain a system low across its lifetime. In one company case, development staff and payroll grew sharply while code output nearly flattened. By release eight, each line of code cost about 40 times as much to produce as in the first release. The accumulating mess had turned feature work into the labor of navigating old code.

Clean work can be faster. In a small six-day exercise converting numbers to Roman numerals, test-driven days took about 10 percent less time than days without that discipline. It is an illustration, not a definitive study, but it challenges the idea that cleanup is a luxury to postpone.

Analysis

The economic lens makes architecture legible to people who do not write code: rising change costs are a business risk, not a developer preference. It also clarifies why a system can function correctly and still be unhealthy. The evidence deserves calibration, though. Lines of code are a crude measure of delivered value, and a six-day exercise cannot establish a universal productivity advantage for any single practice. The more durable test is whether teams can make likely changes with predictable effort and without repeatedly destabilizing unrelated behavior.

Protect changeability as carefully as today's working features

Software carries two values. Its behavior produces or saves value now; its structure determines how readily that behavior can be changed. The second value is easy to neglect because feature requests arrive urgently, while architectural damage accumulates quietly. Martin uses the importance-versus-urgency distinction associated with Eisenhower: urgent work is not automatically important work. Developers must help decision-makers see the future cost of making architecture an afterthought.

Scope is not the whole cost. A small request can be expensive if its shape conflicts with the system's structure. If a new report requires edits across unrelated modules, the architecture is making change harder than the request itself warrants. Preserving changeability does not mean building every imaginable option. It means keeping common, foreseeable changes from becoming system-wide surgery.

Analysis

This distinction resembles the difference between operational performance and organizational resilience: a system may meet today's target while losing the capacity to respond tomorrow. The urgency trap is especially powerful in product organizations, where visible launches receive rewards and avoided maintenance costs do not. Still, flexibility is not free. Every boundary and abstraction consumes attention, so architecture should protect plausible change paths, not hypothetical ones. The practical conversation is less about choosing features or architecture and more about making the cost of deferring structural work visible.

Restrict control flow, indirection, and mutation to make programs easier to test

Programming advances through restraints. Martin presents structured programming as discipline over unrestricted jumps, object-oriented programming as safer control over indirect calls, and functional programming as discipline over changing state. Each makes certain kinds of code harder to write in exchange for code that is easier to reason about. Dijkstra's work on structured programming showed how sequence, choice, and repetition let programs be divided into smaller units that can be examined and tested.

State has concurrency costs. Immutability means values are not casually overwritten; this reduces races and conflicting updates, though it cannot remove every concurrency problem. Event sourcing is one example: store transactions, such as deposits and withdrawals, and derive an account balance from them instead of repeatedly replacing the balance. Snapshots can limit how much history must be recomputed.

Analysis

The unifying idea is not that programmers should use one fashionable paradigm, but that constraints can make reasoning compositional. This connects to safety engineering, where limiting hazardous operations often matters more than asking people to be vigilant. The concurrency claim needs a boundary: immutable data reduces shared mutable state, but systems still face ordering, resource contention, and distributed consistency problems. Event histories also introduce storage, replay, and interpretation burdens. The useful design question is where mutation is necessary, and how narrowly it can be contained.

Point source dependencies toward business policy, not toward technology

Keep policy on the inside. Clean Architecture is Martin's arrangement of software so that business rules remain independent of external mechanisms. Entities represent important business rules that can apply across applications. Use cases coordinate those rules to accomplish a particular application's tasks. Outer adapters translate between those inner policies and details such as web requests or database records.

Dependencies point inward. The Dependency Rule means source code in an inner policy layer must not name or rely on outer implementation details. Runtime activity can still travel outward: an inner use case calls an interface it owns, and an outer presenter or database adapter implements that interface. Thus the business rules can survive a change in database or screen design without inheriting framework-specific types or data formats.

Analysis

The distinction between runtime flow and source-code dependence is subtle but powerful. It separates who initiates an action from who is allowed to define the contract, a distinction familiar from protocol design and institutional governance. The inner layer owns the interface because it has the requirement; the adapter supplies a replaceable mechanism. This arrangement is not a demand for concentric diagrams in every project. It is a test of ownership: if changing a database library forces edits to business rules, the boundary is not doing its job.

Draw boundaries around reasons to change, not arbitrary technical categories

Group by responsibility. The Single Responsibility Principle says a module should serve one actor, meaning one group that requests a particular kind of change. Martin's payroll example places pay calculation, hours reporting, and database storage in one Employee class. A shared hours routine then lets a payroll change accidentally corrupt HR reports. Separating code by the people and purposes that change it reduces such collisions.

Design for safe variation. The Open-Closed Principle favors extending behavior without repeatedly modifying protected code. The Liskov Substitution Principle requires interchangeable implementations to honor the promises their users rely on. The Interface Segregation Principle avoids forcing clients to depend on operations they do not use. The Dependency Inversion Principle puts stable abstractions between core policy and volatile details. Together, these ideas help contain change rather than merely decorate classes.

Analysis

These principles are strongest when treated as questions about change ownership, not as a checklist of class shapes. The payroll example exposes a social problem as much as a technical one: one team can alter code another team trusts without realizing it. Interfaces can make that ownership explicit. Yet splitting every actor into a separate module can create needless coordination and indirection. Good boundaries track recurring differences in change, while code review and domain knowledge remain necessary to identify when two responsibilities truly diverge.

Break component cycles before they turn releases into team-wide emergencies

Components shape collaboration. A component is a deployable unit, such as a Java archive or a shared library. Three cohesion principles help decide what belongs together: group code that is released together, group code that changes for the same reasons, and avoid bundling classes that users do not need together. These aims conflict, so the right component size can shift as a project moves from internal development toward reuse.

Keep dependencies acyclic. Acyclic Dependencies Principle means component dependencies form a directed graph with no loops. A cycle can make several teams depend on the same synchronized release, undermining isolated tests and incremental integration. Stability adds another guide: components with many dependents are costly to change, so volatile components should not become prerequisites for stable policy. Abstract interfaces can let dependencies point toward stable components instead.

Analysis

A dependency graph is also a map of coordination costs. Cycles create the software equivalent of tightly coupled departments that cannot change their procedures without negotiating with one another. An acyclic graph does not guarantee good architecture, but it makes build order, test scope, and release impact easier to reason about. Stability metrics can flag surprising dependency patterns, yet they cannot decide whether a component is valuable or appropriately sized. Such measurements are diagnostic instruments, not objective quality scores.

Start as a monolith; distribute only when real constraints justify the cost

Deployment is not architecture. A monolith can contain carefully separated components, while a collection of services can still be tightly coupled. Function calls inside one process are cheap and can be frequent. Calls across processes or networks add latency, data conversion, and operational failure modes, so boundaries at those levels should solve a real development, deployment, or operating need.

Services do not guarantee independence. In Martin's taxi-booking example, adding a kitten-delivery feature affects candidate selection, driver dispatch, supplier rules, and customer allergy checks. Dividing those behaviors into services did not prevent the feature from crossing all their boundaries. A component design with extension points could isolate the new offering. The recommended path is to preserve separations in code first, then move selected boundaries into deployable units or services when evidence supports it.

Analysis

This is a useful corrective to equating network distribution with modularity. Distributed systems exchange local simplicity for latency, partial failure, deployment coordination, and observability demands. The kitten example shows that shared data and cross-cutting policy can bind services as tightly as functions bind classes. Conversely, a monolith can become a bottleneck when teams or operational requirements truly demand independent deployment. The architectural question is not which topology is modern, but which boundary reduces total coordination and failure costs in the actual environment.

Keep databases, web interfaces, and frameworks outside the business rules

Delay replaceable choices. Martin treats databases, web delivery, and frameworks as details because the business policies should not need to know their specific implementations. In FitNesse, a simple interface for page storage let the team build features first with an in-memory implementation, then use flat files. A customer later added a MySQL implementation in about a day. The team ultimately did not need that option.

Use tools without surrendering the core. Frameworks can accelerate work, but their authors design for their own problems, and a tight commitment may make later replacement costly. Keep framework-specific code in an outer adapter or setup component. The data model itself can be central to the business; the database software and its query language need not be. External customer or organizational requirements may still make a specific technology necessary.

Analysis

The FitNesse story demonstrates the value of reversible decisions: a small seam preserved the option to choose later without requiring the team to predict the perfect storage system. This resembles real-options reasoning in economics, where modest early costs can preserve valuable choices under uncertainty. But deferral is not automatically wise. A technology decision may affect performance, staffing, compliance, or procurement, and those constraints can be substantive rather than fashionable. The aim is not to pretend constraints do not exist, but to prevent them from contaminating policy unnecessarily.

Build tests and hardware seams into the architecture, not around it

Test at the policy boundary. The Humble Object pattern moves hard-to-test behavior into a minimal component and keeps logic in a testable one. A presenter can format dates and amounts into a view model, leaving the screen view to display them. A dedicated testing API can let tests reach business rules without navigating a volatile GUI or matching every production class one for one. That reduces brittle tests and resistance to harmless refactoring.

Separate software from hardware. Embedded systems need a hardware abstraction layer, an interface that presents useful services while hiding device-specific implementation. An operating-system abstraction can serve the same role for operating-system dependencies. Without such seams, a hardware change can force widespread edits, and code may only be testable on the target device.

Analysis

Testability here is a structural property, not a test team's afterthought. A stable API gives tests access to behavior while insulating them from incidental screen layout and class organization. In embedded work, the same logic creates a path to testing before hardware is ready or after a device becomes obsolete. Powerful test interfaces require care: bypassing security or substituting expensive resources can create risks if test-only capabilities leak into production. Isolation must include deployment and access control, not just clean source code.

Make the architecture reveal the product, then enforce its boundaries in code

Let the domain show. A repository should make its purpose visible, whether it supports video sales, healthcare, or accounting, rather than announcing only its web framework. In the video-sales case, distinct actors include individual buyers, business buyers, authors, and administrators. Grouping their use cases helps keep one actor's requests from spreading indiscriminately through the system.

Implementation can undo design. Simon Brown's chapter compares organizing code by technical layer, feature, domain boundary, or component. In Java, making every class public weakens package-level encapsulation, so the compiler cannot prevent callers from bypassing intended interfaces. A component-oriented package can expose one entry point while hiding its internal implementation. Boundaries should be strengthened when friction makes their benefit exceed their maintenance cost, not imposed everywhere in advance.

Analysis

Architecture communicates both to machines and to people. A domain-centered structure can shorten onboarding because newcomers can infer what the system does before learning its framework choices. Compiler-enforced access restrictions make that structure more than a diagram or a promise in a code review. Still, organization by feature or component is not universally superior; language visibility rules, team size, and deployment needs shape the best arrangement. The core criterion is whether the chosen structure makes intended dependencies easy and accidental dependencies difficult.

Analysis

The book's most important move is to redefine architecture from a picture of boxes into a strategy for managing the cost of change. That makes its recommendations cohere: dependency inversion protects policy, component graphs organize collaboration, testable boundaries limit regression risk, and delayed technology choices preserve options. The argument is strongest when it connects software structure to human effort. A tangled dependency graph is not merely aesthetically poor; it creates slow integration, wider testing burdens, and more people needed to make ordinary changes.

Its framework is deliberately portable across languages and eras. The recurring primitives are sequence, selection, iteration, data, and indirection, while hardware and tooling change. That historical perspective usefully resists the belief that a new framework or deployment style removes old design problems. Yet the claim that architectural rules are essentially changeless should be read as a claim about durable principles, not identical implementation. Modern distributed platforms, cloud operations, and regulatory constraints alter the cost profile of boundaries, even when policy should remain insulated from detail.

The book also offers a valuable tension rather than a recipe. Reuse, local change, and avoiding unnecessary dependencies pull component design in different directions. Similarly, anticipating a boundary can prevent costly surgery, but speculative abstraction can burden a small product. The architectural task is therefore empirical: observe where changes collide, where tests become fragile, and where deployment or operation imposes real constraints, then invest in the boundary whose expected savings justify its upkeep.

Some evidence is illustrative rather than conclusive. The productivity case uses lines of code, and the test-driven experiment is small. Neither establishes a universal numerical return on clean design. Their role is to make a plausible mechanism visible: messy structure consumes effort that might otherwise produce useful behavior. The enduring lesson is not to maximize abstraction. It is to make the system's important policies understandable, testable, and relatively insensitive to the details most likely to change.

Summary in 30 Seconds
Architecture determines how much effort ordinary changes require over a system's lifetime. Keep business rules independent of databases, interfaces, and frameworks, and direct code dependencies toward those rules. Separate modules by responsibility, prevent circular dependencies, and add boundaries where changes collide or tests become fragile. Begin with a well-separated monolith; move to distributed services only when operational or development constraints justify their costs. One company’s code output barely grew as staff expanded, and later releases cost about 40 times more per line.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.21 out of 5
Average of 7k+ ratings from Goodreads and Amazon.

Clean Architecture: A Craftsman's Guide to Software Structure and Design receives mixed reviews. Many praise its focus on SOLID principles and decoupling, while others find it repetitive and lacking practical examples. Some readers appreciate the historical context and anecdotes, while others feel they detract from the core content. The book is generally seen as helpful for understanding high-level architectural concepts, but opinions vary on its usefulness for beginners versus experienced developers. Several reviewers note that the book's content could have been conveyed more concisely.

Your rating:
4.6
633 ratings
Want to read the full book?

Glossary

Clean Architecture

Policy insulated from details

An architectural approach that places important business policies inside, and technical mechanisms such as databases, web frameworks, and devices outside. Source dependencies point toward the inner policies. The system can still use external tools, but core rules should not depend on their names, formats, or implementation choices.

Dependency Rule

Dependencies point toward policy

The rule that source-code dependencies in a layered architecture must point inward, from details toward higher-level policy. Inner code must not refer to names or data formats declared by outer layers. Interfaces owned by inner code allow runtime calls to reach outward implementations without reversing the source dependency.

Entity

Core business rules and data

A software object or module that brings together critical business data and the rules that operate on it. An Entity represents a business concept that remains meaningful beyond one particular application's interface or database. It should not depend on those technical mechanisms.

Use case

Application-specific business procedure

A description and implementation of how an automated system is used to achieve a goal. A use case defines relevant input, output, and processing, and coordinates the Entities that contain more general business rules. It should not depend on whether users interact through a web page, console, or another interface.

SOLID principles

Guides for change-friendly design

Five related design principles concerning responsibility, extension, substitutability, interface size, and dependency direction. They guide how functions and data are grouped and how modules depend on one another. Their shared aim is to make software easier to change, understand, and reuse without coupling unrelated responsibilities.

Component cohesion principles

Rules for grouping deployable code

The Reuse/Release Equivalence, Common Closure, and Common Reuse principles guide which classes belong in a component. They balance coordinated release, grouping code that changes together, and avoiding dependencies on unused classes. Because these goals can conflict, component structure should reflect a project's current development and reuse needs.

Event sourcing

Store events, derive current state

A data strategy that stores the sequence of transactions or events rather than repeatedly overwriting the current state. The state is reconstructed by applying those events, sometimes from a saved snapshot to reduce replay work. It can reduce mutable updates, but requires storage and processing for the recorded history.

Humble Object pattern

Separate hard-to-test behavior

A design pattern that divides behavior between a minimal component that handles difficult-to-test mechanics and a separate component containing testable logic. For example, a view can display prepared values while a presenter formats them. The separation often creates a useful architectural boundary.

Testing API

Stable access for automated tests

An interface intended for tests to exercise business behavior without relying on the user interface or mirroring every production class. It may provide controlled ways to set system state, bypass expensive resources, or access operations unavailable to ordinary users. Sensitive testing capabilities should be kept out of production access paths.

Hardware abstraction layer (HAL)

Hardware hidden behind services

A software interface that presents services needed by an application while hiding the details of particular hardware. Instead of exposing device registers or pin assignments, it can offer operations expressed in product terms. Implementations can then change with the hardware while higher-level software remains insulated.

Main Sequence

Balance stability and abstraction

A line on a component-design graph relating stability to abstractness. Components near one end are stable and abstract; those near the other are unstable and concrete. Components far from the line may be rigid despite being concrete, or abstract without useful dependents. The measure is a diagnostic prompt, not a proof of quality.

FAQ

What's Clean Architecture about?

  • Focus on Software Structure: Clean Architecture by Robert C. Martin emphasizes creating systems that are easy to develop, maintain, and deploy through effective software architecture.
  • Timeless Principles: It outlines principles like SOLID, applicable across various programming paradigms, to guide developers in writing clean, maintainable code.
  • Separation of Concerns: The book advocates for separating business rules from technical details, enhancing flexibility and adaptability in software design.

Why should I read Clean Architecture?

  • Improve Software Design Skills: The book enhances understanding of software architecture, providing practical advice for real-world projects.
  • Timeless Knowledge: Its principles are not tied to specific technologies, ensuring relevance throughout your career.
  • Real-World Examples: Martin shares insights from his extensive experience, offering relatable examples and case studies to simplify complex concepts.

What are the key takeaways of Clean Architecture?

  • Architecture is a Shape: Software architecture is defined by component division and communication, facilitating development and maintenance.
  • Decouple Business Rules: Emphasizes separating business rules from technical details for easier changes and adaptations.
  • Leave Options Open: Good architecture defers technical decisions, allowing flexibility to adapt to changing requirements.

What are the SOLID principles mentioned in Clean Architecture?

  • Single Responsibility Principle (SRP): A class should have one reason to change, reducing complexity and easing maintenance.
  • Open-Closed Principle (OCP): Software entities should be open for extension but closed for modification, minimizing bug risks.
  • Liskov Substitution Principle (LSP): Subtypes must be substitutable for their base types without altering program correctness.

What is the Dependency Inversion Principle (DIP) in Clean Architecture?

  • High-Level Modules: DIP states high-level modules should not depend on low-level modules; both should depend on abstractions.
  • Abstractions Over Details: Depending on abstractions rather than concrete implementations makes systems easier to modify and extend.
  • Use of Interfaces: Encourages using interfaces to define contracts between components, enhancing testing and maintenance.

How does Clean Architecture define good software architecture?

  • Support for Use Cases: Good architecture must support intended use cases, making them clear and visible within the structure.
  • Minimize Human Resources: It should minimize resources required for development, deployment, and maintenance through careful design.
  • Leave Options Open: A well-designed architecture keeps options open for future changes, crucial for long-term success.

What is the significance of boundaries in Clean Architecture?

  • Separation of Concerns: Boundaries separate system components, ensuring changes in one area don't adversely affect others.
  • Control Over Dependencies: Managing dependencies across boundaries prevents disruptions, leading to a stable system.
  • Facilitate Independent Development: Boundaries allow teams to work independently, enhancing productivity and reducing conflicts.

What is the "Screaming Architecture" concept in Clean Architecture?

  • Architecture Reflects Intent: "Screaming Architecture" means the system's architecture should clearly communicate its purpose and functionality.
  • Use Case Driven: Good architecture is driven by use cases, maintaining clarity and purpose throughout development.
  • Avoid Framework Dependency: Architecture should be centered around business needs, not dictated by frameworks or tools.

How does Clean Architecture address testing?

  • Testable Architectures: Emphasizes architectures that allow unit testing of business rules without external systems running.
  • Humble Object Pattern: Separates hard-to-test code from testable code, focusing on logic without UI or framework complexities.
  • Testing API: Suggests creating a testing API to bypass security constraints, enhancing the ability to test various scenarios.

How does Clean Architecture differentiate between the web and the architecture of a system?

  • Web as a Delivery Mechanism: The web is viewed as a delivery mechanism, not a defining aspect of system architecture.
  • Decoupling Delivery from Logic: Treating the web as a detail allows designing systems agnostic to delivery methods.
  • Focus on Business Logic: Prioritizes business logic and use cases over web delivery specifics, ensuring core functionality remains intact.

What are the risks of using frameworks according to Clean Architecture?

  • Tight Coupling: Frameworks can lead to tight coupling, making technology switches difficult.
  • Overhead and Complexity: Heavy reliance on frameworks can introduce unnecessary complexity and hinder performance.
  • Loss of Control: Over-reliance on frameworks can lead to a rigid system, making changes and adaptations challenging.

What are the best quotes from Clean Architecture and what do they mean?

  • "Your architecture should tell readers about the system, not about the frameworks you used in your system.": Emphasizes architecture reflecting business domain and use cases, not technologies.
  • "Frameworks are tools, not ways of life.": Reminds developers to maintain control over architecture, not be overly reliant on frameworks.
  • "A good architecture makes it unnecessary to decide on Rails, or Spring, or Hibernate, or Tomcat, or MySQL, until much later in the project.": Highlights deferring technology decisions until architecture is established, promoting flexibility.

About the Author

Robert Cecil Martin, known as Uncle Bob, is a prominent software engineer and advocate for Agile development methods. As President of Object Mentor Inc., he leads a team of consultants specializing in Object-Oriented Design, Patterns, UML, and Agile Methodologies. Martin has extensive experience in the software industry, having served as Editor in Chief of the C++ Report from 1996 to 1999. He is a sought-after speaker at international conferences and trade shows, sharing his expertise on software development best practices. Martin's influence extends beyond consulting, as he has authored several influential books on software craftsmanship and clean coding practices.

Download PDF

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

Download EPUB

To read this Clean Architecture 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.45 MB     Pages: 26
Want to read the full book?
Follow
Listen11 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...