✅ Why Attend This Training?
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
• Duration: 4 days (32h)
• Platform: Java, Spring Boot

📚 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.