Event Sourcing & CQRS Workshop
Event Sourcing and CQRS can unlock transparency, scalability, and evolution.
What’s hard is turning the blog-post promise into production-ready code.
Where do aggregates end and bounded contexts begin? How do you refactor a stream full of historical events? How do you model long-running workflows without tying yourself in knots?
In this two-day Event Sourcing & CQRS Masterclass with Marco Heimeshoff, you’ll work through the real challenges and you’ll:
- Map messy domains into clean, focused bounded contexts preventing model entanglement.
- Design events that capture real business intent and learn techniques for versioning them safely as the domain evolves.
- Split read and write models with confidence, optimising performance without sacrificing consistency.
- Practise patterns for sagas, process managers, and projections that keep complex workflows reliable and observable.
- Explore the real-world hurdles that make or break CQRS/ES projects defining the right aggregate granularity coordinating complex, cross-aggregate transactions handling cross-cutting validation without leaking domain rules.
Throughout the class Marco Heimeshoff pairs short theory bursts with guided, hands-on exercises. You’ll model, code, refactor, and deploy, seeing firsthand how each decision shows up in your event stream.
Join us and make the leap from curious to competent, and build systems that stay future-proof, no matter how the future changes.
Learning Objectives
By the end of the workshop, you’ll be able to:
- Design scalable, auditable, event-driven systems from scratch that can evolve safely as business needs change.
- Model real-world behaviour with rich, semantic commands and events, capturing intent and outcomes unambiguously.
- Carve the domain into cohesive Bounded Contexts and apply CQRS to keep write-side decision-making isolated from read-side projections, taming complexity as the system grows.
- Implement a production-ready architecture that combines CQRS with Event Sourcing, giving you full traceability, time-travel debugging, and flexible data-shaping options.
- Build a rapid red-green-refactor feedback loop: write expressive, domain-driven tests that replay event streams to verify behaviour over time and guard against regression.
The workshop is relentlessly practical: you’ll learn how meaningful separation of concerns, clear bounded contexts, and an event-centred testing cycle combine to produce antifragile systems. Systems that welcome change instead of fearing it.
The Trainer
Marco Heimeshoff is a Software Developer, a passionate EventStormer, a coach and a Speaker.
Care Bear of DDD, cultural optimist, helping others to become better versions of themselves.
Marco Heimeshoff is also the co-organiser of KanDDDinsky.
With over a decade of experience, he helps teams grow by guiding them through everything from code to culture, teaching practical mastery of Domain-Driven Design, Agile development, functional programming, and CQRS with Event Sourcing.
When he’s not consulting with companies around the world, Marco speaks at international conferences on Domain-Driven Design, socio-technical systems, and software design fundamentals.
Target Audience
This workshop is designed for:
- Software Architects looking to evolve legacy systems or design new ones
- Senior Developers ready to move beyond layered architectures
- Team Leads & Tech Leads dealing with scaling challenges and distributed systems
- Anyone working with Domain-Driven Design, microservices, or event-driven systems.
If you’re exploring semantic software, messaging, or tackling complex business domains, you’re in the right place.
Topics
- Event Sourcing: Events, event streams, and domain models
- Events and Storage: managing event stores
- Event Replay & Versioning: Rebuilding state and evolving events
- Eventual Consistency: Handling distributed systems and consistency
- Semantic Testing with Events: Writing tests for event flows and state transitions
- CQRS: Benefits of Command and Query model separation
- Command and Query Models: Working with commands, validation, and projections
- Event-Driven CQRS: Using Event Sourcing to power CQRS systems.
- Sagas: Reactive behaviour, distributed transactions, and
- Failure handling in long running, distributed processes.
Agenda
Day 1: Mastering Event Sourcing
- Why Event Sourcing? – Understand the power of immutable facts, auditability, traceability, and evolution.
- Core Concepts – Learn how events, streams, aggregates and projections fit together.
- Designing Event-Driven Systems – Practice modeling events, consistency boundaries, and storage choices.
- Rebuilding & Evolving Systems – Use event replay and versioning to rebuild state and manage schema evolution.
- Eventual Consistency – Handling distributed systems with Event Sourcing. How to manage business logic across different boundaries.
- Semantic Testing – Validate system behavior with event-based testing strategies.
Day 2: Integrating CQRS with Event Sourcing
- Introduction to CQRS – Separate reads and writes to untangle complexity and gain clarity.
- Semantic Messaging – Capture business intent and model domain behaviors through commands.
- Event-Driven CQRS in Action – Drive projections, listeners, and workflows from your event store.
- Advanced Topics – Implement sagas, orchestrate long-running processes, and handle distributed failures gracefully.
How It Works
This is a fully hands-on, in-person workshop.
You’ll:
- Build a CQRS & Event Sourcing system
- Model commands, events, projections, and failure paths
- Practice designing consistency boundaries and messaging patterns
- Test your systems using event-driven flows and replays.
Every concept is reinforced through guided exercises, making sure you leave with not just theory, but muscle memory.
FAQ
Do I need to know something beforehand in order to participate in this workshop?
You should be able to build object-oriented or functional software and use a unit testing library. Anything else needed for this workshop will be taught during the sessions.
Do I need to bring my laptop with me?
Yes, please bring your laptop with a running dev-environment for your favourite language.
