O'Reilly logo
live online training icon Live Online training

Architecture without an end state

Designing software systems that can evolve over time to support change

Michael Nygard

Join expert Michael Nygard to learn how to design and architect systems that admit change—bending and flexing through time. Using a blend of information architecture, technical architecture, and process change, Michael walks you through transforming rigid systems into more maneuverable architecture. Over two days, you’ll learn how to build systems from simpler pieces with simpler interfaces that can be combined and recombined to deliver new features. By the end of this training course, you’ll be able to design software architecture that adapts to stresses from business and technology change.

What you'll learn-and how you can apply it

By the end of this live online course, you’ll understand:

  • How to design systems that can evolve over time in the face of technological and business change
  • When the “single system of record” pattern applies and when it does not
  • How to combine microservices with legacy systems
  • Why aiming for the “end state” never works and what to do about it

And you’ll be able to:

  • Separate concerns for better decision hiding
  • Isolate information to allow independent change
  • Build systems in simpler pieces

This training course is for you because...

  • You're a software architect with a design background who wants to integrate new and old technology styles.
  • You're a developer who wants to take charge of software architecture.


  • Familiarity with common architecture patterns and the fallacies of distributed computing

Recommended preparation:

Pattern-Oriented Software Architecture Vol 1 (book)

"Documenting Architecture Decisions" (article)

"Architecture Qualities" (article)

Assignments to be completed prior to the course:

Choose an example system to use for exercises during the class, and write 2–3 sentences describing the business purpose of the system and its basic architecture. This can be a system you worked on in the past, a current effort, or a planned effort. It can even be an imaginary system, as long as you make it “real” enough to make decisions about how to build it.

About your instructor

  • Michael Nygard develops software, designs architecture, and teaches software architects around the world. He strives to help people and companies realize their potential. Simple, flexible, robust systems let humans do creative work instead of tending to production outages. Michael is the author of “Release It! Design and Deploy Production Ready Software,” a best-selling book about building systems that survive contact with the real world.


The timeframes are only estimates and may vary according to how the class is progressing

Day 1

Introduction (20 minutes)

  • Lecture: Course overview and goals; architecture and trade-offs; the payoff curve
  • Q&A

Complex systems (25 minutes)

  • Lecture: Defining complex systems; implications; local context
  • Hands-on exercise: Choose a sample system to use for the course
  • Q&A

Break (10 minutes)

Complex systems continued (35 minutes)

  • Lecture: Context diagrams; arrows across the boundary; sensitivity analysis
  • Hands-on exercises: Draw a context diagram; identify users and APIs; identify system sensitivities
  • Q&A

Iterative architecture (20 minutes)

  • Lecture: When to use an iterative architecture

Break (10 minutes)

Iterative architecture continued (70 minutes)

  • Lecture: MFs and AEs; sequencing and timeline; deferring decisions versus YAGNI; architecture qualities; quality attribute scenarios
  • Hands-on exercise: Identify MFs and AEs; make a timeline
  • Q&A

Break (10 minutes)

Responsibility allocation (60 minutes)

  • Lecture: Upstream versus downstream; data flow diagrams; locality; augmenting; federating; contextualizing via policies; identifiers; required fields
  • Hands-on exercises: Draw a local data flow diagram; update with augmentation, federation, and contextualization
  • Q&A

Day 2

  • Information architecture (50 minutes)
  • Lecture: Identifiers and ownership; data and reality; ETL and observations; semantic coupling
  • Q&A

Break (10 minutes)

Information architecture continued (30 minutes)

  • Lecture: Concept maps; splitting nouns;
  • Hands-on exercises: Draw a concept map for your sample system; in an object-oriented system, find interfaces with exactly one implementer; count the number of exposed methods
  • Q&A

API design (20 minutes)

  • Lecture: API stability; open world versus closed world
  • Hands-on exercise: Explore sample diagrams to determine how much the service is allowed to change
  • Q&A

Break (10 minutes)

API design continued (30 minutes)

  • Lecture: Substitutions without permission; breaking changes
  • Hands-on exercise: Explore whether API changes are breaking or non-breaking; determine how breaking ones could be made nonbreaking
  • Q&A

Application architecture (25 minutes)

  • Lecture: Separation of concerns
  • Q&A

Break (10 minutes)

Application architecture continued (60 minutes)

  • Lecture: Layers; the challenges of layers; good layers; ports and adapters; honeycomb; faults, errors, and failures
  • Hands-on exercises: Create and share tech/UI transitions; list ports relevant to your chosen system

Break (10 minutes)

Ecosystem (15 minutes)

  • Lecture: Value stream; discoverability
  • Q&A

Wrap-up and Q&A (20 minutes)