Summary
This workshop demonstrates how to apply Domain-Driven Design patterns step by step to refactor a legacy codebase. You’ll learn practical techniques to gradually transform a monolithic system into a well-structured modular monolith—and, if needed, evolve it further into a microservices architecture. Throughout the workshop, we’ll also use an AI-assisted, spec-driven development approach to support the implementation process. Specifications will help make architectural and domain decisions explicit, while AI will be used as an accelerator for tasks such as refactoring, implementation, and testing—without replacing the reasoning behind those decisions.
For who?
The workshop is designed for participants already familiar with DDD concepts. It focuses on hands-on strategies for tackling complexity, aligning software architecture with the domain, and evolving an existing codebase incrementally.
What you'll learn
- Learn how to apply DDD patterns and principles in the context of a real-world project.
- Understand how to use Strategic Patterns to analyse and structure the solution space.
- Gain hands-on experience applying Tactical Patterns directly in code.
- Learn how explicit specifications can guide implementation and make AI-assisted development more reliable during architectural changes.
- Explore how to introduce CQRS and Event Sourcing as the architecture evolves.
- Learn how to test business processes and introduce the Saga pattern to handle distributed process complexity.
How we'll work
The workshop is highly practical. Across the four half-day sessions, we’ll progressively evolve the same codebase, moving from domain analysis to architectural and implementation changes. AI-assisted development will be part of the workflow rather than the subject of the workshop: we’ll define specifications, use them to guide coding agents and AI tools, inspect the generated changes, and refine both the specifications and the implementation as the design evolves. The goal is not to delegate design decisions to AI, but to show how a clear understanding of the domain and explicit specifications can make AI a useful engineering tool rather than a source of accidental complexity.
Prerequisites
Attendees should be familiar with the basic concepts of Domain-Driven Design.
AI-Augmented Domain-Driven Design
Written by Alessandro Colla and Alberto Acerbis - Published by Packt
AI‑Augmented Domain‑Driven Design: Design Better Domains Using LLMs, Structured Prompts, and Multi-agent Workflows
What this Book will help you do:
- Understand how LLMs reason, where they help, and where they fail
- Apply prompt engineering to Domain-Driven Design workflows
- Use AI-assisted reasoning to refine domain events and bounded contexts
- Build rulebooks that guide and constrain LLM reasoning
- Apply AI to EventStorming and domain modeling activities
- Design AI agents for domain discovery and DDD workflows
- Orchestrate multi-agent systems for domain modeling
- Strengthen software architecture decisions while preserving domain clarity
Domain-Driven Refactoring
Written by Alessandro Colla and Alberto Acerbis - Published by Packt
Transform your approach to software systems with "Domain-Driven Refactoring." Learn how to dissect monoliths into microservices and modular systems effectively using Domain-Driven Design (DDD) principles. By following practical examples and strategic guidance, this book equips you with the tools to build maintainable, scalable systems tailored to business requirements.
What this Book will help you do
- Understand how to identify and manage the boundaries of your system components to align with your business needs.
- Apply strategic Domain-Driven Design patterns, such as bounded contexts and ubiquitous language, for enhanced system clarity and flexibility.
- Learn tactical DDD patterns to design effective and maintainable aggregates, entities, and value objects.
- Refactor legacy codebases by implementing proven patterns and techniques to modernize your architecture.
- Explore event-driven and modular designs for building decoupled, scalable, and resilient systems.