Master CQRS & Event Sourcing: From Code to Concept
Are you facing challenges with legacy codebases, unclear state transitions, or scaling systems under increasing domain complexity?
These are challenges many teams struggle with.
Conventional architectures lack the transparency and adaptability needed for modern systems. CQRS and Event Sourcing provide patterns that make behavior explicit, state traceable, and change manageable.
The CQRS & Event Sourcing Workshop with Marco Heimeshoff gives you a better way.
Over two intensive, hands-on days, you’ll learn how Event Sourcing and CQRS can help you build systems that capture business intent, model change as immutable facts, and separate complexity with clarity.
With guidance from Marco Heimeshoff, you’ll not only understand the theory, you’ll gain the practical skills to implement these architectures in your own projects.
We’ll focus on immediate, real-world applications through exercises that cover everything from event-driven design to real-time updates. By the end of the two days, you’ll not only understand the theory but also have the confidence to implement these powerful architectural patterns in your own projects.
Learning Objective
By the end of the workshop, you’ll be able to:
- Design scalable, auditable, event-driven systems from scratch
- Model real-world behavior using semantic commands and events
- Separate complexity using Command and Query responsibilities effectively
- Implement robust CQRS-based architectures powered by Event Sourcing
- Write tests that simulate and validate business behavior over time.
This isn’t just about understanding concepts, it’s about building systems that last.
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 eventsEventual 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.
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 stores fit together.
- Designing Event-Driven Systems – Practice event modeling, 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.
Will there be any materials to take away?
There will be a handout with additional content as well as a fully working demonstrational codebase for you to explore
