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 Evolutionary Architectures

Building Evolutionary Architectures

Support Constant Change
Keep software adaptable as requirements shift, without betting on the next architecture trend.
by Neal Ford 2017 190 pages
3.74
1k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Design architecture to keep changing, not to predict every change.

Treat time as part of design. The book defines an evolutionary architecture as one that supports guided, incremental change across several dimensions. Those dimensions include the code, data, security, and operations, as well as qualities such as performance and reliability. A design that protects only its code structure can still become difficult to change when its database or deployment process is rigid.

Prediction has a short shelf life. The software ecosystem shifts through changing tools, platforms, and practices. The rise of containers, for instance, followed earlier changes that made Linux widely usable and infrastructure easier to provision automatically. No single plan could guarantee that outcome. The practical response is to make change less costly and to specify which qualities must survive it.

Analysis

What's useful here is the shift from treating a blueprint as a forecast to treating it as a set of options. A system that can absorb change preserves choices for the people who maintain it. But flexibility is not free: keeping every imaginable option open can create unnecessary complexity. The work is to name the dimensions that matter in this system, rather than declare evolvability an abstract virtue. A stable internal structure can be a good choice when the surrounding environment and requirements are genuinely stable.

Turn architectural promises into checks that can expose deterioration.

Make quality verifiable. A fitness function is an objective assessment of whether an architectural characteristic remains intact. If a service must respond within 100 milliseconds, a performance check can test that boundary. A structural check can reject code that creates forbidden package dependencies. Some checks run automatically, while legal or operational requirements may still need a person to verify them.

Choose the right scope. An atomic check examines one property in one context. A holistic check examines how properties interact. For example, caching may improve speed but make data too stale for a security requirement. Teams should identify critical, relevant, and nonessential concerns early, then review them as the system changes. The collection of checks gives decision-makers a shared basis for discussing tradeoffs, not a magic score for architecture.

Analysis

The framework turns vague quality goals into evidence that can inform daily decisions. Its strongest feature is that it allows architectural rules to live in the same working process as code, rather than depend on memory or occasional review. There is a real danger, however, in confusing a measurable proxy with the quality itself. A passing latency test does not prove a system feels fast to users, and a security scan cannot settle every security question. Checks need owners, context, and periodic reconsideration.

Use small releases and parallel versions to change behavior without forcing a big switch.

Build a safe path to production. Continuous Delivery practices automate building, testing, and preparing software for release. A deployment pipeline separates these checks into stages, from ordinary code tests to broader integration and operational tests. Feature toggles can hide unfinished behavior, while routing can direct selected users or services to a new version without immediately retiring the old one.

Compare before replacing. GitHub used a framework called Scientist to run new merge behavior alongside the established behavior. The old implementation remained the one users relied on, while a small random share of requests tried the candidate. Differences and failures were recorded. After four days, including a full day without mismatches or slow cases, the team removed the old implementation. This approach made a risky internal change observable before it became the only path.

Analysis

Parallel execution converts a replacement decision into a learning process. The old system acts as a reference point, while real traffic reveals cases that a test suite may miss. The method works best when teams can compare outputs reliably and contain the consequences of a mismatch. It is not a reason to send every experiment to every user or to keep duplicate paths indefinitely. Each temporary route needs a decision rule and a plan for removing the path that no longer earns its keep.

Set component boundaries around real change, including transactions and data.

Find the actual unit of change. An architectural quantum is an independently deployable unit with enough functional cohesion to work as a whole. In a monolith, the quantum may be the entire application. In a service architecture, it may be one domain service together with its data and dependencies. Smaller units can make changes more selective, but only when the parts are genuinely separable.

Business and organizational boundaries count. A layered design may isolate presentation, business logic, and storage, yet a change to one business capability can still cross every layer and team. Conway's Law describes how an organization's communication structure tends to shape its systems. Transactional rules can bind components even more tightly: splitting code while preserving a shared transaction may not create independent services. A disciplined modular monolith can be more changeable than poorly partitioned microservices.

Analysis

This view usefully replaces the simplistic goal of making components smaller with the more demanding goal of making them independently useful. A boundary is successful when it reduces coordination without hiding necessary coordination. That makes domain language, ownership, deployment, and data consistency part of architecture, not administrative details. The caution is that service boundaries can be mistaken for autonomy. If teams must negotiate every change across a web of shared contracts, the architecture may have distributed its code without reducing its coupling.

Version database changes alongside code, and transition schemas gradually.

Treat the schema as changeable software. Database structures represent an understanding of the world, so they need revision as requirements change. The book recommends testing and versioning schema changes with the code that depends on them, then applying small migrations through the deployment process. Once a migration has been used, teams should add a new migration to correct it rather than silently rewriting history.

Keep old and new interfaces compatible during change. The expand/contract pattern adds a new structure while temporarily retaining the old one. When a customer name moves from one field into separate first-name and last-name fields, existing systems may still require the original field. A temporary synchronization mechanism can support both forms while applications migrate. Once consumers have moved, the obsolete field can be removed. This transition can last days or months, depending on coordination needs.

Analysis

Database evolution is a useful test of whether incremental change is real or only a code-level slogan. A schema shared by several applications makes even a simple alteration a coordination problem, so compatibility windows buy teams time. Yet temporary bridges have costs: triggers, duplicate fields, and migration logic can become permanent by neglect. The transition should have an owner and an exit condition. Data also deserves a quality review, since preserving every historical structure can preserve confusion rather than business value.

Make uncertain decisions reversible, while removing accidental sources of change.

Reduce needless variation. Immutable infrastructure means defining machines and environments in code, then rebuilding them consistently instead of making undocumented manual changes. This reduces the chance that two supposedly identical servers behave differently. The book recounts a trading-system failure in which an outdated server and a reused feature toggle contributed to a disastrous mix of buying and selling behavior, costing the firm more than $400 million.

Keep options open deliberately. Blue-green deployment keeps a previous production environment available while a new one takes over. Feature toggles and routing can limit a new behavior to a small group and provide a way back if it misbehaves. Anticorruption layers isolate a system from a third-party tool's details, making replacement less invasive. These techniques do not predict the right answer. They lower the cost of discovering that an answer was wrong.

Analysis

Reversibility is a practical response to uncertainty, but it should be applied selectively. Keeping a rollback path can limit damage, while retaining old toggles and duplicate systems can create the very variability that reliable releases require teams to remove. The key distinction is between a deliberate option with an owner and an accidental leftover. Immutability helps make environments repeatable; it does not make the software inside them correct. The checks around a change remain essential.

Stop reuse, vendors, and standards from becoming permanent bottlenecks.

Reuse can bind teams together. A shared component may look efficient, but every consumer then depends on its design and release schedule. At PenultimateWidgets, a reusable administration component became a bottleneck because one central team controlled improvements and the implementation could not keep pace. Allowing teams to fork or replace it restored their ability to act independently.

Abstraction can also disappoint. The Last 10% Trap describes tools that make most of a solution easy but make the final, distinctive requirements painfully difficult. Vendor-centered systems can impose similar limits when the business bends its processes around a product that cannot support important needs. The answer is not to reject every shared tool. It is to treat tools as replaceable integration points, assess their ongoing value, and standardize only where consistency helps more than it constrains.

Analysis

The central tension is between scale through commonality and freedom through local control. Shared infrastructure can make routine work safer and cheaper, but a shared product with a slow decision process can turn reuse into a queue. The sensible question is not whether duplication is always better, but whether the cost of coordinating change exceeds the cost of maintaining separate versions. That balance changes with the technology, the teams, and the business. Periodic review matters because yesterday's useful standard can become today's constraint.

Let user behavior test product assumptions before teams build more features.

Replace confident guesses with experiments. Hypothesis-driven development states what a feature is expected to change, then uses an experiment to test that expectation. Facebook used different wording in questions about flagged photos to learn why people considered them offensive, reducing false positives when the volume of reports surged. The goal was not to assume what users meant, but to ask in a way that produced useful evidence.

Measure actual use. PenultimateWidgets had a long-lived desktop application to move to the web, but its analysts did not know which features mattered most. The team added usage logging and found that invoicing and customer lookup were common, while an expensive feature saw little use. That evidence helped set both the migration scope and sequence. Experiments can also compare interface versions or service behavior, provided the outcome is measurable and the test is safe.

Analysis

This approach makes software architecture an enabler of product learning, not just a means of shipping code. Logging and controlled experiments can reveal a gap between what stakeholders request and what users actually do. Evidence still requires interpretation: frequent use does not automatically mean high strategic value, and a short experiment may miss seasonal or rare needs. Good experiments therefore specify the decision they will inform, the relevant population, and what result would change the plan.

Put teams where business changes happen, not in technical silos.

Make ownership match the work. Conway's Law predicts that communication patterns influence system design. When interface, database, and operations specialists sit in separate groups, a change to one customer-facing capability can wait on several handoffs. The Inverse Conway Maneuver deliberately organizes cross-functional teams around the boundaries the architecture aims to create, such as a business service or product.

Reduce coordination overhead. The book uses a team-connection calculation to show how communication links grow quickly: 20 people create 190 possible connections, while 50 create 1,225. Small teams can reduce that burden, especially when they own a product through development and operation rather than handing it off at project completion. Where staffing prevents a fully cross-functional team, scarce specialists can be shared, but automation should reduce avoidable waits and make responsibilities clear.

Analysis

Team structure is an architectural constraint because every boundary creates communication work. Giving a team end-to-end ownership can improve feedback and make operational consequences visible to the people changing the software. It can also create silos if products share important capabilities or data. Cross-functional teams therefore need clear integration agreements and ways to coordinate shared concerns. The point is not to eliminate communication, but to spend it on genuine dependencies rather than on organizational handoffs created by job titles.

Begin migration at a natural seam, not with a fashionable rewrite.

Start with evidence and a manageable boundary. For an existing system, inspect its module structure, data relationships, transaction boundaries, and ability to release changes. Add tests around important behavior before restructuring, and use fitness functions to protect new integration points. A monolith may become more modular without becoming a collection of services. If a service migration makes sense, the book recommends starting with a small number of larger services, then refining boundaries as the team learns.

Choose the starting point deliberately. A low-risk area can demonstrate the method; a high-value area can test whether it solves an important problem. Neither is universally right. Some tightly coupled systems may cost more to reshape than to replace, while a short-lived product may justify a sacrificial design. The architecture should fit the business problem, not the current fashion.

Analysis

The migration advice resists two familiar extremes: preserving a failing system forever and treating a rewrite as a clean escape. Small steps make hidden dependencies visible, but they need a destination expressed in business and technical terms. A staged migration without a reason to stop can accumulate parallel systems and extra integration layers. Conversely, a rewrite can discard hard-won behavior that documentation never captured. A useful first step produces information as well as code, so the next decision can rest on observed constraints rather than architectural enthusiasm.

Analysis

The book's strongest contribution is not a new architecture style. It is a way to make architecture accountable over time. It brings testing, deployment automation, monitoring, data migration, and team design into a single conversation about whether a system can change without losing the properties that matter. This is a practical answer to the limits of long-range technical prediction: teams cannot know which tools or requirements will dominate, but they can decide how to detect damage and how to make change safer.

The argument also complicates the usual claim that decoupling is always good. A component boundary has value only if it matches a real unit of work and can be deployed independently. Shared transactions, data schemas, service contracts, team handoffs, and operational procedures all create coupling, even when a diagram shows separate boxes. A modular monolith may therefore be more evolutionary than a poorly coordinated service network. The book's repeated focus on appropriate boundaries is a useful corrective to architecture by fashion.

Fitness functions are the practical hinge. They turn architectural intentions into feedback, but they cannot eliminate judgment. Measures simplify reality, and a test can pass while the system fails a broader need. Teams must choose meaningful thresholds, look for interactions between qualities, and revisit checks when the business changes. The collection of checks supports deliberation, rather than replacing it with a single score.

The book is most persuasive when it connects technical change to organizational design. A deployment pipeline cannot remove weeks of approval friction by itself, and domain-centered teams cannot overcome a database that every service must share. Architecture is therefore both a technical structure and a pattern of ownership. Its best outcome is not constant change for its own sake, but a system and organization able to change deliberately, learn from production, and retire yesterday's assumptions before they become permanent constraints.

Summary in 30 Seconds
Software architecture should make important qualities measurable and change safer, rather than depend on accurate predictions. Automated checks can protect boundaries and performance targets, such as a 100 millisecond response time. Small releases, parallel implementations, and gradual database migrations expose problems before a full switch. Component boundaries should reflect real business and transaction boundaries. Cross-functional teams reduce handoffs, while user experiments reveal which features matter before migration work expands.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.74 out of 5
Average of 1k+ ratings from Goodreads and Amazon.

Building Evolutionary Architectures receives mixed reviews, with an average rating of 3.76 out of 5. Positive reviews praise its overview of modern software architecture and emphasis on designing for change. Critics argue it lacks depth and relies too heavily on metaphors. Many readers appreciate the concept of fitness functions but find the explanation unclear. The book is seen as a good starting point for understanding evolutionary architecture, though some feel it doesn't offer much new information for experienced professionals. Several reviewers note issues with editing and proofreading in the first edition.

Your rating:
4.33
170 ratings
Want to read the full book?

Glossary

Evolutionary architecture

Guided change over time

An architecture designed to support guided, incremental change across the dimensions that matter to a system. It does not assume requirements or technologies will remain fixed. Teams identify important qualities, such as security or performance, and use feedback mechanisms to help preserve them as the system and its environment change.

Architectural fitness function

Architecture integrity check

An objective assessment of whether an architectural characteristic remains within acceptable bounds. It may be automated, such as a test that checks performance or package dependencies, or manual, such as a required legal review. Fitness functions can examine one property or interactions among several properties, and may run on a trigger or continually.

Architectural quantum

Independent deployable unit

The smallest independently deployable part of a system that contains the structural elements needed for its function and has strong functional cohesion. Its size determines how small a change can be released independently. A whole monolith may form one quantum, while a service architecture may have a quantum for each bounded domain service and its dependencies.

Inverse Conway Maneuver

Align teams with architecture

An organizational practice that shapes team boundaries to encourage the intended architecture. Rather than allowing existing communication structures to dictate system design, an organization arranges teams around business capabilities or service boundaries. Cross-functional ownership can reduce handoffs when a change requires work across technical specialties.

expand/contract pattern

Compatible schema transition

A technique for changing a schema or interface while existing consumers continue to work. First, the system adds the new structure while retaining the old one. Consumers migrate over time, sometimes using temporary synchronization between old and new representations. Once the old form is no longer needed, it is removed.

consumer-driven contracts

Consumer-defined integration tests

A way to protect an integration by having consumer teams specify tests for the data or behavior they require from a provider. The provider runs those tests and keeps them passing while changing its implementation. This makes consumer needs explicit and provides an automated check against breaking an integration unintentionally.

anticorruption layer

Boundary around external dependencies

A layer that translates between an application and an external system, library, or framework. It keeps the application's internal concepts from depending directly on the external tool's particular interface. If that dependency changes or needs replacement, the layer can limit the number of affected parts.

cycle time

Work-to-production duration

The elapsed time from when a developer begins a unit of work until that work is running in production. In the book's account, shorter cycle time allows a team to deliver changes more frequently and therefore gives the architecture more opportunities to evolve. It can also be monitored as a process measure.

hypothesis-driven development

Test product assumptions

A development approach that frames a proposed feature as a claim about an outcome, then uses an experiment to assess it. Instead of treating a stakeholder's proposed solution as certain, teams specify what they expect to change, gather evidence through user behavior or controlled variants, and use the result to guide product decisions.

Conway's Law

Communication shapes system design

The observation that the communication structures of an organization influence the systems it designs. Teams divided into separate technical specialties may produce architectures that mirror those divisions, making changes that cross specialties harder to coordinate. The book applies this idea to team design and the alignment of ownership with business capabilities.

FAQ

1. What is "Building Evolutionary Architectures" by Neal Ford about?

  • Core Focus: The book explores how to design software architectures that can adapt to constant change, emphasizing the need for systems that evolve incrementally and gracefully over time.
  • Key Concepts: It introduces the idea of evolutionary architecture, which supports guided, incremental change across multiple dimensions, such as technical, data, security, and operational concerns.
  • Practical Guidance: The authors provide actionable advice on implementing fitness functions, managing coupling, and leveraging modern engineering practices like Continuous Delivery and DevOps.
  • Real-World Examples: Throughout, the book uses case studies (e.g., PenultimateWidgets) and industry anecdotes to illustrate both successes and pitfalls in building evolvable systems.

2. Why should I read "Building Evolutionary Architectures" by Neal Ford?

  • Adapting to Change: The book addresses the reality that software requirements and ecosystems are always changing, making it essential for architects and developers to build systems that can evolve.
  • Modern Practices: It bridges the gap between traditional architecture and agile/DevOps practices, showing how to operationalize architecture in a world of rapid delivery and feedback.
  • Comprehensive Framework: Readers gain a holistic framework for thinking about architecture, including technical, organizational, and business dimensions.
  • Avoiding Common Pitfalls: The book highlights common antipatterns and pitfalls, helping readers avoid costly mistakes in their own projects.

3. What are the key takeaways from "Building Evolutionary Architectures" by Neal Ford?

  • Three Pillars: Evolutionary architecture is built on incremental change, fitness functions, and appropriate coupling.
  • Fitness Functions: Defining and automating fitness functions is crucial for protecting architectural characteristics as systems evolve.
  • Team and Organizational Impact: Team structure (e.g., cross-functional, domain-centric teams) and organizational culture significantly influence architectural outcomes.
  • Continuous Improvement: Embracing experimentation, automation, and regular review of architectural decisions leads to more resilient and adaptable systems.

4. How does "Building Evolutionary Architectures" by Neal Ford define evolutionary architecture?

  • Guided, Incremental Change: An evolutionary architecture supports guided, incremental change across multiple dimensions, allowing systems to adapt without losing core qualities.
  • Meta-Characteristic: Evolvability is treated as a meta-characteristic that wraps and protects other architectural qualities (like scalability, security, etc.).
  • Fitness Functions: The architecture is guided by fitness functions, which objectively assess and enforce desired characteristics.
  • Multi-Dimensional: Evolutionary architecture considers not just technical aspects, but also data, security, operational, and organizational dimensions.

5. What are fitness functions in the context of "Building Evolutionary Architectures" by Neal Ford, and why are they important?

  • Definition: Fitness functions are objective integrity assessments of architectural characteristics, inspired by evolutionary computing.
  • Purpose: They protect important qualities (e.g., performance, security, scalability) from degrading as the system changes.
  • Types and Categories: Fitness functions can be atomic or holistic, triggered or continual, static or dynamic, automated or manual, and domain-specific.
  • Operationalization: Embedding fitness functions into deployment pipelines ensures ongoing, automated verification of architectural integrity.

6. How does "Building Evolutionary Architectures" by Neal Ford recommend handling incremental change?

  • Small, Safe Steps: Systems should be designed to accommodate small, incremental changes in both development and deployment.
  • Continuous Delivery: Practices like deployment pipelines, automated testing, and feature toggles enable safe, frequent releases.
  • Parallel Versions: The book advocates for running old and new versions side-by-side during transitions, allowing gradual migration.
  • Feedback Loops: Incremental change is supported by feedback mechanisms that quickly surface issues and guide further evolution.

7. What is the role of coupling in "Building Evolutionary Architectures" by Neal Ford, and how should it be managed?

  • Appropriate Coupling: The book stresses the importance of minimizing inappropriate coupling while allowing necessary, intentional connections.
  • Architectural Quanta: It introduces the concept of architectural quanta—independently deployable, functionally cohesive units—as a way to manage coupling.
  • Patterns and Styles: Different architectural styles (monoliths, microservices, event-driven, etc.) are evaluated for their inherent coupling and evolvability.
  • Tools and Tests: Tools like JDepend and fitness functions are recommended to detect and prevent harmful coupling, such as component cycles.

8. How does "Building Evolutionary Architectures" by Neal Ford address data and database evolution?

  • Evolutionary Database Design: The book advocates for treating database schemas like code—versioned, tested, and changed incrementally.
  • Expand/Contract Pattern: It describes the expand/contract (parallel change) pattern for safely evolving schemas without breaking integrations.
  • Data Coupling: Inappropriate data coupling (e.g., shared databases) is highlighted as a major barrier to evolvability.
  • Transactional Boundaries: The authors caution against tight transactional coupling, recommending service boundaries that align with natural data and business boundaries.

9. What organizational and team structures does "Building Evolutionary Architectures" by Neal Ford recommend for supporting evolutionary architecture?

  • Domain-Centric Teams: Teams should be organized around business domains rather than technical functions, reducing coordination friction.
  • Cross-Functional Membership: Each team should include all necessary roles (development, QA, operations, data, etc.) to own their service end-to-end.
  • Inverse Conway Maneuver: Structure teams to mirror the desired architecture, making it easier to achieve and maintain.
  • Product over Project: Emphasize long-lived product teams with ownership and accountability, rather than short-term project teams.

10. What are the most common pitfalls and antipatterns highlighted in "Building Evolutionary Architectures" by Neal Ford?

  • Vendor King: Over-reliance on a single vendor or platform, leading to inflexibility and loss of control.
  • Last 10% Trap: Tools or frameworks that make the first 80-90% easy but the last 10% nearly impossible, resulting in hacks and disappointment.
  • Code Reuse Abuse: Excessive focus on reuse leading to harmful coupling and reduced usability.
  • Inappropriate Governance: Outdated governance models (e.g., forced standardization) that hinder agility and evolution.
  • Leaky Abstractions: Over-trusting abstractions without understanding their limitations, leading to hidden complexity and fragility.

11. How does "Building Evolutionary Architectures" by Neal Ford suggest operationalizing evolutionary architecture in practice?

  • Identify Dimensions: Start by identifying all architectural dimensions that need to be protected (technical, data, security, etc.).
  • Define Fitness Functions: For each dimension, define fitness functions to objectively assess and enforce desired qualities.
  • Automate with Pipelines: Use deployment pipelines to automate the execution of fitness functions and manage incremental change.
  • Continuous Review: Regularly review and update fitness functions and architectural decisions to adapt to new requirements and discoveries.

12. What are the best quotes from "Building Evolutionary Architectures" by Neal Ford, and what do they mean?

  • "An evolutionary architecture supports guided, incremental change across multiple dimensions." — This encapsulates the book’s core definition, emphasizing both direction and adaptability.
  • "If you can’t build a monolith, what makes you think microservices are the answer?" (Simon Brown) — Warns against adopting complex architectures without mastering the basics of modularity and coupling.
  • "The more reusable code is, the less usable it is." — Highlights the tradeoff between reusability and simplicity, cautioning against overengineering for reuse.
  • "Make as many decisions as possible reversible (without over-engineering)." — Encourages designing for change and recovery, rather than betting on perfect foresight.
  • "Demonstration defeats discussion." — Advocates for proving architectural approaches through working examples and metrics, rather than endless debate.

About the Author

Neal Ford is a Software Architect and Meme Wrangler at ThoughtWorks, a global IT consultancy. He is an accomplished author, having written or edited five books on various technologies. Ford is also a prolific speaker, having delivered over 600 talks at more than 100 developer conferences worldwide. His expertise lies in designing and building large-scale enterprise applications. Ford's work spans multiple areas, including application development, instructional materials, magazine articles, and courseware. He maintains a website at nealford.com and welcomes feedback via email. Ford's extensive experience and diverse skill set make him a respected figure in the software development community.

Download PDF

To save this Building Evolutionary Architectures summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.42 MB     Pages: 22

Download EPUB

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

Why one summary?

Scanner
Find a barcode to scan

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