Living at the moment is great... until the moment throws a production error and your logs say: ¯_(ツ)_/¯

Traditional systems forget the past. Event Sourcing doesn’t. It captures every change like a journal, making debugging, audits, and insights way easier, and sometimes even fun. And it doesn’t just give you those benefits, it brings context to your moment, something that matters not just in software, but in life too.

We’ll walk through the core concepts—commands, events, read models, projectors, event store, and see how they come together in a real-world application. And yes, there will be live coding, because there’s nothing like seeing it all unfold in action.

If you’ve ever been curious about Event Sourcing but found it a bit intimidating, this session is for you. It’s all about clarity, practical insights, turning facts into code, and maybe a few dad jokes along the way.

Living at the moment is great—until production throws an error and your logs shrug back: ¯_(ツ)_/¯

Traditional systems forget the past. Event Sourcing doesn’t. It records every change like a journal, making debugging, audits, and insights much easier—and sometimes even fun. But beyond the benefits, it also comes with real trade-offs every developer should know before adopting it.

In this session, we’ll explore the core building blocks of event-sourced systems—commands, events, read models, projectors (reactors), and the event store—and see how they fit together in practice. We’ll unfold practical patterns by applying them to a live-coded Tic-Tac-Toe game, step by step.

What you’ll learn • Develop a clear mental model of Event Sourcing and recognize when (not) to use it • Apply practical patterns immediately in your own systems • Understand both the superpowers and the pitfalls of event-sourced architectures

Anyone (backend developers, cloud developers, architects) who is curious about event-driven systems and wants to move beyond the theory into real-world applications. No prior Event Sourcing experience required—just curiosity and maybe a sense of humor.

The most prominent shift we've observed in the field of distributed systems over the last decade is probably the transition from traditional synchronous integrated systems to message-driven means. This change is a logical response to the high demands for scalability, elasticity, and resilience within today's software systems.

Regardless of how overwhelming the array of message-based options may seem, Cosmos DB serves as an incredible solid backbone for most of them, whether utilized as a transactional outbox or a fully-fledged event store in the context of event-sourcing. By diving deeper into real-world experiences, we will discover the mechanics of how Cosmos DB can guarantee nearly infinite scalability if you follow a few basic principles and patterns to efficiently model your data.

While Cosmos DB should not be considered as another silver bullet, this talk will teach you why you should certainly keep it as a prominent tool in your toolkit when it comes to building event-driven systems at scale.

The most prominent shift we've observed in the field of distributed systems over the last decade is probably the transition from traditional synchronous integrated systems to message-driven means. This change is a logical response to the high demands for scalability, elasticity, and resilience within today's software systems. Regardless of how overwhelming the array of message-based options may seem, Azure Cosmos DB serves as an incredible solid backbone for most of them, whether utilized as a transactional outbox or a fully-fledged event store in the context of event-sourcing. By diving deeper into real-world experiences, we will discover the mechanics of how Azure Cosmos DB can guarantee nearly infinite scalability if you follow a few basic principles and patterns to efficiently model your data. While Azure Cosmos DB should not be considered as another silver bullet, this talk will teach you why you should certainly keep it as a prominent tool in your toolkit when it comes to building event-driven systems at scale.

On-boarding new developers and imposing programming patterns and guidelines can take a good amount of time from your team. Roslyn with its rich APIs is helping us to tackle these challenges at compile time. In this session we will investigate Compiler APIs from Roslyn and how they assist to create Semantic Analyzers and Code Fixers tailored for your team. With Semantic Analysis you can ensure the given program is semantically consistent with language definition, and with Semantic Analyzers you can extend it to best practices and coding patterns. Code Fixers provide suggestions for the already written code to be replaced with an alternative, this way your team's developers will have an extra tool in their toolbox for writing better code addressing their needs. In the session we will showcase how to save time on development and during code reviews through unifying the build on your machine and CI/CD pipelines.