Microservice Architecture with DDD and Event Storming
This advanced workshop is dedicated to designing robust microservice-based systems using Domain-Driven Design (DDD) and Event Storming. Over four intensive days, you'll explore practical strategies for defining bounded contexts, designing service boundaries, and handling communication and integration challenges across distributed systems.
You will not only learn how to design architecture that aligns with domain needs, but also how to implement it using proven patterns such as CQRS, Event Sourcing and Strangler Pattern. You'll gain experience using Architecture Decision Records (ADR) to capture your trade-offs and rationale, and discover how to evolve monoliths into modular, production-ready microservice architectures.
Learning Objectives
Apply Event Storming for domain modeling and requirement discovery.
Use strategic DDD patterns: Bounded Context, Context Mapping, Ubiquitous Language.
Design modular, scalable microservice architectures with Architecture Decision Records.
Model and implement inter-service communication using synchronous, asynchronous, and event-driven strategies.
Implement CQRS and Outbox patterns for distributed consistency.
Support transformations from monolith to microservices using Strangler Pattern and Anti-Corruption Layer.
Key Benefits
Realistic, hands-on experience using Event Storming and DDD in microservices.
Learn how to define Bounded Contexts and architect systems aligned with business needs.
Gain techniques to anticipate architectural risks and make decisions that support scalability.
Apply advanced communication patterns (e.g. Choreography, Orchestration).
Learn how to handle distributed transactions, API strategies, and progressive rollout techniques.
Understand modern testing and deployment strategies in a microservices environment.
Who Should Attend?
Software architects and experienced backend engineers.
Project teams transitioning from monoliths to microservices.
Developers and specialists seeking to apply DDD, Event Storming, and advanced integration patterns in real projects.
Prerequisites
Familiarity with architectural patterns.
Solid experience in domain analysis, design, and object-oriented programming.
Practicalities
Level: Advanced.
Platform: Java, Spring Boot.
Presenter:
I help teams delivering value faster, understanding business needs and building scalable Architecture and Shift-left Testing Strategy. With a passion and trust.
I have the experience, knowledge, passion and open mindset - perfect skills to deliver value to the customers and the businesses with:
✔ Speed - required to catch the market opportunity
✔ Quality - to retain and scale
Proven by:
✔ Building and maintaining systems at the core for the entire business stability
✔ Significantly reducing the cost of manual tests by implementing Shift-left testing strategy
✔ Iteratively designing and building Architecture open for business expansion yet not over-engineered
Agenda – What You’ll Learn and Build
For architects and engineers designing resilient, domain-aligned microservices
1. Foundations and Setup
• Architecture of code vs. infrastructure
• Benefits and trade-offs of microservices
• Introduction to Event Storming
• Overview of Domain-Driven Design
Understand the mindset and motivations behind domain-aligned distributed architecture.
2. Strategic Domain-Driven Design Patterns
• Ubiquitous Language
• Domains
• Foundations of Bounded Contexts and Context Mapping
Gain strategic tools to define clear service boundaries and reduce ambiguity.
3. Domain Exploration with Event Storming
• Introduce a sample domain
• Apply notation and mapping
• Use Chaotic Exploration and Chronology
Learn to map complex domains into a structured ecosystem of services.
4. Defining Bounded Contexts & Architecture
• Identifying language boundaries
• Handling modeling challenges
• Choosing the right architecture style
• Capturing decisions using Architecture Decision Records (ADR)
Learn to define and defend architectural decisions with traceable rationale.
5. Inter-Service Communication
• Strategic communication with Context Mapping
• Integrating with legacy code
• Synchronous vs. Asynchronous messaging
You’ll design communication strategies that balance autonomy, speed, and consistency.
6. Managing Distributed Transactions
• Distributed consistency and eventual consistency
• Orchestration vs. choreography
• Applying Event Sourcing for traceability
Build services that remain consistent without relying on central databases or tight coupling.
7. API Design in Microservices
• Resilient API Design and versioning strategies
• Using an API Gateway
• API composition across services
Learn to expose, evolve, and compose APIs for independent services.
8. Applying CQRS
• Separate command and query responsibilities
Improve scalability, performance, and clarity by splitting read/write concerns.
9. Testing in Distributed Systems
• Applying the Advanced Test Pyramid to microservices
• Using Consumer-Driven Contracts (CDC)
• Strategies for reducing the bottlenecks of enterprise-wide test environments
Build confidence in service behavior across evolving boundaries.
10. Releasing Microservices
• Feature Toggles as release strategy for safe rollouts
• Deployment strategies
Learn how to ship faster and safer in complex environments.
11. Transforming Monoliths to Microservices
• Identifying service candidates
• Using Anti-Corruption Layer to isolate legacy
• Applying the Strangler Pattern for step-by-step transformation
Manage legacy without rewriting and evolve confidently toward a modular future.
