Along the way, I’ll show how easily you can plug in messaging, persistence, and observability without the usual wiring and complexity. Once it's running locally, we’ll set up CI/CD and deploy the whole thing to the cloud - with minimal effort.

Whether you're modernizing an existing solution or starting from scratch, you’ll walk away with practical ideas and a new appreciation for Aspire’s end-to-end developer experience.

Talk (60 min)

Effortless Distributed Systems with Aspire

.NET

Architecture

Cloud

DevOps

Well, no, not really. Your onboarding processes are probably poorly documented, the tools your developers use on a day-to-day basis vary wildly between teams, and the way your teams deploy to production vary from dated bash scripts to crossed fingers over beers on Friday. Hardly the solid context needed for generative AI to actually be helpful.

In this talk, we’ll explore how platform engineering and generative AI can work together to improve developer experience, if you get the foundations right. We’ll look at common organisational and cultural challenges that limit productivity, and how to start addressing them with simple, practical steps. From there, we’ll show how “everything-as-code” patterns and AI-assisted tooling (such as MCP servers, coding copilots etc.) can accelerate platform maturity and reduce friction across teams.

Whether you’re a platform engineer, developer, or tech leader, you’ll leave with a clearer view of how to build a platform that AI can actually help with, and how to make your developers happier in the process.

Platform Engineering in the age of Generative AI

So what’s real, what’s exaggerated, and what’s next? Join Richard Campbell for an insightful look at the current AI surge, why it matters, and where the real success stories are happening today. Explore the opportunities, the challenges, and the eventual end of the hype cycle—so you can separate the promise from the noise and prepare for the future of AI in business and development.

Beyond the AI Hype: What's Real, What's Next

Ethics

People

Security

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.

Messaging Patterns for Modern Software Solutions

In this talk, I'll share a raw and honest take on how GitHub Copilot can be used right. I’ll show how Ask Mode empowers learners to ask the “million questions” they’re afraid to ask and get answers that build confidence, not dependence. And how Agent Mode helps senior devs accelerate delivery, refactor legacy code, and surface security flaws without losing control of their architecture.

This isn’t a hype session. It’s a call to action: to use AI as a tool for growth, not replacement. To build better software, support each other, and stop burning out. Whether you’re early in career or leading the charge, this talk will challenge your assumptions and leave you with practical ways to thrive in the age of AI.

Ask More. Build Better. Burn Out Less- Real Talk on AI, Devs & GitHub Copilot

Soft Skills

Tools

Work skills

This session shows you how to flip that script. I’ll share a practical framework for designing and deploying AI agents that create measurable business impact, agents that align with real workflows, integrate securely, and deliver results people actually care about.

You’ll leave with:
- A checklist for spotting when an AI agent is worth building (and when it’s not)
- Common pitfalls that cause pilots to fail and how to avoid them
- Strategies for measuring and communicating value early to win stakeholder trust
- Real world lessons from enterprise rollouts that moved from hype to impact

If you want to stop wasting resources and start building AI agents that stick, this talk will show you how.

AI Agents That Don’t Suck: How to Build Ones That Actually Drive Business Value

Machine Learning

In this session, we’ll build a Flight Tracker from scratch, powered by the Agent Framework. Along the way, you'll learn how you can orchestrate agents that can fetch live flight data, manage context, and respond in natural language as well as use tools, connectors, and memory to make your agent reliable and context-aware.

We will also explore human-in-the-loop approvals as well as learn to integrate with famous protocols like A2A and MCP so your agent doesn’t just act but acts responsibly.

By the end, you’ll see how the Microsoft Agent Framework makes it easier than ever to go from idea to prototype to production-grade AI agent, with enterprise reliability built in.

It’s going to be demo-packed, developer-focused session where you’ll discover how to harness the Agent Framework to bring your own AI agents to life whether that’s a Flight Tracker or the next big AI-first app.

Build your own Flight Tracker with Microsoft Agent Framework

In this session, we’ll examine how Zero Trust principles can be enforced at the browser layer. Using case studies from recent security incidents, we’ll map real-world compromises to MITRE ATT&CK techniques and show how enterprise browsers and browser isolation platforms are evolving into critical security control points.

Attendees will learn how to mitigate SaaS and GenAI risks with in-browser DLP, tenant restrictions, OAuth consent governance, and session telemetry—without locking down productivity. Whether you’re a CISO, security architect, or practitioner, you’ll leave with a clear understanding of why the browser is now your most important Zero Trust battleground.


Zero Trust in a SaaS and AI World

More like a revolution than an evolution of software delivery, SDD produces solutions as artifacts of a structured specification. This specification is the contract for code behavior and the single source of truth guiding developers, tools, and AI agents to generate, test, and validate results. It is software engineering through prompt precision.

Spec-Driven Development: The Fast Track to 10x?

We learned that LLMs aren't just APIs with fancy responses—they're distributed systems with non-deterministic failure modes, unpredictable costs, and reliability challenges that break traditional architectural patterns. This talk is a technical deep-dive into building AI infrastructure that survives production.

Production-Grade LLM Architecture: Lessons from Processing 50 Million AI Requests

In this session, we'll cover best practices for securing your .NET projects, including using tools like Trivy and NuGet’s security features to scan and monitor dependencies. We’ll also discuss supply chain observability—how to track vulnerabilities and ensure the integrity of your components.

Beyond tools, we'll touch on team policies for approving third-party libraries, setting security gates in CI/CD pipelines, and fostering a security-first mindset in your organization. Live demos will show practical steps you can implement right away to protect your applications.

.NET supply chain: Protecting against hidden threats

Despite how important and prolific software and programming have become over the last 50 years the general public still have a very loose understanding of what software actually is.

This hasn't been lost of the people that build the software, who often slowly try and capture themselves in the work that they do.

In this talk we'll take a look at some examples through history of seeing the humans behind the code they write as they imprint themselves on their work and we'll consider if it's possible to deliberately make art by manipulating the form and design of software itself.

A talk for everyone wanting to be seen in the work, or understand their own creative urge.

Meditations on Code As Art

In this talk I will present what these both mean to me as someone who has been a "DevOps" engineer and is now a Platform Engineer. I'll talk about the "Platform Engineering Iceberg" showing how what appears to be a simple term hides a mass of complexity and challenges. And to wrap it up I'll talk about Developer Experience and how that ties into all of this.

Platform Engineering vs DevOps

How do you improve safety and asset maintenance, with a person in a Pit, when we are designing digital products from the office?

The first step in building truly effective digital products is focusing on the people who rely on them daily. I've been to the literal coal face, it's dusty, hot, sweaty, flies buzzing, with big dirty gloves on. Not to mention offline and over exposed!

Innovation fails when we ignore the end users. Applying Human Centric Design principles reduces costly failures, boosts adoption, and drives tangible impact. Add in AI, machine learning, automation and predictive analytics, and now we are shaping the next frontier and making a Digital Twin.

Human-Centered Design (HCD) is key—iterating and testing in real mining environments ensures our technology meets real-world needs. By integrating user feedback and iterating the design, we create safer, smarter, and widely adopted industrial solutions.

Over the years, our team has developed IoT devices, sensors, apps, websites, AI Visionware, and digital platforms to monitor Bradken’s steel products across mining operations for 100+ mining companies in 20+ countries.


Designing technology for dirty gloves

Embedded

3D Modeling

We'll look at how the MCP C# SDK makes it simple to annotate your existing controllers, instantly transforming your REST endpoints into AI-powered services that can empower LLMs and agents. We’ll also compare this approach to a no-code approaches using Azure API Management.

Finally we'll look at where both of these approaches fall short and are only a starting point for a good long-term MCP design. You can use then to jump start the process and then follow the path we outline together to evolve your APIs from technical plumbing to intelligent, task-focused tools that solve real problems using AI—all without starting from scratch.

Old API, New Tricks: Add MCP to Existing .NET REST Endpoints

This talk will provide a gentle introduction to the collector itself, then dive into the specific examples. If you are curious about the topic, this video provides an excellent primer for this talk: https://www.youtube.com/watch?v=_CJrFW_yjRo

Get a Grip on your Telemetry using the OpenTelemetry Collector

Workskills

Gian Wild chaired the Mobile Site Sub-Committee to develop a set of Mobile Site Testing Guidelines that are available under Creative Commons. These guidelines are meant to be used in conjunction with WCAG2 (and WCAG2.1) to ensure that sites are accessible to people with disabilities using mobile and tablet devices.


Accessibility is important to all – not everyone using your mobile app, device or wearable will be fully functioning, either because they have a disability, or they are simply engaged elsewhere. Gian talks about the things that are essential to avoid when designing mobile apps, devices and wearables to ensure that everyone can use them. She talks about specific mobile accessibility features: pinch zoom, native screen readers, haptic keyboard, etc., and system accessibility settings: font size, screen rotation, high contrast, etc.


Mobile accessibility: building accessible mobile sites and native apps for accessibility

Mobile

Testing

But what if I told you that you didn’t have to use JavaScript at all? Not even as a build process? Thanks to updates in browser technologies, there’s now a plethora of native browser features that allow building modern, functional websites, sans JavaScript.

So together, we’ll build out a *completely* static website, a collection of HTML and CSS files, no tracking, no scripting, no servers, no third-party resources. Let’s build a website the way we used to (but no marquees).

Your website does not need JavaScript

JavaScript

We’ll start with a quick demo of vibe-coded UI work to show where it shines (exploration, spikes) and where it falls apart. Then we’ll move to context-engineered flows that plug in your own docs, API schemas, and tool permissions to get more consistent results. Finally, we’ll go spec-first: contracts, checklists, and CI rules that let AI generate specs, tasks, and implementation in a controlled pipeline—without losing momentum.

You’ll leave with a playbook for when to use each style, plus templates you can bring back to your team to move from “cool demo” to code you can run in production.

- Differentiate between vibe coding, context engineering, and spec-driven development in terms of risk, speed, and governance.

- Identify scenarios where each approach is appropriate (exploration, delivery, production hardening).

- Design a basic spec-driven workflow that produces reviewable PRs with tests and CI checks.

- Apply context-engineering patterns (docs, APIs, permissions) to improve AI output consistency.

- Evaluate their current AI usage and propose one concrete improvement for their team.

Vibe Coding vs Context Engineering vs Spec-Driven Development

In this talk we'll cover:
- Why should we consider creating fun and engaging experiences via messaging
- How OpenAI's API works
- How to set up Twilio’s WhatsApp sandbox to send and receive incoming media
- How to process and transform images with OpenAI’s latest APIs
- Utilising existing libraries to transform images
- Sending images through WhatsApp
- Best practices for handling image input, latency, and user experience
- Other cool things you can build once you have images

This demo is practical, fun, and showcases how teams can blend communication APIs with AI to create delightful, interactive messaging experiences.

Building fun and creative messaging experiences on WhatsApp

Attendees will learn how these tools can simplify development, enhance user experience, and bring desktop-like capabilities to the web. Through live demos and practical industry examples, developers will leave with actionable insights and inspiration to integrate these APIs into their own projects.

This talk is targeted at web developers, technical leads, and product designers eager to explore innovative browser capabilities and stay ahead of the curve.

Web APIs You Should Be Using in 2026: Unlocking Next-Level Web Experiences

Cross-Platform

Australia’s backyard fauna are nature’s ultimate chaos engineers. In this fast‑paced, demo heavy session, we’ll channel our inner Wile E. Coyote—optimistic, iterative, occasionally singed—and show how combining AI, IoT, and a bit of ACME‑grade creativity can turn your backyard, deck and shed into a humane, real‑time defence system.

The Wile E. Coyote approach to AI for backyard beast management

This session guides authorization for AI workflows beyond RBAC (Role-Based Access Control). We'll implement dynamic permission scoping, context-aware authorization, and most importantly, human approval gates for dangerous operations. You'll learn to build agentic workflows that are useful enough to deploy but constrained enough to trust with production data.

AI Agents Need Permission Slips

What started as autocomplete has become chat assistants, CLI tools, and cloud agents, with their evolution being claimed as a shift from a pair programmer to that of a peer in our virtual team. This session takes a practical look at how we can work with these tools effectively, optimise them for real-world use, and critically assess when they’re genuinely contributing... and when they’re just getting in the way.

From Pair to Peer Programmer

This is when I discovered integration tests - a far more effective safety net for ensuring our system works as expected. But building effective integration tests is much more challenging than isolated unit tests.

In this session, I'll break down the common tools used in integration tests for .NET, including the testing package for Microsoft and other extensions such as FastEndpoints. I'll also cover dealing with shared state and infrastructure like databases using TestContainers, and external uncontrollable dependencies.

Finally, I'll share patterns for building effective and maintainable integration tests for a variety of application types, from web apps, to APIs, to messaging endpoints.

Building the Ultimate Safety Net with Integration Tests

5 years later we're starting to grapple with some of the implications of that issue. LLM-generated code is being smuggled into large code bases, some successfully and others not. Open-Source maintainers are creating policies forbidding LLM-generated contributions, yet others are delegating their tech-debt and backlogs to LLMs.

In this talk I'll be sharing some data and insights on the analysis of millions of lines of LLM-generated code. I'll explore some principles of software engineering, maintainability and quality and explore how they apply to an AI-generated toolset. I'll share some techniques for improving software quality when using LLMs and my opinions on the long-term risks with letting the LLM write the code.

Are LLMs good software engineers?

Programming Languages

Do you get your SLAs, HAs and DRs confused with your RPOs and RTOs?
The cloud vendor will take care of recovery right?
How does SaaS change the planning?
What risks do I need to cater for, and which do I ignore?

This session is designed for anyone building enterprise grade systems or being in the position of having to work with stakeholders on requirements, options and costs.

With some lightning storms, a bit of math and lots of take home tools and discussion starters, this session is designed to make you feel more confident when designing your next 99.999% uptime system.

Bulletproof - Designing for risk, resiliency and recoveryarchet

In this session, we explore the Azure AI ecosystem from a delivery and architecture perspective, showing how real-world AI solutions emerge from the combination of data platforms, semantic foundations, agent orchestration, pro-code and low-code experiences, and securely exposed tools and APIs. Drawing on Microsoft’s latest Ignite announcements—Fabric IQ, Foundry IQ, and Work IQ—we’ll unpack how Microsoft is converging on a unified intelligence layer that finally makes AI agents useful at enterprise scale.


You’ll see how these capabilities map to practical architectures, where teams typically go wrong on the path to AI ROI, and which patterns consistently succeed. The focus is on delivering measurable value today—search, summarisation, decision support—while deliberately preparing for the next wave of agent-driven systems.
This talk is aimed at developers and architects who want to move beyond demos and build AI platforms that scale, govern, and deliver real outcomes.

The Azure AI Ecosystem for Real-World Enterprise ROI

In this session, we’ll cut through the hype and focus on practical, developer-tested strategies for getting the most out of AI in your workflow.

You’ll learn how to master prompting and context engineering, make the most of long context windows, streamline debugging and testing, and integrate AI into your daily development practices without sacrificing code quality or security. We’ll also explore how emerging standards like Model Context Protocol (MCP) unlock new workflows by connecting your AI assistant directly to tools such as GitHub, Slack, Playwright or Figma — turning it from a code generator into a true development teammate.

Whether you’re new to AI-assisted coding or already experimenting with it daily, you’ll leave this talk with concrete ideas and techniques you can apply immediately to level up your development process.

10 tips to level up your ai-assisted coding

Attendees will see how each tool performs in terms of accuracy, speed, and integration with existing workflows. The session will highlight specific strengths and limitations based on real coding scenarios. It will also cover what happens when multiple tools are used together.

This talk is intended for developers who want a practical understanding of how current AI tools support day-to-day programming work and where manual effort is still required.

Evaluating AI Developer Tools: A Practical Comparison

That approach gave us room to learn. Teams ran small tests, shared what worked, and slowly built confidence. Over time, AI shifted from something a few people played with to something teams relied on daily. Eventually, we brought that experience into the product itself. We added AI features where they made sense, not as flashy add-ons, but to improve the deployment experience in simple, practical ways.

You should attend this session if you are a developer who wants a realistic view of what AI looks like inside a software team. If you have tested tools but struggled to get lasting value or are unsure how to introduce AI to your team without it becoming a distraction, this talk will help. You will hear what worked for us, what did not, and how we kept the focus on practical outcomes. Whether you are curious, cautious, or somewhere in between, you will leave with ideas you can take back to your team and use right away.

One Team’s Journey to Using AI Without the Hype

In this talk, we'll don the fedora and take up the whip as we explore techniques for exploring legacy codebases without triggering the traps. We'll dig into Source control archaeology, safe refactoring strategies, introducing tests in a hostile environment, and recognizing "cursed" files with high churn or hidden dependencies.

Whether you're maintaining a dusty monolith or inheriting a mystery repo, this session will equip you with tools and tactics to escape with the real treasure: Knowledge of how to extract business value and gradually modernize.

Indiana Jones and the Temple of Legacy Code

In this session, we’ll explore how developers can apply the principles of Responsible AI to build autonomous agents that are not only powerful but also trustworthy. We’ll walk through technical implementation strategies using publicly available Microsoft and Azure tools, including orchestration frameworks, fairness assessment toolkits, and governance patterns that enforce safe behaviour.

Through hands-on demos, we’ll showcase practical examples of how to audit agent behaviour, enforce action boundaries, and build systems that align with ethical and regulatory standards. You’ll see how to use tools to embed responsibility into every layer of your agentic architecture.

This talk will equip you with practical techniques to build autonomous AI agents responsibly using open-source tools, design patterns, and governance frameworks that ensure safety, transparency, and accountability from day one.

Building Responsible Autonomous AI Agents: Principles, Patterns, and Practices

This presentation introduces the design ideas that make column stores so powerful, such as cache-friendly access patterns, vectorized execution and advanced compression schemes. We will demystify the internal machinery of column stores, including columnar storage layout, sophisticated encoding schemes, and column-oriented query execution. 

You’ll leave this talk with a clear understanding of where column-stores shine, how they differ from relational databases, and why modern analytics platforms are built on these principles. Whether you’re a practitioner curious about database internals or just looking to understand the tech powering today’s big data systems, this presentation will give you an approachable, hands-on introduction to the world of column-oriented databases.


Column-oriented Database Internals

Database

Big Data

Azure Data's MCP story is also getting good. At the heart of our agentic play is Data API builder's new MCP experience, which provides DML and DQL interop for models in a novel and performant way that keeps security and scale top of mind. Integrated with AI Foundry, Entra, ACA, and SQL, the SQL MCP Server is an important puzzle piece.

For three years, Data API builder has given developers the flexibility, telemetry, and topological options they need to snap into the enterprise architectures of our largest customers and the earliest hobbyists. Free, open source, and fully supported, Data API builder is the cornerstone of our Data story arc to enable every developer.

But that's easy to say. Come see for yourself what Data API builder can do for classic line-of-business apps interacting with backend data sources, how massive chunks of a code base made redundant by the engine can be eliminated, and how intelligent apps integrating AI agents through LLM models can "just work" against your data sources.

Introducing the Azure SQL MCP Server for Enterprise Data Agents

Well, there's a bit more to it than that.

In this talk, I'll explore why many teams love the idea of ephemeral environments but struggle to implement them. We'll cover the fundamentals you need to understand before diving in, from how long these environments should live, to whether they need to mirror production, to where your data comes from, and what you should use these environments for.

You'll walk away understanding:
- What ephemeral environments are, when they make sense, and what infrastructure maturity you need before attempting this
- How your existing infrastructure choices (Kubernetes, Azure Static Web Apps, virtual machines, PaaS, etc.) influence your implementation approach
- Real-world tradeoffs between the coordination overhead of static environments versus the cost and complexity of ephemeral ones
- Why parameters and variables will be required everywhere, and why they can be frustrating

This is an honest look at what works, what doesn't, and how to bridge the gap between wanting ephemeral environments and successfully running them. I'll show a couple of demos of getting started, so whether you're evaluating ephemeral environments for the first time or looking to understand why your initial experiments didn't stick, this talk will help you make informed decisions about your approach.

Ephemeral Environments: Easier Said Than Spun

How to integrate AI into your .NET applications with Microsoft.Extensions.AI.

How ChatGPT and Ollama enhance contextual understanding.

Why vectorization is key to semantic search and how to implement it.

Through live demos and practical examples, you'll leave equipped to build better, more user-friendly search experiences. Whether you're a .NET developer or an AI enthusiast, this session will give you tools to level up your search game.

Warm and Fuzzy Search: AI-Driven Search in .NET

Upon an edge device, I designed, implemented and deployed a solution that acts as a communication bridge between the elderly and the outer world, including care takers, nurses, doctors etc. To achieve that, it uses local resources as well as Azure resources for multiple heavier tasks.

I will go through all the challenges I faced, stretching from hardware and software to people skills and the fear of the unknown.

I programmed a better grandson for my grandma.

This presentation is based on a research experiment where we systematically reviewed 400+ AI‑generated patches for real‑world vulnerabilities. We looked to answer two key questions:
1. Do AI‑generated patches actually fix the vulnerabilities?
2. Do developers learn from AI‑generated patches?

Our findings show a significant drop in remediation accuracy when developers rely solely on AI suggestions. A large number of participants could not explain how the AI‑generated patch addressed the issue.
Rather than serving as a mentor, current AI assistance risks over‑reliance, leading to a superficial understanding of vulnerabilities and passive consumption. Our findings is inline with other related research that shows a considerable drop in learning when humans rely on auto-suggestion tools.

This presentation is filled with real-world examples and data from a secure coding contest. We will discuss the implications of these findings for software security. We will also explore how to use AI tools effectively without sacrificing necessary secure coding skills.

Skill Degradation: An Empirical Analysis of 400+ AI‑Generated Security Fixes

This session explores the fundamentals of the MCP protocol, how to safely implement it into our applications with the .NET SDK and Semantic Kernel, plus key considerations for building a production-ready system – like auth, rate limits, and observability.

We'll cover the basics of setting up an MCP server in .NET and exposing executable functionality as Tools, enabling any client to communicate with our application. We'll understand how Semantic Kernel's familiar concepts of Plugins and Functions map over to the world of MCP.

Let's walk through integrating .NET's native Identity services to align with MCP’s authentication spec, enforce role-based permissions using Semantic Kernel Filters, and apply rate limiting middleware to keep systems reliable and secure.

Finally we will discuss approaches to running intelligent .NET applications in the wild with Azure API Management, open telemetry, and .NET Aspire on Azure Container Apps.

MCP with .NET: securely exposing your data to LLMs

We’ll cover real-world examples and lessons learned from within Octopus and discuss tooling tips to help you clean up your codebase without fear. If your product roadmap is filled with more "we should remove that someday" than you're comfortable admitting, this talk is for you.

Feature Flag-Driven Development… in Reverse

Just writing lots of unit tests for this kind of software isn't enough. Bad tests slow you down without catching meaningful bugs. Good tests are hard-working productivity multipliers.

In this session we'll explore a variety of testing techniques applied to a commercial database engine over a decade of active development, including model-based testing, fuzzing, and more. Borrowing methodologies from other industries, we'll see how testing complex software requires challenging our ideas of what a test is, and how testing fits into software development.

Industrial Strength Testing for Complex Software

We'll cover: the evolution from simple chatbot to a complex, dynamically evolving multi-agent system with MCP, hundreds of tools, and a diverse action space; which architectural pivots were necessary and why; practical challenges around context management, tool design, and reliability; and how to balance powerful agentic capabilities with security.
Beyond the technical, we'll explore the foundational mechanisms enterprises need now to properly leverage generative AI and autonomous agents in the years ahead. Attendees will leave with practical patterns for building multi-agent systems that survive contact with reality, and architectural principles that prevent you from getting left behind as the field rapidly evolves.

What Happens After the POC: Building Agentic Systems That Last

We’ll start from a simple front end and progressively assemble a fully authenticated API tier, event-driven communication with Event Grid, and a lightweight GitOps workflow that continuously deploys both infrastructure and services across multiple regions. The goal is to demonstrate clear, repeatable patterns that make serverless microservices easier to build, operate, and scale.

From Zero to Active-Active Multi-Region: Building Distributed Architecture with Azure Container Apps

We’ll explore patterns for generating machine-readable, structured outputs (JSON, key/value payloads, classifications, and entity records) with strong control, validation, and reliability. Using a real example, I’ll show how AI can identify existing entities to prevent duplicate creation and maintain data integrity across a system.

Attendees will learn practical techniques, prompt patterns, token management, and architectural approaches for turning Azure OpenAI into a predictable and safe backend service that can allow you to plug in Intelligence into any part of your system.

Designing AI-Powered Backends with Azure OpenAI: Reliable, Structured, and Production-Ready

Microservices

You'll see how large language models, functions, and open source tools fit together to bring to life an agent over the course of the talk. We'll build out an agent that starts simple and graduates to a multi-agent model, with different components managing and performing tasks.

You'll leave with a good idea of what you need to know to start building your own powerful agents.

Let's build an AI agent

We’ll walk through practical examples of how Hot Design transforms UI workflows using live editing, AI-generated layouts, and instant visual feedback. Then we’ll go deeper into how MCPs allow developers to scaffold whole apps that leverage themes, toolkit, extensions and other features of the Uno Platform.

Whether you're building your first Uno app or optimising a production-scale solution, you’ll leave understanding:

- How Uno Platform’s UI and runtime architecture enables native performance everywhere

- How Hot Design boosts iteration speed with real-time design-to-code workflows

- How MCPs enrich developer tooling with AI-driven context, automation, and smart refactoring

- Patterns for combining all three to build modern apps faster, cleaner, and smarter

If you want to glimpse the future of .NET app development—and start using it today—this session is for you.

Design Once, Run Everywhere: Building AI-Accelerated Cross-Platform Apps with the Uno Platform

In this fast-paced and high-energy talk, Lemon will introduce you to the latest and greatest features of modern CSS, and give you tips for using them to transform your projects—whether you’re giving an old site a fresh coat of paint or leveling up your current workflow. Get ready to expand your CSS toolkit and create beautiful, performant designs with confidence. This is the CSS you didn’t know you’ve been waiting for.

The CSS You Don’t Know About

Over the years, the concept has had many different names. From “observables” in KnockoutJS, to “refs” in VueJS, before Solid made “signals” popular. We’ve seen the carcinization of frontend frameworks in the pursuit of more seamless and fine-grained reactivity in our applications.

But what actually are Signals? Why do we keep coming back to them? And why is their potential adoption as a language standard such a big deal?

It's Time To Talk About Signals

You will see how modern agents combine tools, memory, and goal-oriented thinking to handle real tasks just like a human assistant would (only faster and without coffee breaks).
We will explore practical design patterns and show their evolution through plenty of real-world examples—starting with simple use cases and building up to fun, advanced, and collaborative scenarios.

✅ A clear sense of how agents go beyond just prompts
✅ Practical design patterns to kickstart your own agentic builds
✅ Awareness of the "gotchas" to avoid in real-world deployments
✅ The confidence (and code) to start building your own autonomous AI sidekicks

Whether you are building the next-gen assistant or just want to supercharge your apps—this workshop will put you on the fast track to building intelligent, agent-driven solutions.

From Bots to Brains: Patterns for Building Intelligent AI Agents

Throughout this session, we'll navigate through the intricacies of GitHub Actions, uncovering the potential of this automation powerhouse. You'll gain a deep understanding of advanced concepts and techniques, ensuring you can leverage GitHub Actions to its full extent for your projects. Here's what you'll learn:

- Optimizing GitHub Actions Runners: Master the art of selecting and optimizing runners for faster builds and deployments.
- Mastering YAML Workflow Syntax: From triggers to conditionals, learn to craft workflows that respond dynamically to the complexities of your project.
- Leveraging Advanced Features: Dive into job dependencies, matrix builds, and outputs for sophisticated workflow design.
- Securing with Environments and Secrets: Implement best practices for managing sensitive data and configuring secure deployment environments.
- Dynamic Deployments: Explore advanced deployment strategies to container registries and Azure, ensuring your application is delivered efficiently to the right platforms.

Enhanced with real-world examples, this session will equip you with the skills to implement advanced CI/CD workflows that streamline your development process, improve code quality, and accelerate deployment cycles. Whether you're looking to refine your existing CI/CD practices or expand your GitHub Actions expertise, this talk will provide valuable insights and techniques that are immediately applicable.

Real World CI/CD with GitHub Actions

This session covers the fundamentals (replication, consistency, partitions) and the tradeoffs nobody mentioned when they said "just scale horizontally." We'll look at real failure modes and practical patterns for building systems that handle chaos without dragging your app down with them.

Distributed Databases: What Could Possibly Go Wrong?data

This talk demonstrates how Fine-Grained Authorization (FGA) provides robust security for Retrieval-Augmented Generation (RAG) and agentic AI systems. Learn how to implement permission models that protect sensitive information while enabling AI to access only authorized data.

The talk explores implementations using OpenFGA and LangChain, showcasing how to build security directly into AI retrieval pipelines.

The presenters will provide real world case studies to discover how enterprises can prevent data leakage, implement multi-tenant isolation, and maintain audit trails while scaling to billions of access decisions.

Open source tools like OpenFGA and integration techniques with vector databases will be featured, along with best practices for real-world deployment. Thus join us to understand how one can maintain security without sacrificing performance or user experience in Agentic / Gen AI applications.

Fine-Grained Authorization: The Missing Piece in Agentic AI Security

Microsoft's new Agent Framework can reduce part of this complexity by abstracting away the underlying AI platform, allowing you to move between local and cloud with easy, but there's still a lot of additional overhead for all the other parts of the application to manage.

NDC { Sydney }

Agenda

10:20 - 11:20 (UTC+11)

Beyond the AI Hype: What's Real, What's Next

Richard Campbell

Ask More. Build Better. Burn Out Less- Real Talk on AI, Devs & GitHub Copilot

Michelle Sandford

The Wile E. Coyote approach to AI for backyard beast management

Todd Whitehead

Effortless Distributed Systems with Aspire

Jason Taylor

Designing technology for dirty gloves

Leanora Horne

11:40 - 12:40 (UTC+11)

The Azure AI Ecosystem for Real-World Enterprise ROI

Adam Stephensen

AI Agents Need Permission Slips

Heather Downing

Build your own Flight Tracker with Microsoft Agent Framework

Arafat Tehsin

Building the Ultimate Safety Net with Integration Tests

Jimmy Bogard

13:40 - 14:40 (UTC+11)

Building fun and creative messaging experiences on WhatsApp

Michelle “MishManners” Duke

.NET supply chain: Protecting against hidden threats

Tom van den Berg

10 tips to level up your ai-assisted coding

Aleksander Stensby

Meditations on Code As Art

David Whitney

Bulletproof - Designing for risk, resiliency and recoveryarchet

Andrew Cobb

15:00 - 16:00 (UTC+11)

Are LLMs good software engineers?

Anthony Shaw

Vibe Coding vs Context Engineering vs Spec-Driven Development

Ron Dagdag

Production-Grade LLM Architecture: Lessons from Processing 50 Million AI Requests

Vaishnavi Gudur

Messaging Patterns for Modern Software Solutions

Irina Dominte(Scurtu)

Your website does not need JavaScript

Amy Kapernick

16:20 - 17:20 (UTC+11)

Platform Engineering in the age of Generative AI

Will Velida

From Pair to Peer Programmer

Aaron Powell

Zero Trust in a SaaS and AI World

George Coldham

Get a Grip on your Telemetry using the OpenTelemetry Collector

Adam Gardner

Mobile accessibility: building accessible mobile sites and native apps for accessibility

Gian Wild

17:40 - 18:40 (UTC+11)

Old API, New Tricks: Add MCP to Existing .NET REST Endpoints

Jonathan "J." Tower

Spec-Driven Development: The Fast Track to 10x?

Jerry Nixon

AI Agents That Don’t Suck: How to Build Ones That Actually Drive Business Value

Robert Koch

Web APIs You Should Be Using in 2026: Unlocking Next-Level Web Experiences

Nhlanhla Lucky Nkosi

Platform Engineering vs DevOps

Dylan McCarthy