What if we had a magical way to find out what crazy things customers would try to do with our product… before we built it? Or before we launched it and put it in front of customers?

Anyone can learn to conduct qualitative usability testing, and you can make massive improvements to your products quickly and cheaply - if you test it right. To be clear - ‘user testing’ and ‘usability testing’ don’t mean the same thing.

In this talk, I’ll share the secrets that UX researchers use to take websites or software projects from good, to great - including how to do it, when to do it, and what tools you can use.

Join me and learn about the most cost effective UX research method at your disposal, and learn how to leverage it to build stuff better.

Talk (60 min)

Usability Testing is easier than you think

Testing

Inspired by the Standford's paper "Generative Agents: Interactive Simulacra of Human Behavior", this session explores how to build dynamic, AI-driven worlds using Apache Kafka, Apache Flink, and Apache Iceberg. We'll use a Large Language Model to power for conversation and agent decision-making, integrate Retrieval-Augmented Generation (RAG) for memory storage and retrieval, and use JavaScript to tie it all together. Along the way, we’ll examine different approaches for data processing, storage, and analysis.

By the end, you’ll see how data streaming and AI can work together to create lively, evolving virtual communities. Whether you’re into gaming, simulations, research or just exploring what’s possible, this session will give you ideas for building something amazing.

Bringing stories to life with AI, data streaming and generative agents

Architecture

Database

Gaming

However, getting started with graph databases can be a bit daunting if you have only ever worked with SQL server. Especially since most graph databases are so "far" away from your standard Microsoft domain.

But it really doesn't have to be. Graph databases, like neo4j, are awesome for a lot of scenarios. So, maybe shying away from using them because of the daunting task of getting started isn't the best solution. And honestly, getting started with neo4j as a .NET developer, isn't really that complicated.

In this talk, Chris Klug, a senior .NET developer with 25+ years of coding experience, will give you the introduction to neo4j that he wished somebody would have given to him years ago.

In just one hour, you will see how to get neo4j up and running on your computer. How you connect to it from your .NET application. And how you query it using the Cypher query language. Basically, everything you need to get started with ne04j. Or...everything you need, to go from zero to neo4j n00b...

neo4j for the relational .NET developer

.NET

In the last few years however, .NET finally caught up to the world of notebooks, in fact it might even be starting to overtake it. In this session we’ll examine how .NET notebooks work, how you can use them as part of your codebase, and how to build modern day ML pipelines in the cloud entirely in .NET!

Notebooks & .NET: A Marriage Made In Jupyter

Machine Learning

Work skills

Technical folks struggle to find the signal in the noise, and many business brains get swept away by the hype (and by Zuckerberg's aspirational announcements... thanks, Zuk). There are a few common archetypes that have emerged:

There's the AI-ate-my-job developer, the one-with-the-vibe junior, the embrace-ai-or-get-out CEO, the cathedral-building anti-slop senior, the vc-funding-focused entrepreneur, and the not-on-my-watch IT gatekeeper. There are also people who seem to be doing things very sensibly, but it's worth looking closely at the extremes - there are a lot of pitfalls to avoid, and wisdom to be adapted and adopted (#steal-like-an-engineer).

There are clear benefits to fast iteration and quick prototypes, and adopting LLM tools on complex brown-field projects often has mixed results. It's worth knowing about the (shifting) limitations of these tools, and the emerging best practices (which often look a lot like the best practices that emerged in the before-times). It is worthwhile to deeply consider safety-nets and guard-rails as we lean on these tools, we need to iterate on our approach to engineering rather than focusing on writing more code faster (LOC is a bad measure of productivity, we know this!)

The other thing we really need to think about and solve for as a community is: how do we play the long game? I'm pretty convinced that we will still need human software engineers for a long time to come, and good ones at that. Skill comes from experience, and the junior developer job market is a bit of a dog show.

How should junior devs prepare for the future? And how should organisations adapt so that they have people that they can rely on 5 years from now? I have some opinions...

Playing the long game

Ethics

People

Today, most AI designs emphasise SOPs, data quality, and evaluation, but sustainability is rarely considered. When it is, it tends to be incidental, the byproduct of choosing a cheaper or smaller model. Once deployed, very few applications measure their ongoing consumption footprint. Yet with the right monitoring in place, clear and powerful strategies emerge: caching repeated requests, nudging users toward greener prompts, scheduling tasks off-peak, or routing workloads to cleaner-energy regions.

In this session, we’ll design a Carbon Impact Agent layered on top of a support agent. This multi-agent system tracks, analyses, and recommends approaches to actively reduce the environmental footprint of AI applications. We will explore:
•	What to measure: compute usage, energy mix, task-level telemetry, carbon intensity by region.
•	How to design the system: agent orchestration for monitoring, calculation, analytics, and recommendations.
•	What insights emerge: per-task carbon costs, workflow-level emissions, and team-level benchmarks.
•	How to act on them: UI nudges, greener deployment choices, prompt optimisation, and workload scheduling.

By the end, you’ll see how we can build AI systems that are not only impactful, but also sustainable by design, embedding environmental accountability into the fabric of intelligent applications.


Building a Carbon Impact Agent: Boosting ROI with Sustainable AI in Design, Monitoring & Remediation

Cloud

In this session, we will go beyond the basics to explore a few patterns that address some of the toughest challenges in building distributed systems. We will discuss how the Outbox pattern prevents data loss in the face of crashes, how sagas coordinate long-running workflows without distributed transactions, how scatter-gather accelerates workloads through parallelism, and how competing consumers keep systems elastic under heavy load. We will also examine routing topologies and operational safeguards like retries, dead-letter queues, and back pressure.

By the end of the session, you will have gained knowledge about when and how to apply these patterns to take your distributed system up a level with increased data consistency, resiliency, reliability and fault tolerance.

Beyond Pub/Sub - Advanced Messaging Patterns

Existing approaches, such as Trusted Research Environments, address these concerns _to an extent_. But they still require researchers to abide by an honour system when it comes to privacy, and the precise research methodologies and code used for a particular study aren't captured and made public. Enter OpenSAFELY.

Born during early COVID, OpenSAFELY is both a sensitive data research philosophy, and the set of tools built to enable researchers to act upon that philosophy. At the Bennett Institute in Oxford, we've been building the next generation of healthcare data research software, which allows open, reproducible and secure usage of data provided by GPs in the UK.

We've got our own domain-specific query language, our own output checking and file release system, and our own network of researchers and healthcare professionals who are helping us build the right tools for the job. We've also got a lot of problems to solve. Come along to this talk to learn about them, our story, and where we hope to go next.

OpenSAFELY: a quiet revolution in healthcare data

Security

Big Data

As someone with a background in resiliency engineering, I’ve seen firsthand how a single mismanaged configuration change can take down an entire system. This session is about preventing that. We’ll cover how configuration works under the hood, and more importantly, how to test configuration changes safely so you can deploy with confidence and avoid costly surprises.
We’ll also dive into practical, battle-tested strategies for modernizing configuration management in your .NET projects while boosting security, scalability, and uptime.

Strongly Typed Configuration: Improve readability and catch errors early.
Configuration Providers: Leverage JSON, XML, INI, environment variables, Azure App Config, and Key Vault effectively.
Dependency Injection Integration: Modularize and simplify your configuration logic.
Options Pattern: Enable flexible, scalable settings across your app.
Containerized Applications: Securely manage secrets and environment-specific configs in Docker and Kubernetes.
Deployment Strategies: Inject configurations safely using Azure DevOps Pipelines, GitHub Actions, and Kubernetes manifests.
.NET Aspire Configuration: Streamline service-oriented setups in distributed systems.

Whether you're building cloud-native apps or modernizing legacy systems, this session will equip you with the tools and mindset to make configuration a strength, not a liability.

Modern .NET Configuration Practices

DevOps

Tools

What is the common denominator in all these attacks? Social engineering. It is one of the most subtle yet potent set of techniques, often used by individuals or groups to exploit human weaknesses and gain access to systems and sensitive data. No organization or group is immune to this form of attack.

Working in an IT company places us in the crossfire. On one hand, we have access to not only business data but also information that could be exploited to attack our organization. On the other hand, IT professionals themselves are well-positioned, making themselves potential targets of attacks.

While it’s almost impossible to be fully protected against social engineering, it is vital to understand the possible vectors of attack. Various methods and psychological tricks can be used to compromise our security or that of our organization.

So, let’s buckle up and take a small step toward becoming more secure.

Social Engineering: Hacking Humans

Soft Skills

The good news is that we don’t have to wait for systemic change. There are things you can do on Monday when you’re back at work to start redressing the balance. You might assume this means writing code or providing sponsorship, and it might, but we’ll also explore other ways to help: concrete actions that don’t require budget approval, practices that strengthen and support the open-source projects you rely on while actually benefiting you and your team.

Don’t wait for someone else to fix it - learn how to make a real difference, one contribution at a time.

Open Source is Broken, and it's Your Fault

In this talk, Eric will show how these features can be applied in real projects through live-coding examples, with the goal of inspiring you to start using them today. We’ll also explore some bleeding-edge CSS innovations and see how they combine with these new HTML capabilities to create cleaner, more elegant, and more flexible user interfaces.

The New Frontend Toolkit: Popover API, Dialog, and Next-Gen CSS

JavaScript

You still need your software to be reliable, performant and to solve a problem for your users. And regardless of what 'style' of system your building, there are some unchanging patterns that are always going to help you.

In this talk, you'll learn all about these unchanging patterns of systems design. This isn't an escoteric talk. This is a talk that is going to give you practical patterns of system design that you can take away and use in your business. Whether your working on a 20 year old monolith, working on the cutting edge of agentic AI, or whatever hype train comes next in software development. You'll have the skills to ensure your systems are always reliable, performant and solve real problems.

Immutable Patterns of System Design; From Monolith to Agentic AI

Microservices

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

In this talk, we'll run through some practical UX design tips that make a difference without needing a design degree. We’ll cover keeping interfaces clear, reducing cognitive load, using consistent design patterns, giving users meaningful feedback, using inclusive plain language and more.

Through helpful examples, you’ll see how small improvements can make a big difference in how users experience your product. You’ll leave with actionable knowledge to bring to your next project, helping to reduce frustration for your users, and maybe preventing a few support tickets on the way.

Think like a user: practical UX design tips for developers

Not quite. This latest wave of tools brings as many cons as it does pros - and that’s exactly why the real question isn’t if we should use them, but how. How do we leverage AI coding assistants in ways that actually make us better engineers? Better problem solvers?

In this talk, I’ll share how we’ve been experimenting with AI inside the Umbraco CMS development team over the past year. Think mandatory Copilot-assisted sprints where devs are encouraged to ask “why” and “what if” instead of just “give me code.” I’ll walk through the practices that have turned coding assistants into learning assistants - and explain why AI can be such a powerful, low-stakes place to practice, explore, and even make mistakes.

Learning not leaning: How developers can Accelerate their Learning with AI

But CSS isn't just about making websites look pretty. It's one of the fundamental building blocks of the open web, and it's continuously evolving. Modern CSS has variables, grids, flexboxes, animations, view transitions... when it comes to layout, accessibility, interaction and validation, CSS can do all kinds of things you thought you could only do with JavaScript.

Dylan Beattie's been building web applications since before CSS was invented - yes, really - and in this session, he'll take you on a whirlwind tour of some of the weird and wonderful things you can do in 2026 using semantic HTML, a generous sprinkling of CSS, and absolutely no JavaScript.

OK, maybe a tiny bit of JavaScript. But absolutely no React.

Do It With Style: Rethinking CSS

This is not a new problem, but it's more relevant than ever. Generative AI has dropped the barrier to entry dramatically, and it's never been easier to produce probably-working software with a single prompt.
So how do we avoid sleepwalking into brittle, opaque systems that only appear correct? When is "good enough" actually good enough? And when the result always looks right, how do we know when to step in?

Keynote: The dangers of probably-working software

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, Oliver demonstrates how C# Pattern Matching works, why this evolution of the old imperative "switch" is so important, and how the structure of C# code can be generally different from the past on the basis of this feature. As a conclusion, he proves that C# can now pattern match with the best, by porting some F# code as well as a complex Haskell algorithm.

Advanced Pattern Matching in C#

Functional Programming

Programming Languages

Join me in this lively, hands-on session as we demystify MCP and learn to build an intelligent context-aware MCP server from scratch.

Whether you're new to MCP or a seasoned AI enthusiast, you'll leave with everything you need to make your apps smarter, more intuitive, and ready for the AI-driven world. Let's bring AI to life, the .NET way!

.NET Meets MCP:  Build Your Own AI-Powered Service with C#

This session dives into how we used OpenLit, a lightweight CNCF tool for observing LLM and agent-based workloads. We’ll explore how we tracked & debugged prompt chains across orchestration layers, visualize token usage and latency distributions at each step of an AI workflow, monitor agent reasoning patterns and build performance dashboards that go beyond CPU and memory into model selection, response variability, and input size trends.

Whether you're building RAG systems, multi-step AI agents, or just trying to figure out why your chatbot is always apologizing, this talk shows how OpenLit brings real observability into your AI stack — without needing a PhD in tracing or LLM internals.

Prompt Failures and Latency Spikes: Observability for AI

At the same time, Java is mature, stable, backwards compatible, and runs just about anywhere. The community is pretty cool too!

This talk takes a light-hearted, warts-and-all look at some of the more frustrating aspects of Java, how the language has evolved over time and where it's headed next. A discussion on the consequences of language design decisions that can be enjoyed by programmers of all languages, but especially by C# users.

Expect to laugh, and yes maybe even cry, as we try to make sense of the beast that puts food on the table for millions of developers worldwide

We will cover:
- Pivotal early design decisions such as checked exceptions and generics and how we still pay for those decisions today (that is, why do lambdas suck so bad?)
- How Java has influenced the development of other programming languages, and vice versa
- Most controversial language design decisions of late and the associated fallouts

Java developers will leave this session feeling validated and with a renewed love for the language that keeps a large chunk of the world running. C# developers will leave this session with a renewed level of smugness.

Java Sucks (So C# Didn't Have To)

In this talk, we’ll dive deep into the emerging discipline of LLM observability: what to track, how to track it, and why it matters. We'll compare purpose-built tools like LangFuse, LangSmith, and AgentOps with general observability frameworks like OpenTelemetry, and show how new GenAI semantic conventions make structured tracing possible at scale.

How to Instrument, Govern, and Debug Agents Before They Go Rogue

It’s not because we don’t want to develop accessible websites and applications.
But we often lack knowledge and perspective. We build based on our own experience because that’s what we know. In this talk, you’ll get to experience how our applications work for someone with a screen reader, low vision, or limited motor control, and feel firsthand the challenges they face.

The talk combines knowledge, practice, and lived experience to raise your awareness of accessibility on the web and how small changes can make a huge difference.

You'll see the most common mistakes in action, who they affect, and how to fix them. So come experience the world through someone else's senses, and learn how to be a more accessible developer.

Let's break some WCAG rules

We’ll cover practical techniques to uncover the reasons behind slow queries and fix them. Along the way, we’ll look at new features and insights that make performance tuning more straightforward.

Finding Bottlenecks with Wait Statistics: Learn how to spot the root cause of delays in your queries.

Session-Level Wait Stats: See how tracking waits at the session level can provide valuable insights.

Understanding CPU Waits: Break down CPU-related waits and what they mean for your server’s performance.

Fixing Disk I/O Delays: Understand how to reduce the impact of disk waits on your queries.

Using Wait Stats to Tune Queries: Apply what you learn to improve indexes, joins, and query plans.

This session is for anyone who wants to improve query performance and make their SQL Server run as efficiently as possible. Join us to learn simple, actionable steps that you can start using right away.

"Run Query Run" - A Fresh Look at SQL Wait Stats

In this session I'll show how Dapr, the Distributed Application Runtime, a graduated CNCF project, helps to build and run agentic systems reliably using the durable execution principle that is provided by Dapr Workflow. I'll demonstrate various patterns in .NET for building effective agents such as Prompt Chaining, Routing, Parallelization, Orchestrator-Workers and Evaluator-Optimizer. I'll also use the new LLM Conversation API in Dapr to interact with different LLM providers.

By the end of the session, you'll have a good understanding of how to build agentic systems with Dapr, and when to apply the different agentic patterns.

Reliable Agentic Systems need Durable Execution 🤖

We'll start with a focused deep dive into Playwright itself: modern locators, resilient test patterns, parallelization, and debugging features that help teams test faster and smarter. Then we'll explore how to connect the Playwright MCP Server to an LLM, allowing you to:
- Automatically generate meaningful tests from user flows or requirements
- Identify gaps in test coverage
- Debug and repair failing or flaky tests
- Interact with your running application via natural language

This talk is ideal for developers, testers, and QA engineers who want to level up their automation stack, reduce test maintenance, and bring AI into real-world testing workflows. Expect live demos and practical strategies you can take back to your team.

Supercharged Testing: AI-Powered Workflows with Playwright + MCP

We are told that as long as we keep a "human in the loop" it's all good. At one level, this advice seems sound — and even obvious — but it's as vague as it is unhelpful. What does it actually mean to be the human in the loop? It's clearly more than just LGTMing any generated code, but what skills and mindset are needed to make AI use effective? What does it take to be the driver, not the road?

This isn't a talk about tools, MCP servers or better prompts: it's a talk about understanding what productivity is and is not, the difference between value demand and failure demand, that typing is not the bottleneck in software development, that design and coding skills are important, that solutioneering the problem domain is not enough, that testing is not optional, that being able to generate and explore options has more long-term value than committing first-guess code.

Being the Human in the Loop

This session will give you some tools to help you understand how to sneak in some UX... or at least make some sincere attempts at SWAG user flows, experiences, and set ups. No, it's not ideal, but these half-assed techniques will help prevent your company from showing their whole ass with a bad experience.

How to do half-assed UX

Because LLM traffic is a streaming, state-heavy beast that breaks every REST assumption: requests aren’t stateless, payloads snowball with context, and GPU memory melts under token floods. We’ll map the three checkpoints where most projects stall—context explosion, batch backfires, cache chaos—and show how LLM-D’s open-source sharding plus a hybrid NVIDIA/AMD node pool turns each choke point into a green light. You’ll see live before-and-after dashboards, get a YAML ladder you can drop into any cluster, and learn a back-of-the-napkin formula to keep cost per 1 000 tokens under control.

Stop Treating LLMs Like REST APIs

Blazor Server requires an approach that is totally different than when using Blazor WebAssembly. And if you use a mix of the two rendering modes things can get very complicated.

This session is here to help you out. We'll cover the right way to do cookie and OpenID Connect authentication for both modes as well as the mix mode.

At the end of the session you'll be able to confidently secure any Blazor application.

Blazor Authentication? Hold My Beer!

In 1978, Myers noted that while the benefits of modularity were widely agreed upon, there was little discussion about how to write modular code. Almost fifty years later, many engineers continue to struggle with using modules in their code. And yet the pressure to write modular code, to support augmented coding, InnerSource, and testing rises.

In this talk, we look at how to write modular code.
- We will start by defining modules. We will provide some examples in C# of modules (assemblies) and examine language features that control visibility.
- Next, we will look at how modules can help us in software development. We will discuss information hiding and examine coupling.
- Then we will look at how we slice our software estate into modules. We will discuss how David Parnas's observations can benefit us. We will provide some examples of how we slice up an estate.
- We will step into test-driven development, so we can understand the idea that the module boundary is where we should write our tests.
- Finally, we will look at how we use modules with some architectural styles: CQRS, ports & adapters, vertical slice architecture, and flow-based programming. Again, we will provide examples in C#

We will wrap up with an overview of how these ideas relate to modular architecture styles, such as modular monoliths and macroservices

Modular Code with Examples in C#

In this session, we’ll dive into how continual learning techniques, inspired by human adaptability, help AI models improve diagnostic accuracy, minimize false positives, and handle evolving data in medical settings. We’ll discuss challenges like catastrophic forgetting, maintaining model performance in dynamic environments, and practical strategies that developers can apply to other domains. Gain hands-on insights into building resilient AI systems that evolve and adapt to new data, ensuring long-term reliability in critical applications.

Building AI That Learns and Adapts: A Case Study in MRI Diagnostics

The reality is that to build reliable agents, we need to use all tools in our context toolbox to ensure they provide accurate responses in the correct format.

Let's dive into the world of context engineering, and understand the elements of context that we can tune and tweak to build more reliable AI agents and associated systems.

Crafting Intelligent Agents with Context Engineering

Vector-based searches can be used in many other scenarios besides text. If you can embed, convert data items to numbers, you can search for similar items, and this includes images, sounds, video and even music.

In this demo-intensive session Alan will explore the concepts of embedding and nearest-neighbor search. The analysis and embedding of data will be explained, along with techniques to vectorize text, images and music. He will then demonstrate how vector-based indexes can be created in Azure AI Search using both the Azure portal and programmatically. Alan will show how text and image embedding can be leveraged, and then show the techniques used to create an index using the beat signatures in music. The search index can then be used to find similar sounding beat patterns in songs, allowing code to mix tracks seamlessly, creating a stunning AI-augmented audio experience.

Well, that’s the theory, can this work in practice? Join this session and learn about the power and versatility of vector-based searching.

Drop the Bass with Embedding and Vectors in Azure AI Search

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

Almost all the code we interact with was written by other humans, and they wrote the code that way for a reason. If we take the time to understand the context and the story behind a piece of code, we can infer a lot about what those humans meant to achieve, what their culture was like, and what they valued… in other words, we need to become an archaeologist!

Let’s work to build a better understanding of the code we didn’t write, and of who wrote it and why. Using the tools of psychology you can learn what’s happening to your brain when you’re reading someone else’s code, and then learn how you can make understanding it take less cognitive effort. Using the tools of archaeology you can learn how to use your development environment to find the real stories of the people that wrote it, and how that story can protect you from making the same mistakes they did. The ability to read and examine others’ code is essential - you can’t change or improve software without understanding what it already does, so come learn how to do it with skill and compassion!

Digging into the Matrix: Practicing Code Archaeology

This talk explores the practical aspects of performance optimisation in .NET. We’ll look at proven strategies for monitoring, identifying, analysing, and iteratively improving applications. You’ll learn how to approach the performance lifecycle, from monitoring applications in production and pinpointing the best areas to optimise, to investing valuable engineering time where it counts most.

Through a worked example, we’ll follow a feature through the optimisation cycle. We’ll profile the application, design benchmarks, theorise improvements, and iteratively refine the implementation to reduce allocations and execution time, while balancing performance gains with code readability and maintainability.

Along the way, you’ll learn how to use tools like dotTrace, dotMemory, and BenchmarkDotNet to target areas for improvement and validate gains. We’ll discuss common optimisation opportunities, from smarter memory usage and fewer allocations to more efficient execution flow.

By the end of this session, you’ll leave with practical techniques to write faster, more efficient .NET code, along with the judgment to know when optimisation is worth the trade-off, and when it’s not.

Application Performance Optimisation in Practice

There's an old wiki page, shell scripts in a random repository, and repository Readme's referencing frameworks years out of date. The excitement of starting a new project soon turns to dread as the "Time-to-Login-Screen" stretches to days.

Enter Aspire - a new set of tooling from the .NET team that supercharges local development. In this talk, I'll walk through the basic building blocks and technologies behind Aspire. I'll cover examples of development dependencies and local insights and debugging through OpenTelemetry.

Finally, I walk through migrating a complex, multi-application, multi-framework, and multi-dependency example from Docker Compose and other tools to Aspire to provide one seamless experience for local development and debugging.

Supercharging Local Development with Aspire

Keeping them properly configured, updated and healthy involves manual steps per host. Without a central control plane, it becomes error-prone and hard to scale, leading to config drift across fleets.

Enter OpAMP (Open Agent Management Protocol), which enables each agent to connect to a central server so it can “phone home” and receive instructions with capabilities like remote configs, health monitoring, agent telemetry and credential management, drastically simplifying Agent lifecycle. OpAMP is also vendor-agnostic, meaning the Server can remotely monitor & manage a fleet of different vendor Agents as long as they implement the OpAMP specification. In this talk, we’ll discuss the motivation behind OpAMP, the communication model, and how to enable it in the Otel Collector using the OpAMP Extension & Supervisor components.

OpenTelemetry At Scale 101: Intro to OpAMP

In 2025 it's easy to think of "yet another chatbot" when you think about AI, but gaming has long been at the forefront of artificial intelligence and content generation.

From the earliest applications of randomisation in roguelikes, to procedurally generated universes in games like Elite and No Mans Sky, players are used to algorithmic content adding challenge, variety and fun to their games.

In this talk we experiment with using hybrid Procedural Generation and modern transformer models to create narrative storytelling for games that not only plays well, but still feels intentional, human, and engaging.

We'll cover techniques for content generation that both use and constrain our models to make worlds that make sense - that you could shift to other non-gaming mediums.

RolePl-AI

As models advance seemingly overnight, our ability to interpret their decisions struggles to keep pace. The field of Interpretability isn’t just about explaining outputs or offering post-hoc reasoning— it’s about uncovering how these models actually process and represent information.

This talk explores the latest research shaping AI Interpretability, from Anthropic’s 2024 work on mechanistic interpretability and monosemanticity scaling, to methodologies that have historically aimed at explaining models but fall short for today’s LLMs. We’ll clarify the distinction between explainability and interpretability, their respective use cases, and the current toolkit for understanding black-box models. Along the way, we’ll debunk common myths (like the tendency to anthropomorphize LLMs), and discuss why interpretable AI is essential for both reliability and trust.

For engineers at all levels– whether integrating LLMs into applications or advancing AI research– interpretability is no longer optional. It’s necessary for debugging unexpected model behavior, improving efficiency, and ensuring AI systems remain adaptable and aligned with human goals. If we don’t keep up, we risk being outpaced by models we barely understand, yet still utilize. Attendees will leave with a clearer framework for assessing LLM behavior and practical strategies for applying interpretability techniques to real-world AI systems.

Between the Layers– Interpreting Large Language Models

GenAI

As a coach, I feel like there are a bunch of things that would make many tech careers go a whole lot smoother, if only we could have known them from the start. It's almost as if there should have been a course at some point, but the content didn't make the cut when they were grooming the curriculum. So in this talk, I'm going to rectify that as much as I can.

I'm going to pack this session with advice I would have loved as my earlier self. We'll talk about reasoning about technology, heuristics for making difficult choices, and how to navigate career growth in an industry that wants to keep you in a neat little box. Frameworks and languages come and go, but your core skills will remain relevant, even in the age of AI. And with things like choosing employers, or learning new skills, we don't get an infinite amount of attempts, so we better try to get it right.

Attend this session, so that when your next career decision comes around, you will have a better mental model to think about what you should do.

If only I had known ...

In this session, we'll explore and demystify this powerful feature that lets you inspect your codebase and generate new C# source files during compilation.

You'll learn how to create source generators from the ground up, including working with the Roslyn compiler API to analyze syntax trees, semantic models, and symbols. Don't worry, it's actually easier than it sounds! We'll explore practical techniques for traversing your codebase, filtering syntax nodes, and generating precise, context-aware code that integrates seamlessly with your existing projects.

Through hands-on examples, we'll implement source generators that solve real-world problems. We'll cover examples like creating strongly typed entity IDs to prevent primitive obsession, generating boilerplate code, auto-implementing interfaces, building compile-time helpers and more.

This session is designed for intermediate to advanced .NET developers, team leads and architects looking to improve code maintainability, as well as anyone interested in meta-programming and code generation.

After this session, attendees will gain a thorough understanding of source generator architecture and lifecycle, along with practical knowledge of working with the Roslyn API for code analysis. They'll learn essential techniques for debugging and testing source generators, good practices for implementing them in production projects, and acquire a toolkit of ready-to-use patterns for some common source generation scenarios.

Code that writes code - .NET Source generators

In this session, we’ll explore HTMX and ASP.NET Razor Pages, a dynamic duo that lets you build modern, interactive web applications without the bloat of a JavaScript-heavy frontend.

In this session you will learn:
- How HTMX enhances Razor Pages with minimal effort
- Making AJAX requests, swaps, and transitions without writing JavaScript
- Real-world example of cleaner, simpler, and more maintainable web application

HTMX & ASP.NET Razor Pages – Web development without the JavaScript pains

In this session, we’ll explore the different options available to .NET developers when building AI-enabled applications. We’ll start with direct model access using APIs and SDKs, move on to using managed services such as Azure AI Services, and then look at higher-level composition approaches using libraries like Semantic Kernel.

Finally, we’ll look at agent-based frameworks and how they build on these foundations to make it easy to add agents to your applications.

This session is aimed at understanding the trade-offs between these options and when each one makes sense in a real-world application. All examples are demonstrated using a Blazor application, but the concepts apply to any .NET platform.

You’ll leave with a clear overview of the AI integration options available in .NET, along with practical guidance to choose the right level of abstraction for your application.

From Model Integration to Agents: Building Intelligent .NET Applications

In this talk, I'll explore the phenomenon of the progressive collapse. I'll explore how it manifests itself in the built environment, drawing on real world examples of structural failures in buildings. Then I'll explore examples of progressive collapse in our digital systems, and show how we can take the lessons from civil engineering and apply them to our own digital systems. As you'll see, there are a number of practical things you can take to stop a chain reaction.

Progressive Collapse

First part of this talk will focus on the challenges of securing our software supply chain, particularly on NuGet package security and the hidden threats lurking within all of our used dependencies. We'll examine how traditional approaches fall short when it comes to identifying planted malware, risky APIs, and other security vulnerabilities embedded deep within the packages we trust.

While tools like the OpenSSF Security Scorecard provide valuable metrics, they only scratch the surface of what's needed for comprehensive supply chain security. What if we could go deeper? What if we had detailed analysis of NuGet package contents, automated detection of risky API usage?

Join me as I introduce Fennec Labs, a community-focused OSS project designed to help out with how we analyze and secure our software dependencies. I'll demonstrate how this tool enables developers to collaboratively identify security risks, share insights, and make more informed decisions about the NuGet packages they integrate into their applications.

Whether you're a security-conscious developer, a DevOps engineer, or someone responsible for maintaining your organization's software supply chain, this session will provide practical insights and tools to help you level up your security game and protect your applications from supply chain attacks.

NDC { London }

Agenda

09:00 - 10:00 (UTC±00)

Keynote: The dangers of probably-working software

Damian Brady

10:20 - 11:20 (UTC±00)

Beyond Pub/Sub - Advanced Messaging Patterns

Poornima Nayar

.NET Meets MCP: Build Your Own AI-Powered Service with C#

Gerald Versluis

Building a Carbon Impact Agent: Boosting ROI with Sustainable AI in Design, Monitoring & Remediation

Darshna Shah

Let's break some WCAG rules

Elise Kristiansen

"Run Query Run" - A Fresh Look at SQL Wait Stats

Pinal Dave

11:40 - 12:40 (UTC±00)

Do It With Style: Rethinking CSS

Dylan Beattie

Playing the long game

Sheena O'Connell

Social Engineering: Hacking Humans

Pawel Sucholbiak

Advanced Pattern Matching in C#

Oliver Sturm

13:40 - 14:40 (UTC±00)

Being the Human in the Loop

Kevlin Henney

Supercharged Testing: AI-Powered Workflows with Playwright + MCP

Debbie O'Brien

10 Tips To Level Up Your AI-Assisted Coding

Aleksander Stensby

The New Frontend Toolkit: Popover API, Dialog, and Next-Gen CSS

Eric Veliyulin

neo4j for the relational .NET developer

Chris Klug

15:00 - 16:00 (UTC±00)

Messaging Patterns for Modern Software Solutions

Irina Dominte(Scurtu)

Learning not leaning: How developers can Accelerate their Learning with AI

Emma Burstow

Usability Testing is easier than you think

Jo Minney

Modern .NET Configuration Practices

Chris Ayers

16:20 - 17:20 (UTC±00)

Java Sucks (So C# Didn't Have To)

Adele Carpenter

Bringing stories to life with AI, data streaming and generative agents

Olena Kutsenko

Open Source is Broken, and it's Your Fault

Lotte Pitcher

Prompt Failures and Latency Spikes: Observability for AI

Prerit Munjal

Notebooks & .NET: A Marriage Made In Jupyter

Alexander Hall

17:40 - 18:40 (UTC±00)

Immutable Patterns of System Design; From Monolith to Agentic AI

James Eastham

How to Instrument, Govern, and Debug Agents Before They Go Rogue

Carl Lapierre

OpenSAFELY: a quiet revolution in healthcare data

Eli Holderness

Think like a user: practical UX design tips for developers

Lex Lofthouse

Reliable Agentic Systems need Durable Execution 🤖

Marc Duiker