
Explore concepts and terminology for event modeling and event sourcing, then model and implement a review approval system across application and infrastructure layers with event stores, event streaming, and dcb.
In this lecture, we will learn about commands, queries, and events, what they are, and how they differ from each other.
In this lecture, we will learn about the CQS design principle and how we can use it in software development.
This lecture introduces you to the CQRS pattern, how it compares to CQS, and how it can be applied.
Learn how event sourcing stores a sequence of immutable events, replays them to reconstruct state, and uses event streams, projections, and snapshots to support decision making and read models.
Combine event sourcing with cqrs to explore direct event store queries or separate projections that power a read model, enabling polyglot persistence, performance, and scalable, efficient queries.
Explore event modeling, a timeline-driven method that maps commands, events, and views to tell a system's story through actions. Apply event sourcing-aligned blueprint to emphasize information flow across teams.
This lecture is just a small disclaimer saying that you don't need event sourcing to do event modeling. The implementation of an event-modeled system is out of the scope of event modeling itself.
Learn the main building blocks of event modeling—commands, events, and views—and how commands trigger behavior, events record immutable facts, and views expose information via read models.
This lecture talks about the importance of UI mockups and wireframes and how they can be used in your event model.
Master the state change pattern, or command pattern, modeling how information enters the system and how behavior yields state changes. An add task command leads to a task edit event.
Explore the automation pattern, which combines state view and state change to automate non-user steps in a workflow. See how a task archiver archives completed tasks using a to-do list.
Explore the translation pattern to convert external events, such as GitHub issue opened, into local commands that produce task added events and update the read model.
Explore functional event sourcing and domain modeling to structure behavior in code, using commands, events, and state to implement decide, evolve, and react, and patterns like designer, view, and saga.
Quick note on Kotlin, the programming language used, and call for alternative languages.
Explore how decide validates commands, evolve applies events to state, and react generates follow-up commands, enabling deterministic, testable domain workflows within event sourcing.
Explore the saga pattern in functional event sourcing with a pure react function that converts action results into follow-up commands, demonstrated with EF model Kotlin examples and deciders.
Explore materialized views that persist computed task state by coupling view state computation with a state repository, using an in-memory example to fetch, evolve, and save tasks.
Explore event modeling and event sourcing through a practical review approval system, from submitting reviews to moderator decisions and published and visible results, using a UI prototype to map behavior.
Enhance the event model with swimlanes, explicit actors, and given-when-then tests to produce a clear blueprint of automations, moderators, customers, notifications, and bounded contexts.
Explore dynamic consistency boundaries in event sourcing, examining aggregates, commands and queries, decision models, append conditions, and the DCP specification to build a practical mental model.
Explore the limitations of aggregates in domain driven design, highlighting how static boundaries affect consistency, cross-boundary invariants, and evolving requirements, and examine approaches to mitigate complexity.
Apply append conditions to maintain consistency in event-sourced systems using optimistic locking. Fetch events by a query, compare the last known position, and append new events to prevent concurrency issues.
This course will give you a solid understanding of event sourcing and event modeling, two powerful approaches for designing and implementing software close to the domain of your business.
Instead of storing only the current state of your data, event sourcing captures every change as an immutable sequence of events. Event modeling builds on this by providing a structured way to design, visualize, and reason about your entire system through these events without going into detail about how the system is implemented.
Throughout this course, you will:
Learn the fundamental concepts and terminology behind event sourcing and event modeling.
Explore how commands, events, queries, and more work together to coordinate business processes.
Learn how to implement event sourcing using functional patterns like deciders, views, sagas.
Discover dynamic consistency boundaries (DCB) — a fresh way of thinking about consistency in event-sourced systems.
Put everything into practice by modeling and implementing a simple review approval system step by step.
The focus of this course is on concepts and patterns, not on a specific tool or framework. Most examples are written in Kotlin/Java, but the ideas apply to any technology stack.
By the end, you’ll have the knowledge and confidence to apply event sourcing and event modeling in your own projects — and to participate in ongoing discussions about where these approaches are heading.
If you’re a software engineer, architect, or anyone interested in better ways to model complex systems, this course is for you.