What if that's the wrong question? What if the real question isn't what you learn, but how you learn it - and how to get started? Let's talk about motivation. Let's talk about all the wonderful tools and systems out there that make it easier than it's ever been to start exploring new languages and platforms, from Copilot and ChatGPT, to cloud IDEs and IOT microcontrollers. Let's talk about the all-important difference between programs and products; about the challenges of going from "hey, it works on my machine" to something customers will actually pay for. We’ll find out why open source projects succeed where well-funded corporate projects fail, why are there so many JavaScript frameworks – and why you’re still sitting up writing code at 3am, even though you know you have work in the morning.

Talk (60 min)

Machines, Learning, and Machine Learning

Machine Learning

Soft Skills

Tooling

People

For many of us, staying productive isn’t just hard, it feels like trying to swim against a tidal wave while someone keeps throwing beach balls at your head.

As a software developer with ADHD, I’ve spent years experimenting with tools, habits, and workflows to keep myself focused — not in theory, but in the real world of deadlines, code reviews, teams messages, and the endless notifications we all get these days.

This talk breaks down the classic focus challenges developers face: spending too much time on our phones, struggling to start large tasks that suddenly feel enormous, procrastinating until stress takes over, losing track of what we were supposed to be doing, and drifting through meetings without absorbing a single word. Each section shares practical strategies I’ve personally tested — from structuring work sessions and managing dopamine distractions to locking my phone in a box and using productivity apps to manage my tasks.

Whether you have ADHD or just feel overwhelmed by the chaos of modern work, you’ll walk away with practical tactics you can apply immediately to build clarity, momentum, and sustainable productivity in a fragmented world – not just at work, but in every aspect of life.

If you’ve ever opened 326587 tabs, stared at a half-written function, and wondered why you’re reorganizing your desk instead of coding… this talk is for you.

Focus in a Fragmented World: A Developer’s Guide to Staying Productive

It’s a powerful way to decouple services and enable extensibility—but on its own, pub/sub doesn’t solve many of the problems that show up in real distributed systems, such as data loss, broken workflows, or systems that struggle under load.

In this session, we’ll go beyond basic pub/sub to explore a set of proven messaging patterns used in production. We’ll look at how the Outbox pattern prevents message loss during failures, how sagas coordinate long-running workflows without distributed transactions, how scatter-gather accelerates work through parallelism, and how competing consumers enable elastic throughput when demand spikes. Along the way, we’ll also examine essential operational safeguards such as retries, dead-letter queues, back pressure, and idempotency.

By the end of the talk, you’ll understand when and how to apply these patterns to build systems that are not just decoupled, but resilient, scalable, and designed to handle failure gracefully from day one.

Beyond Pub/Sub - Advanced Messaging Patterns

.NET

Architecture

Join Richard Campbell as he explores the challenges and potential of putting data centers into orbit. The balance of cost, performance, latency, power, cooling, and reliability makes for a difficult mix - but the potential for the future is significant!

Above the Cloud: Building Data Centers in Space

Cloud

Space

This talk explores how to make your REST APIs understandable, reliable, and useful not only to humans, but also to machines that "learn" from documentation and responses.

You will see how to structure endpoints for discoverability, add metadata that helps AI reason about your API, and protect your systems from unpredictable agent behavior. We will explore topics like security, error-handling, hypermedia-driven APIs, and monitoring for reliability at scale. By the end, you will understand how to make your APIs ready for an AI-driven world - where your next client might not be a person.

Designing REST APIs for the age of AI agents

JavaScript

In this session, we'll explore how modern AI models can identify what you're typing just from the sound of your keyboard. Using a dataset of recorded keystrokes and an open source sound classification pipeline, we'll walk through building a model that can recover text with startling accuracy. You'll see firsthand how a few lines of Python and a trained network can turn your laptop into an acoustic fingerprint.

But this talk isn't about enabling surveillance... it's about understanding it to fight back. We'll unpack why uniform keyboard layouts and consistent typing styles make these attacks so effective, then explore real countermeasures: signal masking, password entropy, and environmental noise defenses. You'll leave with a practical understanding of how these attacks work, how to reproduce them for research or awareness, and how to harden your systems (and yourself) against them.

The Sound of Your Secrets: Teaching Your Model to Spy, So You Can Learn to Defend

Security

Big Data

Design

GenAI

Let’s look at OWASP LLM05 and how "Improper Output Handling" impacts the security of Vue components. Therfore, let's discuss examples where safe inputs can trick models, causing vulnerabilities like XSS and injection attacks. By the end, you’ll learn how to be "professionally pessimistic" for AI. You’ll learn how to sanitize LLM data, safely render Markdown, and manage AI-generated content. Join my session to approach technology with caution, I look forward to exploring this with you!

Dangerous Reactivity: Why AI Output Is the New XSS

Everyone wants to demonstrate that they are on board the AI train choo-chooing towards the future, that they're not getting left behind. The rhetoric will have us act, not think - there is no time! Is that true? It's a paradox that we are supposed to meet artificial intelligence with our own intelligence turned off. If it's true that AI will "change everything", surely we need every ounce of human intelligence - as well as compassion, wisdom and humanity - we can muster! And what if it turns out to be false? At what cost do we participate in this dance?

The AI puppet dance

Ethics

Even with linters, tests, and security scans in place, you can still ship or deploy compromised software if you can’t prove what was built, how it was built, and that it hasn’t been tampered with.

In this session, we’ll explore how provenance and attestation turn “trust me” into verifiable evidence. Using the SLSA framework as a foundation, you’ll see how producers can generate cryptographically signed build provenance using GitHub Actions and how consumers can verify artifacts before they are allowed into production.

Beyond tooling, we’ll look at how verification fits into real CI/CD workflows, how to enforce trust as a deployment gate, and how to make software supply chain security an actionable, enforceable practice.

Live demos will show practical steps you can apply immediately in your own pipelines.

From "Trust Me" to "Verify Me"

DevOps

Continuous Delivery

Docker

Let's explore what's new in C# 9, 10, 11, 12, 13 and 14!

We will look at how the language has changed and why these changes to the language will make us better C# developers, with less bugs in our code.

We will cover the following features:
- Nullable reference types
- Pattern Matching in C# 8 => C# 14
- Init only & new()
- Record types
- Primary constructors
- Collection expressions
- Extension members

We'll also take a look at what's new in C# 14!

Let’s catch up with C#! Exciting new features in C# 9 to C# 14!

This talk explores the systemic bias in AI models caused by uneven global data representation, and how it impacts developing nations in areas like healthcare, finance, and governance. We’ll examine real-world consequences of this imbalance, discuss why diversity in datasets matters for security and fairness, and propose strategies for building inclusive AI that serves the entire world, not just the Global North.

Global Bias in AI: When Western Data Shapes the World

AI introduces unique vulnerabilities that require new defensive approaches. This session shares practical strategies for securing AI applications in production, based on real-world implementation experience.

- New attack vectors that AI introduces: What makes AI security different from traditional application security
- Securing AI at every layer: Input validation, model protection, output sanitization, and monitoring
- When existing security tools fall short: Understanding the gaps in traditional defenses
- Building security into your AI workflow: Practical controls for development, deployment, and operations

Whether you're adding your first AI feature or scaling AI across your organization, you'll leave with actionable security practices for AI-powered systems.

AI Security in Practice: Protecting Your AI-Powered Applications

The last few years have seen widespread adoption of Event-Driven Architecture, supported by DDD practices such as event storming. But what does that orange sticky note become when we start implementing our design? Common implementation choices include event sourcing, streaming platforms like Kafka and queuing systems like RabbitMQ.

Unfortunately not every orange sticky note has the same operational needs, and many teams remain confused about the differences between these options, resulting in the selection of the wrong paradigm for their needs.

This can lead to unnecessary complexity & operational challenges such as head of line blocking, dropped messages, challenges dealing with failed messages, difficulty with adaptive scaling and inadvertently increasing coupling between services.

In this talk we'll bring that orange sticky note into the runtime of our system. We’ll start with a deep dive into the similarities and differences between event streaming platforms such as Kafka and queueing systems such as RabbitMq, Azure Service Bus & AWS SNS/SQS.

We’ll then look at ways to assess your orange sticky notes to work out which messaging and persistence paradigms suit each one, helping you build more resilient, scalable and loosely coupled event-driven architectures.

It's like 10,000 streams when what you need is a queue

Microservices

Content will forever and always change, so building resilient components requires careful planning and collaboration. And, of course, requires avoiding the common pitfalls of component design.

We will learn from the experience of working within and leading the development of multiple design systems built around React and TypeScript. Through many code samples, we'll highlight common patterns that lead to unmanageable component interfaces with steep learning curves. We'll learn how deviating from HTML can cause our components to break down, littering our codebase with technical debt. But with these examples, we'll learn how to avoid the common pitfalls of component design, and how to not only build frontends that are resilient to change, but how to build trust across teams throughout an entire product.

Building Better Components - A Journey to a More Resilient Frontend

In this session I will talk about real-world experiences learned from building software inside a utilities and banking landscapes.
You’ll see the patterns that matter, like multi-region design, idempotency and outbox/inbox, retry & circuit breaker, event-driven decoupling, and health monitoring. As a bonus, I will show tooling that helps you ship faster (Aspire, Dapr, CodeSpaces and more). I will make sure you will leave the room with knowledge you can apply next Monday.

Five things every developer should know about building mission-critical systems

Agent to User Interface Protocol (A2UI) defines how agents generate UI and Agent-User Interaction Protocol (AG-UI) defines how agents communicate with frontends.

In this session, we’ll deep-dive into each protocol and show how they complement each other. As a bonus, we’ll also see demos on how to use these protocols in agent frameworks such as Agent Development Kit (ADK) to give you practical knowledge to start building your own interoperable agents.


Tour of Agent Protocols: MCP, A2A, AG-UI, A2UI

Tools

But how does this actually work in .NET and how do you make the most of it? And more importantly, how do you store them correctly and prevent leaking secrets?

This talk will teach you how configuration works in .NET, what you should and shouldn't do, and how you can use the power of the cloud to keep your secrets safe!

The following topics will be discussed (including demo's):

- The importance of configuration and secret management
- The basics of .NET's configuration system and how it is set up under the hood
- The Options pattern and how it improves the configuration system
- Secret management during local development
- Best practices for an enjoyable configuration experience
- Secret management in the cloud using Azure Key Vault and Managed Identities.
- Tips and tricks and extra resources

When there's time left over, we will also cover Azure App Configuration and how it can make .NET configuration more powerful and manageable.

Everything a .NET developer needs to know about configuration and secret management

Custom AI solutions for your company used to require a dedicated team and a big budget. Now, with the GitHub Copilot SDK, you can embed AI capabilities that understand your enterprise domain knowledge, tools, and workflows in an afternoon.

This session shows you how to go from zero to a working AI agent embedded in your application in 10 minutes or less, live on stage. We'll cover how to set up the tools, why you might want to use the Copilot SDK, and what kind of agents you can build with it. You'll leave with working knowledge of how to use the GitHub Copilot SDK to put Copilot's capabilities into your existing applications today.

The live demo will be in C#, but the SDK is in a variety of languages, so the knowledge is transferable.

Put an Agent Inside Your App in 10 Minutes or Less with the GitHub Copilot SDK

We never planned to make our jobs harder. But somewhere between chasing new tools, planning for problems that may never come, jumping on every trend and trying to prepare for every future scenario, we lost our way. Today, building software isn't just complex. It's exhausting.
The worst part? We did this to ourselves. Our habits, our pride, and our fear of missing out push us to add more and more, even when less would serve us better.

But what if we chose another path? What if we stopped and asked: "How simple can this be?" Not simple as in easy or limited, but simple as in clear, focused, and built to last.

This session isn't about magic fixes or secret frameworks. It's about seeing that simplicity is both a choice and an opportunity. It takes discipline, creativity, courage, and sometimes more work than the complex path.
We'll explore why we tend to overcomplicate things and how to practice simplicity through Focus on what truly matters, Subtract what doesn't, and Master what remains.

The next big shift in software won't come from AI or the next shiny tool.
It will come from how we use them, and it starts with the next decision you make.  

Imagine If We Made It Simple

Agile

A long time ago, 'writing things down' looked like clay tablets with cuneiform on them, and affairs have only got more complicated from there. Nowadays, we try and write things down so that computers can understand them too, and that's given us a bewildering array of options - disk drives, magnetic tape storage and so much more.

In this talk, we're going to take a look at the history of writing things down, and discuss why some methods have worked better than others. We're going to talk about why writing things down for humans is different than doing it for a computer, and why it's difficult to try and do both at the same time (this is what code is). Finally, we'll take a look at what the state-of-the-art is today for keeping data safe, and what the future might hold.

This talk has no prerequisites, although a fondness for weird facts will certainly enhance the experience.

A Brief History of Data Storage

The Aikido Security research team was the first to uncover several of the most impactful incidents, including the Shai-Hulud self-propagating worm, the largest mass compromise of npm packages involving debug and chalk, and the backdooring of an official XRP cryptocurrency SDK. Together, these discoveries revealed that supply chain attacks are no longer isolated events, but carefully engineered campaigns designed to scale.

Attackers are also increasingly leveraging artificial intelligence as part of this evolution. We’ve seen early signs of this in real-world incidents, including prompt injection attacks delivered through CI/CD pipelines, impacting multiple Fortune 500 companies. including Google.

This talk breaks down why attackers increasingly target the software supply chain and what makes it such a powerful leverage point. We’ll examine the anatomy of modern supply chain attacks, including how attackers gain initial access to trusted packages, workflows, and extension ecosystems; how they move laterally by harvesting tokens and abusing CI/CD systems; and what their ultimate objectives are. We’ll also explore why certain ecosystems, such as package registries and IDE extensions, are especially vulnerable, why detecting malicious behavior remains so difficult, and what practical steps organizations and the broader community can take to raise the bar against these threats.

Inside Today’s AI-Accelerated Software Supply Chain Attacks

Many conflicts and misunderstandings happen because team members don't know what the other members needs. When we don't that, we may accidentally hurt them.

I helped many teams over the years and I have seen this happen again and again. Over time I have developed techniques to address this part as well.

I was working in a large media company, when a team had a conflict escalate into an emotional situation. This is the story of how I helped them talk about their feelings and needs, which was the first step in collaborating again.

I will also share some techniques that you can try out with your own team.

How I helped developers talk about feelings and needs

To do this, I've developed a process for working with coding agents, particularly Claude Code, which allows me to switch context rapidly and do things I don't 100% know how to do myself.

In this talk I'll share the techniques I've learned, developed and refined that help me get solid, usable code that I can put into production with confidence. I'll show you how to write a detailed requirements document that an agent can work from; how to work through those requirements step by step in collaboration with your LLM; how to maintain state between sessions (which is helpful for me as well as Claude); and how to keep up with what it's doing so you can take responsibility for the solution long after its context window has closed forever.

I'll also share some thoughts about where junior developers fit into this new way of working, and how important it is that humans continue to be the primary agents in software engineering.

How I Tamed Claude

Using Twilio, WhatsApp, and OpenAI’s image generation APIs, we’ll build a workflow where users can send images via WhatsApp; think selfies, pet pics, and photos from the conference, and receive a cartoon, sketch, or fun version of your photo to share on your socials, group chats, and company message boards.

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

Placeholder - Nick Chapsas

AI: It AI-n't What You Think!

It's easily said than done, but once we learn the right techniques the result can be rewarding. In this presentation we will take an example driven approach to test drive a piece of code and see how we can be that navigator that can steer us towards reaping the benefits of TDD.

Test Driving Code with the Help of AI

The MCP Apps extension is a proposed standard, inspired by MCP-UI and OpenAI's Apps SDK, that adds a UI layer to MCP that agents can render, generating real, web-powered interfaces that users can control from inside the chat.

In this talk you'll learn how to build interactive UIs that run inside AI chats. We'll start with a standard MCP server, add a UI component to display results, then make it interactive. We'll see the experience evolve from plain text to a mini-app inside the chat that can call tools and carry on the conversation. You'll leave ready to bring your app to life inside AI chats.

Evolving AI chat with MCP Apps

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

Talk 1: How I automated my life with MCP Servers - Cedric Clyburn & Legare Kerrison
Being a developer these days means you’re not only writing code, but also a Linux admin, a DevOps engineer, you name it! Thankfully, the Model Context Protocol (MCP) has made it significantly easier for me to ask my natural language questions, such as “What’s consuming the most memory in our dev cluster right now?”, and quickly receive a response. Hint: It was Prometheus!

What you’ll learn in this session is a straightforward way to build your own local “AI Agent” using open source technologies to interact with various API’s and tools. We’ll take a look at the most common MCP Servers that developers are using today, think Git, Databases, Dev Tools, and more. Plus, we’ll have some fun, and chain multiple tools together to automate your daily standup!

Talk 2: The fundamentals of Agentic Coding (AKA Vibe Coding) - Theodor René Carlsen
AI, whether we like it or not, has fundamentally changed the ways we work with code. In the beginning, many swapped out Stack Overflow for ChatGPT, moved from editing code to autocompleting with tools like Copilot, but now we are seeing more tools that that can write large parts of the solution for you.

Most people will relate to the feeling that “vibe coding” or “agentic coding” is a moving target, where both the models and the tools evolve at near-exponential speed. In this talk, I aim to reduce the sense of FOMO many might get when they hear people using these tools to write and refactor large parts of their codebase for them. Whether that FOMO comes from LinkedIn, X or your boss thats fully convinced that vibe coding is the future, we will try to stay grounded when meeting this new technology.

We will cover the basics so that you can actually understand what these tools are about: what they can and what they cannot do, what is mostly hype and what is actually worth checking out. And yes, we will also try to define the term "agentic coding" .

Talk 3: The Design Systems Graveyard - Kristoffer Nordström
It is said you can't succeed in building a Design System without having done so before. But building a Design System is easy - maintaining and making it grow is much more difficult. During the years many Design Systems have failed and ended up on the Design Systems Graveyard. I will share some trips and tricks that will make it less likely that you fail in your attempt of succeeding with one. Join me on a story about planning, categorising and sorting and about handling human beings and collaboration. This also have something in common with The Gentle Art of Swedish Death Cleaning. If you fail maybe your Design System will end up on The Design Systems Graveyard.

Lightning Talks 1

 - Conference Reception - Food & Drinks in the Expo


 - The OG Social Network - Anders Norås



NDC Party

Agents look brilliant in controlled demos, but the moment you try to plug them into real systems (legacy data, governance, identity, compliance, and unclear ownership) they collapse into the same pile of abandoned POCs as everything else.

My talk cuts through the hype and gets straight to the uncomfortable truth:

- why agentic systems end up as flashy prototypes instead of production tools,
- how Excel-based “data estates” quietly choke autonomy before it even starts,
- why most so-called “AI use cases” are still rule-based automation wearing an AI sticker, and
- how to build the minimal delivery backbone needed for any intelligent agent to run safely in a real enterprise.

This isn’t yet another vision talk, but the reality check most teams never get: the engineering and organizational work required to move agents from the lab into the world where the constraints are real and the stakes are even higher.

Care about getting agentic systems running rather than demoing? This session gives you the hard truths and the practical steps to finally make that possible.


POC Prison: Why agentic systems never escape the lab and how to fix that in 90 days

During the planning phase of a military operation, there are multiple text documents that need to be updated simultaneously by multiple users. At the same time, there is a requirement to provide security in air-gapped deployments.

As such, a solution that follows high standards for security, performance and quality is required.

Within my presentation, I will be describing an embedded solution based on advanced operational transformation algorithms which allows real-time secure collaborative editing, as well as several challenges that we have faced during development and how we managed to overcome each of them.

Building a real-time collaborative editor

Functional Programming

This is a major concern, especially from a security perspective, because there is no guarantee that secure coding practices are followed or that the code is reviewed for design flaws, which usually require expert human oversight beyond AI.

This problem becomes even more serious when you look at recent npm supply chain attacks, particularly typosquatting attacks, where malicious packages are deliberately named to look like popular libraries. AI-generated code that blindly suggests or auto-inserts dependencies without proper review can easily pull in these malicious packages, indirectly contributing to such attacks. When developers trust AI output without verifying package names, maintainers, or reputations, they increase the risk of introducing compromised dependencies into their applications.

In this talk, I will discuss common application vulnerabilities, how to prevent them, and cover foundational secure coding practices to follow during web development. I will also address how to rigorously review AI-generated code and its dependencies, especially third-party packages, before deploying anything to production.

Secure coding in the age of AI

Testing

If you're not carefully managing these dependencies, you could expose your application to vulnerabilities or even malicious code, just like what happened with Log4J.

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

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

I will dive into the fascinating world of artificial intelligence and machine learning, focusing on how bias can infiltrate AI models. Attendees will explore real-world examples of biased AI decisions, learn how machine learning models can "lie," and discuss the ethical challenges this poses. Through case studies like COMPAS and image classification failures, we’ll uncover how biased data can lead to problematic outputs. By the end of the session, attendees will gain practical strategies to identify, prevent, and mitigate AI bias in their own work.
Takeaways:
Understanding AI and Bias through real-life case studies
Ethical Concerns and Practical solutions
Future of looking ahead

How to Lie with AI: Understanding Bias, Ethics, and the Hidden Risks in Machine Learning

Having the users in mind is what connects these areas to build better products.
A fantastic User Experience is what makes the difference when customers choose between one product or another. Considering that, it only makes sense that QAs and UXrs join forces and help build great experiences from their own perspectives. Why not have a system that considers the best of both worlds?
As you’d know, the saying that “good design is obvious” is a tale as old as time. As Steve Krug once said, “Your goal should be for each page or screen to be self-evident, so that just by looking at it the average user can say “I get it.” - Steve Krug.
Takeaways:
How to create effective visual hierarchies
How to don’t reinvent the wheel
How to nor we allow personal feelings to take over the process and how ask the right questions


Most Expensive Design Mistakes (Ever) and how to avoid them

But how does agentic AI work under the hood?
How are models able to understand when to use a tool and how to use it?

In this demo intensive session Alan will explain the concepts of agentic AI in detail. Starting with the basics of function calling in the Open AI models, he will cover the techniques used to provide tools to models, and how the models are able to understand and use the tools. The use of prompting to guide models and improve tool call behavior will be covered, along with guidelines for adding tools to your solution. Alan will also cover the protocols used by Open AI models as well as how the model context protocol is used to provide compatibility between services and LLM solutions.

Join this session if you want to understand what goes on under the hood of function calling, MCP and agentic AI.


AI Agents In-Depth – Function Calling, MCP and Tool Use Under the Hood

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

Languages

Microsoft

In this deep-dive session, we will explore the best practices, advanced scenarios, and performance optimization techniques to ensure you get the most out of HttpClient in your applications. Beyond HttpClient, we will also discuss libraries that extend its capabilities, such as implementing the circuit breaker pattern.

By the end of this session, you will gain a comprehensive understanding of how HTTP calls work within .NET and how to achieve optimal performance in your applications.

Optimizing your HttpClient usage

Language

This talk is not a checklist of rules. It’s an interactive wake-up call.
15–25% of the population needs websites to accommodate different types of disabilities. Still, 94.8% of websites contain accessibility issues that make them harder to use.

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 explore mutation testing, which checks whether your tests actually catch bugs instead of just always passing. Property-based testing lets your code generate hundreds of input variations automatically, exposing edge cases you wouldn’t have thought of. And for complex data structures or legacy code, snapshot testing can capture outputs and catches unexpected changes over time.

Along the way, I’ll hint at other practical approaches that can level up your testing. You’ll leave with concrete ideas to write fewer, but far more effective tests.

.NET Testing Techniques You Didn’t Know You Needed

In this session, we'll explore building an AI-powered companion app using .NET MAUI. We'll harness the capabilities of .NET MAUI to create a seamless user experience across platforms and integrate AI functionalities to make our app smarter and more responsive.

You will walk away with all the knowledge you need to build your own personal Jarvis, whether you want to get personalized book recommendations, crazy roadtrip ideas or get food recipe ideas... After this session you can build it all!

Building an AI-Powered Personal Companion Mobile App

Mobile

For engineers working with AI, the challenge isn’t simply extracting text—it’s preserving the structure, context, and relationships within the data. Whether fine-tuning models or building retrieval-augmented generation (RAG) pipelines, effective document processing is essential to powering actionable insights.

This session dives into the techniques and open source tools needed to transform unstructured documents into structured formats like JSON or Markdown, ready for AI workflows. You’ll learn how to handle challenges like multi-page tables, image-heavy layouts, and scanned documents using context-aware methods. Join this session as we explore how to efficiently bridge the gap between unstructured data and AI-powered applications, and help you achieve better results in your AI projects.

Structuring the Unstructured: Advanced Document Parsing for AI Workflows

In this session, we'll build a set of small, practical features you can drop into real web apps: dynamic story beats, sentiment-aware feedback, and adaptive challenge tuning that reacts to player behavior.

You'll see how to wire these features into a modern JavaScript app with lightweight demos that focus on patterns you can reuse in real apps.

AI-Powered Gamification for the Web

Gaming

Data model mistakes mean you don't have the information to answer your questions, and a lot of your decisions can't be easily reversed. You know the problems are there. You've known for years. But there's never time to fix it properly - you're too busy keeping the lights on.

Then one day, the stars align. You finally have time to tackle it. You open the codebase, ready to make things right - and realize you have no idea where to start. Everything is wrong. Every fix breaks something else. The whole thing feels impossible.

I'm a business owner. I had full authority to prioritize this rewrite. No one to convince, no budget to fight for. I still couldn't make it happen for five years - even while watching money walk out the door.

This is the story of how we finally completed that rewrite. You'll learn:

- Why we abandoned a full rewrite and pivoted to strategic refactoring instead
- How to assess whether your legacy system is salvageable (ours barely was)
- The architectural patterns - including the actor model - that would have prevented this mess
- How we used AI to accelerate the work (spoiler: it wasn't vibe coding)
- The management failures that let this happen, and how to avoid them

This isn't a talk about how smart we are. It's about how we recovered from one of my biggest failures as an engineering leader - and what you can learn from our five-year journey through hell.

NDC { Copenhagen }

Agenda

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

Let’s catch up with C#! Exciting new features in C# 9 to C# 14!

Filip Ekberg

Five things every developer should know about building mission-critical systems

Loek Duys

Put an Agent Inside Your App in 10 Minutes or Less with the GitHub Copilot SDK

Daniel Ward

Beyond Pub/Sub - Advanced Messaging Patterns

Poornima Nayar

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

Everything a .NET developer needs to know about configuration and secret management

Sander ten Brinke