Incremental Architecture


3 day hands-on workshop. You can’t simultaneously fight your code and be Agile—it slows you down too much. Your code’s design must evolve incrementally along with your understanding of the product. In this workshop, you’ll learn everything you need to create highly adaptable designs literally as you implement them. We’ll do that with an extensive hands-on exercise where we build a small system of microservices. Along the way, you’ll also experience Event Storming, TDD, mob-programming, and #NoEstimates.

Out of stock

SKU: incr-arch Category:

The Problem

Agility is impossible if you’re fighting the code with every change. You just can’t move fast enough when every change is a struggle. Trying to solve that problem with a “highly-flexible” up-front design yields bloated, unnecessarily expensive systems,  so complex that rapid change is impossible.

You need a minimal architecture, designed grow as the system grows. Incremental systems model the domain, so domain-level changes are easy to implement. Your system isn’t weighted down with code that solves nonexistent problems and vastly increases development time. Incremental architectures focus on the way your users actually work, so are ideal for Agile, user-story-based planning.

Incremental-architecture and microservices go hand in hand. They are modular, domain focused, highly decoupled systems, perfect for microservice implementations.

The Class

Using a hands-on approach, Allen walks you through designing a system that can handle incremental development and then evolving it incrementally. You’ll start with a real-world problem provided by either you or your classmates and will end up with a domain-based architecture that can grow as the system evolves. The techniques you’ll learn are essential when building effective microservice APIs and in any development shop where requirements change as you’re working.

You’ll learn the entire process, starting with user stories and planning strategies, and ending with a implementation. We’ll go from ideas to actual code using event storming (from DDD), and design-by-coding (a TDD-based approach to architecture that Allen developed). You’ll also learn something about mob programming along the way.

What you’ll learn

Over the course of a few days, you’ll learn how to build an system incrementally in such a way that it can stand up to change. In particular, you’ll learn:

  • how to create a system metaphor that guides architectural coherence.
  • how to create effective user stories that bring real value to your customers
  • how do do value-based planning, with no need for formal estimation (not even points)
  • how to narrow (slice) stories and otherwise reduce their size to manageable chunks,
  • how to build an architectural model from the stories and metaphor, and create a coherent system architecture.
  • how to develop effective interfaces and microservice APIs.
  • how to code effectively in a volatile environment, including Event Storming, TDD and mob programming.
  • how to design reactive (event based) as well as declarative (synchronous) systems.
  • how to incrementally create a coherent architecture as you’re coding.
  • how to modify that architecture as new requirements are added without damaging architectural coherence or integrity.

You also learn about the best physical architectures for volatile environments, including microservices, messaging, and agents.

Presentation formats

The best way to do this class is in house over the course of three days. That way, Allen can work easily with the teams during the exercises and we can solve a problem that’s sufficiently complex. If you want to work on a full-blown business problem and take it all the way to implementation, it would be best to allocate a full week. We can also do an abbreviated version either in house or as a webinar. A half-day lecture-only webinar is the another possibility, but the class requires thinking about both the problem and solution in a new way, and this shift in thinking can be difficult to achieve without a guided exercise.


This hands-on course is aimed both at working developers in all roles (developer, tester, front end, back end, etc.) and technical managers. UX people who work closely with the teams will also benefit. In an Agile shop, it’s best to present to the entire team as a single unit.


  • Orientation
  • Basic principles:
  • What is an object?
  • Abstraction
  • Delegation
  • Modeling Basics
  • Domain-focused architecture
  • The System Metaphor
  • Architectural coherence
  • Defining the problem (problem statements)
  • Identifying roles and actors
  • CRC cards
  • CRC-card walls as a static model
  • Exercise: Developing a problem statement and identifying roles and key abstractions
  • Creating Effective User Stories
  • What is a story
  • Epics and their connection to stories
  • Factoring (narrowing)
  • Stories to Activities (Interaction Analysis)
  • Activity Diagrams as a narrowing tool
  • Value-based planning
  • #NoEstimates
  • Story Maps
  • Making work visible
  • The value stream
  • The Kanban board
  • Cumulative flow diagrams
  • Exercise: Discovering epics and stories.
  • Design Thinking, Pros and Cons
  • Lean UX
  • The problems with up-front thinking
  • Designing the UI/UX incrementally
  • Choreographed (Reactive) Systems
  • Bounded contexts
  • Ubiquitous language
  • Entities (Bounded Abstractions)
  • Entities in context
  • Event Storming
  • The process (this is an iterative process, so things don’t necessarily occur in order):
  • Identifying and ordering domain events
  • Identify activities and commands that generate the events
  • timed events, external events and actors
  • Identify entities by grouping responsibilities
  • Identify aggregates
  • Group aggregates into bounded contexts.
  • Hands-on exercise where we’ll use event storming, initially for product discovery, and then to create an effective event-based architecture suitable for microservice implementation.
  • Design by Coding
  • TDD as an iterative design tool
  • Mob programming and collaborative design/development
  • Responsibility-based design
  • Turning stories into code
  • The CRC driven conversation
  • Creating an architecture iteratively
  • Code as a verification/design tool
  • Demo: A simple authentication system.
  • Hands-on exercise where we turn what we learned in this and the tow previous sections into a working model that validates our thinking.
  • Implementation Architectures
  • Structured monoliths
  • Services as objects
  • Macroservices
  • Microservices
  • Interservice communication and messaging

Your Instructor

Allen Holub (, @allenholub, is an internationally recognized software architect and Agile-transformation consultant. He speaks internationally about these topics and agile-friendly implementation technology (like microservices) and architecture. He provides in-house training and consulting in those areas. He excels at building highly functional Lean/Agile organizations and designing and building robust, highly scalable software suitable for agile environments. He’s worn every hat from CTO to grunt programmer, and is an expert-level programmer.

Allen is widely published His works include 10 books, hundreds of articles in publications ranging from Dr. Dobb’s Journal to IBM DeveloperWorks), and video classes for (Agility with Allen), Pluralsight (Swift in Depth, Picturing Architecture, Object-Oriented Design), and O’Reilly (Design Patterns in the Real World, Building Incremental Architecture).


There are no reviews yet.

Only logged in customers who have purchased this product may leave a review.