Skip to content

Evolutionary Architecture: Systems That Are Allowed to Change

Architecture is not an end state that you lock down once. Small changes and suitable fitness functions make selected risks visible earlier, but they guarantee neither speed nor quality.

≈ 10 min readSoftwareArchitecture

Evolutionary Architecture is not a license for uncontrolled growth, nor is it another word for “agile.” In Building Evolutionary Architectures (O'Reilly 2017, second edition 2022), Neal Ford, Rebecca Parsons and Patrick Kua define it as an architecture that supports “guided, incremental change across multiple dimensions.” Three words carry this definition. Guided: there are named characteristics that are protected. Incremental: each individual change is small enough to be rolled back. Multiple dimensions: this means not just the code but equally data, operations and the organization that carries both.

The counter-model is the frozen system. Cleanly designed three years ago, for a world that no longer exists in that form – and not moved since, because every change seemed too risky. The diagrams still hang on the wall, but they describe a car nobody drives anymore. Behind this lies a stubborn basic assumption: that architecture is something you get right once and then defend, a target picture you reach. But no system in production use stands still. Requirements shift, load profiles change, teams grow, dependencies age. The question is never whether a system changes, only whether the architecture accompanies this change or stands in its way.

Evolutionary Architecture therefore turns the perspective around: instead of treating change as an exception to avoid as much as possible after go-live, it makes change the norm that you build for from the start. A system that is allowed to change – in small steps, and without breaking the characteristics that make it valuable.

Why end-state thinking gets expensive#

The classic reflex is called Big Design Up Front. You think as far ahead as possible, decide everything important early and cast the result into a target picture. That feels responsible. And thinking early is not fundamentally wrong – quite the opposite. What is wrong is the expectation that these early decisions will hold for good.

The flaw lies in the timing. At the very beginning of an undertaking, you know the least about the domain, the users and the real behavior under load. That is exactly when you make the most far-reaching decisions. Every later insight then has to assert itself against a structure that was not made for it. This is the moment when teams start working around the architecture instead of with it. The technical term for this is architectural drift or erosion: the real system moves away, piece by piece, from the intended one, until the diagram on the wall is mere folklore.

The business damage is rarely a spectacular outage. It creeps in. Changes take longer. Every adjustment needs more coordination. New features collide with old assumptions. Time to market rises while confidence falls. And at some point the question comes up whether it would be better to rebuild everything – the most expensive of all options.

The shift in perspective: guided evolution instead of a fixed target#

The way out is not a different target picture but a different way of dealing with target pictures. Instead of defining and defending an end state, you define the characteristics the system should keep and let the structure evolve within these guardrails.

flowchart LR
  A[Change<br/>small increment] --> B[Deployment pipeline]
  B --> C{Fitness functions<br/>guardrails}
  C -->|pass| D[Learn & Adjust]
  C -->|fail| E[Stop & Fix]
  E --> A
  D --> A

The core is a feedback loop, not a waterfall. A small change runs through the deployment pipeline, is checked against defined guardrails, delivers clear feedback – passed or not – and the team learns from it for the next step. Small, guided, repeatable. That is the difference between a system that evolves and one that just gets older.

The emphasis on guided is important. Evolutionary explicitly does not mean “no architecture” or “we let it grow however it wants.” That is the most common fallacy. Uncontrolled growth is not evolution but its opposite. Without consciously named, prioritized architecture characteristics, there is nothing to protect and nothing to measure. The first step is therefore not a technique but a decision: What exactly must distinguish this system? Response time under a certain limit? Loose coupling between business areas? Demonstrable security at the edges? Only when these goals are explicit can you defend them.

Fitness functions: architecture you can measure#

The mechanism used to defend these goals is called a fitness function. The term is borrowed from evolutionary algorithms, where a fitness function evaluates how close a solution is to the desired result. Applied to architecture, according to the authors, it means: “any mechanism that provides an objective integrity assessment of some architectural characteristic(s).” In other words, any mechanism that objectively checks whether an architectural characteristic is still intact.

The decisive word here is objective. A fitness function is not a meeting, not a gut feeling and not an architecture review board that meets once a quarter and passes judgment on slides. It is an automated test that runs in the pipeline and delivers an unambiguous result. This shifts governance from manual control toward something versioned, executable and repeatable at any time – not for nothing does the second edition carry the subtitle “Automating Software Governance.”

The simplest and best-known example is structural rules. With a library like ArchUnit, you can express an architecture rule as a perfectly ordinary unit test:

@ArchTest
static final ArchRule domain_must_not_depend_on_infrastructure =
    noClasses().that().resideInAPackage("..domain..")
      .should().dependOnClassesThat().resideInAPackage("..infrastructure..");

This rule says: the domain layer must not access the infrastructure. Until now, something like that lived in a wiki and was hopefully noticed in code reviews. Now the build breaks as soon as someone violates the boundary – on the same day it happens, not three months later in a refactoring retrospective. The intent turns from a comment into an executable fact.

And this is exactly where the second big fallacy lies: fitness functions are not limited to such package and layering checks. That is just the most visible category. Anything you can check objectively about an architecture is a candidate – performance budgets, security scans, checks for cyclic dependencies, even chaos experiments or monitoring-based checks in live operation.

The authors organize this into a small taxonomy that helps you spot gaps in everyday work. Fitness functions can be atomic (checking a single characteristic) or holistic (checking how several work together). They can be triggered (running on an event, for example in the build) or continual (running permanently in production). And they can be static (fixed threshold) or dynamic (threshold depending on context). If you only have structural, atomic, triggered rules, you cover one corner and miss the rest.

A performance budget, for example, is rather holistic and can be expressed as a gate in the pipeline:

fitness_functions:
  - name: p95_latency_budget
    metric: http_request_duration_p95_ms
    threshold: 300
    on_breach: fail_build
  - name: max_module_coupling
    metric: afferent_efferent_coupling_ratio
    threshold: 0.7
    on_breach: warn

The pattern is always the same: an architectural characteristic, an objective threshold, a defined consequence. If the 95th percentile latency breaks the budget, the build fails. If coupling rises above the limit, there is a warning at first. You do not have to enforce everything strictly – but you make the characteristic visible and decide consciously how strictly you treat it.

Coupling is the real brake#

When a system can no longer be changed in small steps, coupling is almost always the reason. Not only the obvious kind between classes, but also hidden temporal coupling and data coupling. Two services that always have to be deployed together. A schema that three teams have to touch at the same time to change one field. As long as these ties exist, incremental change is impossible, no matter how good the intent.

That is why controlling coupling itself is one of the most important fitness functions. And that is why a few proven patterns make the difference here. Martin Fowler’s Strangler Fig Application describes how to replace a legacy system incrementally by letting new functionality grow around the old core like a strangler fig until the core can eventually disappear – without the one big, risky switchover. At the data level, the expand-contract pattern (also called parallel change) does the same: you expand a schema, migrate step by step and remove the old part only when nobody needs it anymore. This makes refactoring a normal, safe movement instead of a feat of strength.

At the operations level, resilience patterns such as Circuit Breaker and Bulkhead from Michael Nygard’s Release It! make sure that the loosely coupled parts do not drag each other down during failures. And at the service edges, Consumer-Driven Contract Testing keeps the boundaries honest: every consumer describes what it expects from a service, and this contract is checked automatically. If the service changes incompatibly, the test fails before the user notices. That too is a fitness function – one that safeguards changeability at the most expensive breaking points.

A word on Conway’s Law, because coupling is not only technical. Systems mirror the communication structures of the organizations that build them. If you want loosely coupled software, you also have to cut the teams accordingly. That is not a side note but often the precondition for the technical guardrails to take effect at all.

The proof that it pays off#

At this point comes the objection: sounds good, but all this automation and constant change – doesn’t it come at the expense of stability? Faster means riskier, doesn’t it?

The data says the opposite. The DORA research, summarized in Accelerate (Forsgren, Humble, Kim, 2018), shows across thousands of organizations that speed and stability are not opponents but rise together. The highest-performing teams deploy more often and have fewer outages and recover faster. The supposed trade-off between pace and reliability is an artifact of the old thinking – the result of rare, large, risky releases.

The four classic DORA metrics read like system-wide fitness functions themselves:

Deployment Frequency     - wie oft deployen wir?
Lead Time for Changes    - wie lange von Commit bis Produktion?
Change Failure Rate      - wie viele Deployments verursachen einen Fehler?
Time to Restore Service  - wie schnell sind wir wieder online?

They do not measure a single module but the changeability of the whole system. Shorter cycles, less friction and higher quality thus become quantities you can hook into the same feedback loop logic as a latency limit.

flowchart TB
  subgraph Old[Architecture as end-state]
    O1[Big Design Up Front] --> O2[freeze] --> O3[drift & erosion]
  end
  subgraph New[Architecture as guarded evolution]
    N1[named characteristics] --> N2[fitness functions] --> N3[small guarded change] --> N1
  end

Incidentally, this frame of thinking is not limited to technology. It is the same principle that The Lean Startup formulated for products – Build, Measure, Learn: a hypothesis, a small step, a measurement, an adjustment. Architecture evolution is the technical expression of the same attitude. You do not claim to know the right structure. You build in a way that lets you find it out cheaply.

Conclusion#

Architecture is not an end state. It is a system’s ability to keep changing without losing the characteristics that make it valuable. If you take this seriously, you stop defending a target picture and start protecting the right things.

The way there is surprisingly concrete. First: name the architecture characteristics that really count – not all of them, but the few that make the difference. Second: for each of these characteristics, build a fitness function that checks objectively, automatically and in the pipeline whether it still holds – structurally, but also for performance, security and coupling. Third: actively keep coupling low, technically and organizationally, so that small steps remain possible at all. And fourth: trust the whole thing, because the data shows that pace and stability grow together.

The approach does not create short cycles by itself, and it does not guarantee stable quality. It makes named characteristics verifiable earlier when you make small changes. Whether that reduces friction or speeds up changes only shows in the real delivery flow. For me, the best architecture is therefore not the one that is supposed to be right forever, but one whose assumptions can be checked and changed when new insights arrive.

Further reading#

Revised and translated from German with the help of AI.