.NET DevOps Revolution: Flexibility and Quality Control with Docker's Adaptive Arsenal

"It worked on my machine!" is not only said at runtime. It is as easily said during application build! A well-known solution for this is to create a Docker container image of your application. But what if the application will be run in an environment not supporting containers with required unit and quality validation tests? Let's see together how we can achieve this by picking and customizing the interesting bits of the common .NET Dockerfile to our needs. We'll do this from a developer's view, making sure the least amount of management and after-care is required.

Breaking a Monolith Data Import into Azure Logic Apps Quick

Everyone probably has made them: Scheduled tasks to download files and import the data into a different database after some transformations and business logic.
But those can get vulnerable quickly by piling up its purposes and external dependencies, creating a small monolith.

Azure has different resource types to help you create these kind of tasks.
But if you start from an existing one, you can use Azure Logic Apps to offload your external connections without any code.
Combine it with Azure Storage Accounts and Service Bus to create a whole extendable integration solution.

We'll start with an Azure Function that was responsible for all steps of an import, and break it down with Logic Apps to the point where it can ingest files from different sources at the same time.

The Spaghetti Lasagne which Aspired to be Contained Ravioli

Ever inherit .NET solutions that looked like they were assembled after a particularly chaotic cooking show by multiple contestants and got mashed together? We did! 'The Spaghetti Lasagne' – a codebase layered with good intentions, but ultimately a saucy, tangled mess of disparate parts. A modern container could not even keep it safe anymore due to the age of the .NET version used! This is the story of our refactoring journey, from that initial indigestion to a far more refined dish: 'Contained Ravioli.' We'll explore how we used private NuGet feeds to create clear boundaries between components, brought all projects to the same table with a monorepo eventually, migrated to a container-friendly .NET version, and are now enjoying an easy to test and debug solution thanks to .NET Aspire. Bon appétit!

What the Scrolls Didn’t Say: A Real-World Microsoft Agent Framework Quest

Pick up your swords and join us on a quest to create a small but valuable Microsoft Agent Framework POC for a development team! The POC subject is but an excuse to go on an adventure to explore the different capabilities of the Microsoft Agent Framework.

What can we do with it? How can we host and integrate with it? How can we track, test and tackle this new ever-shifting dragon?

Let us share this information as a retelling of our treacherous hero's journey at the local inn. Without bardic inspiration, because we'll also share the challenges we met of working with a fresh new framework in flux.

Prepare for a story about Breaking Changes, AI Agents, Workflows, Tools, Hosting and Testing capabilities!

2 speakers for this session

Building Multi-Agent Systems in your Applications

As AI applications grow, prompt handling becomes a core design challenge. A single agent can process prompts end to end, but a multi-agent system improves results by classifying, routing, and enriching prompts and answers through specialized agents.

This session shows how Microsoft solutions enable this approach in developer friendly fashions for your applications. But the concepts could be applied to solutions from other providers as well.

We will be making specialized agents and learn how to make them available for internal or external use. Practical patterns and solutions for multi-agent systems will be shared where they can discover and collaborate with each other.

By the end, you will have practical examples of creating modular and governable multi-agent solutions for your application.

The Human Guardrail

We are in a new era of software delivery! AI agents generate code, propose integrations, and accelerate decision-making with remarkable speed. But speed alone is not a strategy when creating understandable and maintainable software for both humans and agents. It’s only a matter of time before everything goes down a hill of technological mud where no one understands how the software works or can stay working.

So, are humans the speed bottleneck in agentic development? No, we are the guardrail keeping it from going down the mud hill. And I want to share this fact through my experiences and examples of putting the AI agents back on the right track. All done by getting our own human boots back in the code mud with an AI assistant, looking into architectural decisions as a human, and creating the necessary instructions and skills for AI Agents to succeed. In other words, enjoying the best of both worlds.

These stories will provide you with insights, what to use and what to look out for in your own development workflow to ensure a balanced collaboration between humans and AI agents.