O'Reilly logo
live online training icon Live Online training

Developing Incremental Architecture

Create and optimize an architecture as requirements evolve

Topic: Software Development
Allen Holub

If you still use large up-front design, you'll likely encounter problems during implementation. The solution is to build around a domain-focused metaphor that allows for incremental changes while maintaining coherence throughout. Join expert Allen Holub to learn how to develop an effective, incremental architecture that you can easily modify as new requirements emerge.

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.

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

  • How to develop effective systems and APIs around bounded contexts
  • How to define effective user stories and refine them into implementable small increments
  • How to develop a domain model and a system metaphor from those stories and turn them into an architecture that evolves incrementally in a way that maintains system coherence
  • How to design incrementally as you’re actually implementing

And you’ll be able to:

  • Create an architecture in incremental steps rather than with a single up-front process
  • Optimize that architecture so that it can evolve over time to accommodate changing requirements
  • Create and size high-quality user stories and build an architecture around these stories

This training course is for you because...

  • You're a developer anywhere where requirements change, and you need to create a system that can easily evolve to handle those changes.
  • You're working on a system that has not been fully defined up front, and you need an architecture that can evolve incrementally as you discover new features.
  • You’re working in an Agile shop, and you need to write code that can grow in an Agile way.
  • You need an architecture that works well with microservices.


  • Programming experience in any language

Recommended preparation:

Assignments to complete before the course:

  • Familiarize yourself with Web Whiteboard, which you'll use in place of sticky notes on a whiteboard (The program works best on a desktop computer or equivalent—it uses mouse hover, for example, so it won’t work well with an Apple Pencil on an iPad.)
  • Think of a real-world problem that you’d like to solve (A medium-sized “story” from your work backlog is ideal. Complexity is fine. Study groups will each pick one problem to solve.)

Recommended follow-up:

About your instructor

  • Allen Holub (http://holub.com, @allenholub, allen@holub.com) 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 agilitry.com (Agility with Allen), Pluralsight (Swift in Depth, Picturing Architecture, Object-Oriented Design), and O’Reilly (Design Patterns in the Real World).


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

Day 1

Basic principles (50 minutes)

  • Lecture: Architecture as domain modeling, bounded contexts, Holub replacement and delegation principles, architecture and team/organizational structure, Conway’s law
  • Break (10 minutes)

Process issues (20 minutes)

  • Lecture: Dynamic (incremental) planning; the role of the architect; mob programming for coherence
  • Roles and responsibilities (20 minutes)
  • Lecture: Class and service design

User stories (20 minutes)

  • Lecture: What is a story?; refining (i.e., narrowing) stories
  • Break (10 minutes)

Identifying bounded contexts within a system metaphor (30 minutes)

  • Lecture: Understand what bounded contexts are and how to discover them
  • Hands-on exercise: Divide your real-world problem into bounded contexts and subcontexts/aggregates by writing a short problem statement and developing the contexts using virtual sticky notes

Identifying and narrowing stories (20 minutes)

  • Hands-on exercise: Extract a story or two from your problem statement and narrow them down to a reasonable size

Day 2

Change-focused architecture (50 minutes)

  • Lecture: Modularized monoliths; macroservices; microservices
  • Break (10 minutes)

Converting stories to architecture (60 minutes)

  • Lecture: Design by coding (designing incrementally as you build); TDD principles; activity analysis
  • Hands-on exercise: Start moving your story to code by developing a few lines of API-call code
  • Break (10 minutes)

Choreographed systems: Event storming (50 minutes)

  • Lecture: Understand exactly what a choreographed system is and how to design one; simple event-storming session walkthrough
  • Hands-on exercise: Recast your earlier solution into a one more suitable for choreographed systems, using event storming and virtual sticky notes