DDD Europe 2024 - Program

Architecture: The Hard Parts

Pre-conference Workshops


Neal Ford and Mark Richards

Neal FordMark Richards
May 27-28

Software architects have no clean, easy decisions: everything is a terrible tradeoff. Architecture has lots of difficult problems, which this platform-agnostic class highlights by investigating what makes architecture so hard. This class goes beyond the fundamentals of software architecture and focuses on hard problems within distributed architectures such as microservices and event-driven systems.

This class is divided into 2 main parts—pulling things apart, then putting them back together again. In part 1 (pulling things apart), you’ll learn about the differences between modularity and granularity, techniques, and patterns for breaking apart monolithic systems and migrating them to a distributed architecture, how to choose the right size for a service, and how to break apart monolithic data. However, once you break a system apart, necessarily you need to put it back together again. That’s what part 2 is about - putting things back together.

In part 2 you’ll learn about communication protocols for communicating between services, how to reconnect distributed data, whether your workflow should use orchestration or choreography, what sort of contract you should have between services, what patterns to use for complex event processing, and how to manage distributed transactions while still maintaining some level of data consistency and integrity.

Software architecture is full of hard parts. By attending this 2-day class you can gain the insights and techniques to make it just a little softer.

Target Audience

The target audience is existing architects, aspiring architects interesting in learning about fundamental tradeoffs, and developers working within complex architectures. No laptop is required, but access to a browser on some device is necessary as the exercises are online.

Outline & Agenda

Part 1: Pulling Things Apart

Unit 1: Architectural Modularity

Why migrate from monolithic systems? Business and technical drivers Migration patterns and approaches Hands-on exercises: Migration drivers

Unit 2: Architectural Quantum

Defining a quantum Why this is important Application partitioning Quantum examples Hands-on exercises: Identifying architectural quanta

Unit 3: Technical vs. Domain Partitioning

Technically partitioned architectures Conway’s Law Dynamically partitioned architectures Inverse Conway maneuver Advantages and disadvantages of each Architecture and organizational alignment Migrating from technical to domain partitioning Hands-on exercises: Identifying partitioning

Unit 4: Component-Based Decomposition

Microservices migration patterns Identifying and sizing components Flattening components Identifying component dependencies Creating component domains Creating domain services Domain service decomposition Hands-on exercises: Flattening components

Unit 5: Service Granularity

Granularity disintegration drivers Granularity integration drivers Analyzing tradeoffs Hands-on exercises: Determining service granularity

Unit 6: Breaking Apart Monolithic Data

Drivers for data decomposition Creating Data domains Resolving data dependencies Hands-on exercises: Decomposing monolithic databases

Part 2: Putting Them Back Together

Unit 7: Data Access and Ownership

Creating bounded contexts Managing common data ownership Managing joint data ownership Data Access patterns Hands-on exercises: Accessing remote data

Unit 8: Managing Contracts

Strict vs. loose contracts Bandwidth and stamp coupling Consumer-driven contracts

Unit 9: Communication Protocols

Synchronous communication Asynchronous communication Dynamic quantum entanglement

Unit 10: Managing Workflows

Defining orchestration Defining Choreography Analyzing tradeoffs Hybrid topologies Hands-on exercises: Choosing a workflow type

Unit 11: Distributed Transactions

ACID transactions BASE Transactions Eventual consistency patterns Managing transaction through state machines Compensating updates

Unit 12: Transactional Sagas

Three dimensional sagas Epic Saga Fantasy Fiction Saga Fairy Tale Saga Parallel Saga Phone Tag Saga Horror Story Saga Time Travel Saga Anthology Saga Transactional Saga Tradeoffs Hands-on exercises: Choosing the right transactional saga


This workshop helps me to back up my architectural decisions with measurements and proofs rather than just by gut feeling. – Anonymous post-workshop feedback

The workshop reinforces my learning in distributed systems and helps me to consider important aspects when designing the architecture in my business. – Anonymous post-workshop feedback

Excellent concepts were introduced that I can use to evaluate and discuss architectural choices with colleagues. The workshop provided a vocabulary that makes these discussions easier. – Anonymous post-workshop feedback


No laptop required. Experience with architecture-level decisions

About Neal Ford

Neal is Director, Software Architect, and Meme Wrangler at ThoughtWorks, a software company and a community of passionate, purpose-led individuals, who thinks disruptively to deliver technology to address the toughest challenges, all while seeking to revolutionize the IT industry and create positive social change. He is an internationally recognized expert on software development and delivery, especially in the intersection of agile engineering techniques and software architecture. Neal has authored magazine articles, seven books (and counting), dozens of video presentations, and spoken at hundreds of developers conferences worldwide. His topics include software architecture, continuous delivery, functional programming, cutting edge software innovations, and includes a business-focused book and video on improving technical presentations. Check out his web site at nealford.com.

About Mark Richards

Mark Richards is an experienced, hands-on software architect involved in the architecture, design, and implementation of microservices architectures, service-oriented architectures, and distributed systems. He has been in the software industry since 1983 and has significant experience and expertise in application, integration, and enterprise architecture. Mark is the founder of DeveloperToArchitect.com, a website devoted to helping developers in the journey to software architect. He is the author of numerous technical books and videos, including several books on Microservices (O'Reilly), the Software Architecture Fundamentals book and video series (O’Reilly), Enterprise Messaging video series (O’Reilly), Java Message Service, 2nd Edition (O’Reilly), and a contributing author to 97 Things Every Software Architect Should Know (O’Reilly).