Speakers: Andreas Willich

Legacy .NET applications often come with a painful reality: setting up a reliable local development environment feels impossible, and running meaningful integration tests is even harder. Complex dependencies, missing infrastructure, and brittle setups frequently force teams to skip tests altogether, increasing the risk of regressions and slowing down delivery.

In this talk, you’ll discover how .NET Aspire can transform this challenge into a manageable, automated process. We’ll explore how to integrate Aspire into an existing legacy project to spin up a consistent, containerized development environment—without rewriting your application. You’ll learn how this approach makes it feasible to run integration tests that were previously out of reach, unlocking faster feedback loops and more confident deployments.

Speakers: Stefan Pölz

Would you like to know how incremental source generation and source-level interception grant you Native AOT & performance “for free”?

The just-in-time compiler (JIT) is a mighty beast of the .NET runtime. And it becomes more powerful with every consecutive release of .NET. But it comes along with a cost during run-time, when compiling the assemblies containing intermediate language code into machine code. A price we may not pay gladly for highly scalable cloud services. Native AOT, compiling deployments ahead-of-time into executable code, moves this complexity to compile-time. But features that utilize dynamic code emission may stop working.

As a solution serve Interceptors which were shipped as experimental C#-only feature in .NET 8 and became GA in .NET 9. An interceptor is basically the inverse of a goto statement that enables the Roslyn compiler to replace reflection-based call sites with specialized implementations. Emitted from (incremental) source generators, codebases become more trimmable, more Native AOT-friendly and can unlock better performance.

May Roslyn be with you!

Speakers: Christoph Wille

Use EF migrations and you are all set, they said. Not so fast! Are your changes compatible with already existing data? Are your changes backward compatible?

What about DDL vs DML permissions? And then the elephant in the room: is EF migrations actually the best choice, or is a model-based approach even better?

Let’s find out what the “It depends” reasons are.

Speakers: Raoul Holzer, David Eiwen

In this talk, we will explore the DataSync CommunityToolkit, a powerful tool designed to simplify the integration of data in modern offline clients. We will discuss how it can be used to synchronize data between local and remote sources, ensuring that your applications remain responsive and up-to-date even when offline. The DataSync CommunityToolkit provides a set of APIs and utilities that make it easy to manage data synchronization, conflict resolution, and offline storage. We will demonstrate how to use these features in a practical example, showcasing the benefits of using the toolkit in your applications.

Speakers: Shahab Ganji

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

Speakers: Andreas Willich

Debugging and optimizing applications can often feel like navigating in the dark. Traditional log files are disorganized, verbose, and challenging to interpret, leaving teams overwhelmed and searching for a signal in a sea of noise. This issue isn’t limited to complex, distributed systems—it happens even in ordinary applications, where logs fail to provide clarity. Compounding the problem is the uncertainty about the time and effort needed to achieve specific performance levels. Without clear insights into bottlenecks, it’s difficult to know where to focus or whether your efforts will yield meaningful results.

But what if you could replace the chaos with clarity? What if troubleshooting felt like uncovering the full picture—precise, contextual, and actionable? And what if you could predict and measure the impact of your performance optimizations, removing the guesswork? Observability makes this possible by transforming the way we monitor and debug systems.

In this talk, Andreas Willich from TechTalk and Markus Enzlberger from XXXLutz will demonstrate how observability can tackle both challenges head-on. Using a real-world application built with MongoDB and Apache Kafka, they’ll show how rich traces, real-time metrics, and actionable visualizations enable faster root cause analysis, more efficient optimizations, and a clearer path to achieving your performance goals. Join us to uncover how observability empowers you to understand, improve, and take control of your systems.