.NET Day Online 2026

Modern software systems are becoming ever more distributed and complex, requiring efficient and reliable communication mechanisms to maintain consistency and performance.

With many moving parts, applying well-established patterns like Outbox, Inbox, and Sagas becomes crucial to achieving the key ‘ilities’ you are looking for.

In this session, we will dive into practical use cases, demonstrating how these patterns can be leveraged to tackle some of the challenges in modern software architectures. Through real-world examples, you'll learn how these patterns can enhance the resilience and maintainability of your distributed systems, ensuring they meet the demands of today’s complex environments.

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!

"Yeah, yeah, but your scientists were so preoccupied with whether or not they could, that they didn't stop to think if they should." — Dr Ian Malcolm, Jurassic Park

True in 1993. True today. When developers boast about writing 37,000 lines of code in a day, the question that matters isn't "how much code did you write?" — it's "what problem did any of it solve?" Our job as developers is to solve problems, and volume without value is wasteful. To deliver high-quality code that actually solves the right problem, teams must shift from thoughtlessly generating code to a structured, refinement-first approach.

To scale this standard across an entire department, we built a two-stage process: refinement first, build second. Refinement takes a problem through hypotheses, an epic, features, and stories — each with its own prompt specialized to the task. And all before a line of code exists.

The prompts are passed to a set of specialized AI agents in Claude Code or Copilot for building, orchestrated with OpenSpec. In building there are also multiple agents that between them handle: architecture, API design, writing tests, reviewing tests, coding, documentation, or logging architectural decisions. And all this in a development environment designed to allow teams to work without interruptions – YOLO mode, safely.

This isn't the one true process; it's what works for us, refined through trial and error. Yours will look different. But the basics of it - refine before you build, and let AI specialise rather than generalise - will be a great base to start from.

In this session I'll walk the process end to end, showing the real artifacts it produces at each stage: the prompts, the cost of running it this way, and the times it's gone wrong and needed rework.

By the end, you'll have a concrete process you can adapt: how to structure refinement so AI doesn't just generate code, but high-quality code that solves the right problem — and an honest account of what it costs to run this way.

"Haha, npm had yet another supply chain attack!"

I'm waiting for the day this happens with .NET and NuGet. The tools are there! A number of interesting techniques exist to smuggle code into someone's codebase, malicious or genuine.

In this talk, we'll look at several .NET, NuGet and MSBuild techniques to inject code into a software supply chain. We'll also look at some ways to mitigate the risk (but you can't eliminate it).

Monolithic apps are the worst! They grow and grow until they collapse under their own weight as a Big Ball of Mud.

Microservices are the here to save us! But wait, they're REALLY hard to get right and REALLY hard to manage at scale. In addition to whatever challenges you’re facing with modeling the business problems, you now get to add all of the complexities of distributed computing on top of it. And way too often microservices end up being the worst of all worlds: the dreaded DISTRIBUTED MONOLITH.

Enter, the Modular Monolith. Simple deployments. Cheaper hosting. Easier to extend. Still capable of supporting multiple independent development teams.

Not too simple; not too complex. Maybe the it’s Goldilocks solution your application has been yearning for.

.NET is one the most interoperable tech stacks in software development – and if you haven't checked in lately, you're in for a surprise. Modern .NET runs everywhere, coded in rich environments like Visual Studio, VS Code, or Rider. Open-source platforms like Uno Platform take that same shared .NET codebase seamlessly to mobile, desktop, and web – native APIs on iOS and Android, full platform integration on Windows, macOS, and Linux, and performant Wasm apps in the browser. Modern .NET can reach embedded systems like Raspberry Pi and IoT, and lights up smart watches on Wear OS and watchOS. SkiaSharp handles high-performance rendering across it all, while polished design tools keep the developer loop fast and visual.

.NET with modern AI Agents/Models, provides particularly powerful workflows. The C# MCP SDK makes standing up MCP Servers easy, and Skills or custom Agents turn Agentic hype into actual developer workflows – all backed by C#'s maturity and the flexibility of Roslyn. XAML remains rich and powerful, while developers get their choice of design patterns like MVVM or MVU, and Reactive patterns bring a declarative edge to building .NET UI.
Modern .NET is powerful, flexible and welcoming to all. And .NET developer productivity is easily boosted with contextual AI. This is a great time to be in .NET – let's see why.

Modern apps use language models, but how do those models safely interoperate with your company’s backend data without putting the business at risk? SQL MCP Server answers that question. It is Microsoft’s open source MCP server for secure access to SQL Server, Azure SQL, PostgreSQL, Cosmos DB, and MySQL, running in the cloud or on premises at enterprise scale. It provides a feature-rich database API designed to help models understand and work with your data while enforcing permissions, policies, and operational boundaries.

Built on the same high-scale engine that powers Microsoft Fabric’s own GraphQL API, SQL MCP Server is designed for both scale and developer productivity. With a rich inner loop and a cross-platform command line, it works just as well for enterprise workloads as it does for engineers innovating on the ground.

Building cloud-native, distributed Blazor applications doesn't have to be a logistical nightmare. Discover how to streamline the entire lifecycle of your web apps—from local development to global scale—using Microsoft .NET Aspire and Azure Container Apps. In this session, we will use the open-source Blazor Data Orchestrator as a real-world architectural example to demonstrate how to break down complex data workflows. You will learn how .NET Aspire simplifies local orchestration, service discovery, and telemetry, and how to seamlessly push that exact architecture to the serverless, highly scalable environment of Azure Container Apps.