Name: NDC Copenhagen 2025
Start: 2025-09-08
End: 2025-09-12
Location: NDC Copenhagen

In this humorous talk, you'll learn which security concerns are important to think about while working in a Modular Monolith. I'll show you how you can implement those concerns so that security isn't a disaster when you need to scale your system out. And maybe you'll learn a thing or two about cats, too. Dog people are also welcome.

Talk (60 min)

Secure your Modular Monolith by pretending it's a cat

Architecture

Microservices

Security

With Web APIs, the answer is almost always yes; even to the question "can you fly a drone with a banana?"

In this talk, I show the audience the power of APIs and discuss a few cool experimental APIs. I do this by taking them through on a journey through my experience of trying to hack a drone and fly it with a banana.

If you're interested in all things web, custom controllers, Bluetooth technology and accelerometer-based controls or if you just like fruit and seeing silly applications of technology, this talk is for you.

Flying a drone with gestures, bananas & Web APIs

JavaScript

But here's the real question: are you absolutely certain that your API only accepts access tokens issued by your service?

In this session, I’ll demonstrate some tricks that can bypass improperly configured token validation. You’ll see how easy it is to fool your API if you’re not careful. But don’t worry, I’ll also show how to write tests that ensure your application is protected against these exploits, keeping your data and users safe. 

Are you sure your access tokens are really secure?

.NET

Testing

In this session, we’ll explore how to train Regression and Classification models using C# and ML.NET, and how to run those models in a .NET MAUI app, enabling offline AI analysis directly on a mobile device. We’ll also look at how to create an image classification model using Azure Custom Vision, and use it offline in our .NET MAUI app with the power of ONNX.

After this session, you’ll have a basic understanding of what Regression and Classification problems are, how to train and evaluate models with ML.NET and Azure Custom Vision and how to use these models locally in a .NET MAUI app.

Building Intelligent .NET MAUI Apps with ML.NET

Microsoft

Mobile

But how do you modernize over 10 years of legacy? Throw it all out and start over? That gets even more expensive. The answer is simple: it depends.

It depends on the specific needs of the business: does it need to scale? What about safety or privacy? How about Performance? Choices have to be made.

As an application modernization architect I have done my fair share of these projects. In this session I will share my experiences, and how I deal with them. By the end of the session you will have a clear understanding of where to start, and what steps to take to bring that business-critical application into the modern age.

Modernizing your legacy application

Design

In this talk, we’ll debunk the myth that adding an index is always the best solution and dive into the hidden performance killers lurking in your database. From inefficient query patterns and misused joins to transaction overhead and bloated statistics, we’ll explore real-world scenarios where indexes failed and smarter alternatives prevailed. Expect live demos, surprising insights, and actionable takeaways to help you optimize queries beyond just adding another index. Whether you're a database veteran or a curious dev, this talk will make you rethink how you approach query performance! 🚀

It’s Not Always About the Index: The Hidden Secrets of Query Performance

Database

In late 2024, I helped a client launch an AI-powered code reviewer. We built the initial prototype in the first few hours. But we soon encountered many unexpected challenges as we tried to productionize the idea into a coherent user experience.

In this session, let me tell you the surprises, challenges, and lessons learned from building an AI-powered code reviewer and what it tells us about the current state of LLM technologies.

How we built an AI-powered code reviewer in 80 hours

Serverless

GenAI

In this talk we'll explore the ins and outs of caching in .NET, from memory to distributed up to hybrid caching: we'll see both the new HybridCache from Microsoft and FusionCache.

We'll explore common scenarios, recurring problems and how to solve them with a focus on pragmatic solutions that can be used right away in the real world.

FusionCache is my free OSS project: is even used by Microsoft itself (see Data API Builder) and is the world's first production ready implementation of HybridCache.

Resiliency, performance and scalability will be center stage.

Hybrid Caching in .NET

Concurrency

Thanks to a Microsoft backed, open-source SDK called Semantic Kernel, you can seamlessly integrate an LLM-based AI with your own code to perform more complex tasks like sending emails, updating databases, ordering tickets, and much more...
With Semantic Kernel, you can leverage the same AI orchestration patterns that power Microsoft's Copilots in your own applications.
In this session, Johnny will explain the concepts and prove them with a number of hands-on examples. 

Building your own AI Agent using Semantic Kernel

Several academic studies show that AI generated code based on LLM's that are trained on vulnerable OSS implementations lead to vulnerable generated code. Another study showed that developers tend to trust GenAI created code more than human created code. Combining that with the higher code velocity it will result in more vulnerabilities in it's output.
Using an AI system that runs an LLM also has additional risks tied to it, related to jailbreaks, data poisoning and malicious agents, recursive learning and IP infringements.


In this presentation, we will examine real-world data from several academic studies to understand how GenAI is changing software security, the risks it introduces, and possible strategies to address these emerging issues.

Using GenAI on and inside your code, what could possibly go wrong?

In this session, you'll gain practical knowledge you can apply when building and operating event-driven systems. You'll learn how to test systems that prioritize asynchronous communication, evolve them over time, and, most importantly, observe them and recover from failures when things go wrong. This session will walk through the software development lifecycle for an actual application, and it includes the theory behind the different practices and practical things you can take away and implement in your architectures.

So You Want to Maintain a Reliable Event Driven System

Zero Trust architecture, with its emphasis on continuous verification and least-privilege access is the foundation. It is imperative for software engineers to integrate this knowledge into their skill set, not only to maintain security in hybrid cloud environments but also to anticipate and counteract emerging threats in increasingly sophisticated ecosystems.
By the end of this session, attendees will understand why Zero Trust practices are critical to Microsoft's Secure Future Initiative and why equipping all software engineers with this knowledge is essential for safeguarding modern, connected systems with practical examples using Azure resources.

Zero Trust Security with Azure cloud

Cloud

People have often told me they’d never be able to do design, as it’s too subjective and a completely different mindset to coding. Well I’m here to tell you that UI design isn’t as complex as it looks when you’ve got the right tools to hand.

In this talk, I will help you understand some of the main design principles that you can apply across UI design. Including – Typography, Emphasis, Hierarchy, Layout, Spacing, Size, Depth and Colour.

We’ll be discussing these principles and through visual demonstrations show just how you can implement them across typical features such as forms, cards, dashboards and other interface elements . There may even be some *live designing* to help demonstrate.

Whether you’re the ‘dev-signer’ or you’re just somebody who would like to learn some fundamental design skills to widen your knowledge – you should then leave feeling well equipped with new design skills to apply day to day!

Design for Developers

Event-driven architecture (EDA) offers a powerful solution that extends beyond the traditional roles of producers, consumers, and brokers. It facilitates the creation of dynamic architectures that evolve, empower teams, and enhance agility, enabling businesses to thrive in rapidly changing environments.

In this talk, we’ll explore how complexity can obscure the potential of event-driven architecture (EDA). By examining EDA through the lens of Domain-Driven Design, we'll discuss how it contributes to the growth of evolutionary architectures and the critical guardrails and governance strategies needed to manage complexity effectively.

Whether you’re refining your current architecture or embarking on a new journey, this session will provide actionable insights into controlling complexity and maximizing the potential of event-driven architectures within a domain-driven context.

Navigating complexity in event-driven architectures: A domain-driven approach

Join us for "Blob Wars: The Battle for Efficient File Handling", where we’ll arm you with the tools and strategies to conquer the chaos of file management.

In this session, we’ll explore how to build a real-time file management system using .NET, SignalR, and React. You’ll learn how to:

Streamline file uploads and downloads using Azure Blob Storage.

Leverage SignalR to enable real-time updates and notifications.

Build a responsive React frontend that interacts seamlessly with your .NET backend.

Whether you’re fighting the dark forces of inefficiency or seeking to master the art of real-time file handling, this talk will equip you with the skills to emerge victorious. May the blobs be with you!

Blob Wars: The Battle for Efficient File Handling with .Net and React

We'll cover the main ideas, such as schemas, handlers, ClaimsPrincipal, claims, challenges, session cookies, and more. It will be a practical, in-depth look at how authentication actually works in ASP.NET Core.

Demystifying authentication in ASP.NET Core

However, the web is more dynamic than you remember and visual notifications that are now used to communicate updates, errors, and content changes are difficult to understand. If not impossible.

We’ll explore ARIA Live Regions through the eyes of a zombie trying to navigate the modern day web. From creating an account, ordering your favorite snacks, to sending an email, we’ll experience how screen readers understand, or sometimes don’t understand, dynamic content and live region updates. We’ll explore the rules and recommended methods for incorporating live regions to create more inclusive notifications, and ultimately, we’ll find ways to replace live regions all together with more persistent and robust patterns.

The Shopping Dead: An Accessible Live Web For The Unalive

Because screens are central to modern life, our day-to-day work has monumental purpose and value. We banish interface rage, help businesses save and make serious money. We keep people safe from disaster and yes, pickles.

We'll explore why small interface problems are never the whole story behind historic (or mundane) UI failures. You'll come away with a stronger sense of purpose in the smallest details and broader context of your important dev work.

The Chips and Pickle Story: What's Really Behind Infamous, Historic UI Failures?

People

For space nuts like me, this fascinating time is utterly compelling. It’s also highly instructive for digital product developers. After all, engineers drove the innovation that pushed us beyond earth. The lessons they learned and processes they created can help us today as we make software, apps, and advanced functionality online.

Of course, the Soviet side of the story tends to be less understood. And that’s exactly what we’ll explore. It’s unbelievable stuff, and a cautionary tale for development teams.

WHAT YOU’LL LEARN
- How differing philosophies of development lead to different processes and results.
- What Soviet imperatives parallel modern development approaches.
- Why the USSR led the space race early, but ultimately failed to reach the moon first.
- What we can learn, adapt, and avoid today from the 20th century Soviet model.


What the Soviet Space Program Taught Me About Digital Product Development

Space

This talk will be a road trip through some of the most burning developer topics. You might get inspired, or you might get provoked. No matter what, you will learn about software developers, our thoughts, and why a famous Monty Python sketch should inspire us all. 

The Developer Rhapsody

Agile

Soft Skills

In this hands-on workshop, you'll learn how to have strategic dialogues with AI that challenge your assumptions, uncover edge cases, and help you slice user stories into manageable chunks. By the end of this workshop, you'll walk away with your own customized AI coach, ready to help you write more impactful user stories immediately. More importantly, you'll have a framework for applying these AI collaboration techniques to other aspects of your product development process. This isn't about replacing product managers; it's about amplifying your expertise with AI-powered tools.

Workshop (60 min)

Part 1/2: Create Your AI Product Coach: A Hands-on Workshop for Writing Impactful User Stories

Tools

We'll be covering What You Need To Know about async/await in C#, including several different correct conceptual models of async/await that you can switch between at will. We will take a look at the common async pitfalls, best practices, and guidelines along with a careful examination of when to ignore the best practices. We'll be including some semi-advanced topics (specifically ValueTasks and Channels) to round out techniques for modern asynchronous development.

While this talk is geared towards developers who already use async and await, it would also be appropriate for those who do not (yet). Feel free to bring questions!

Avoiding common pitfalls with async/await

Let's address the practical applications of DSLs once they are integrated into the codebase. This talk explores how DSLs, unlike simple imperative code, can serve as a single source of truth to solve various problems. I will illustrate this with five concrete examples and share advanced tips and tricks for writing non-trivial Kotlin DSLs. Attendees will gain insights into maximizing the potential of DSLs to improve maintainability, quality, and documentation in their projects.

One Source to Rule Them All: Kotlin DSLs as a Single Source of Truth for Multiple Tasks

Java

Languages

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

Ethics

Machine Learning

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

This session dives into the real-world impact of WebAssembly for .NET developers, from Blazor WebAssembly to Uno Platform and beyond. We’ll explore how .NET can leverage Wasm to create fast, portable apps and how WASI is opening the door for server-side execution. Whether you're looking to extend your .NET skills to the browser or streamline multi-platform development, this session will give you the insights and tools to harness Wasm effectively. 

WebAssembly & .NET: The Future of Cross-Platform Apps

Cross-Platform

Language

In this talk, we’ll dive into the challenges with Eventual Consistency, multi-tenancy, circular references, cross-origin resource sharing (CORS), and many more. You'll hear the choices we made, along with other options we considered, and what we learned from this experiment.

Migrating from a monolith to a new service

In this session we'll present an overview of how cloud-native application patterns have emerged over the last ten years, and how powerful edge-compute services are impacting what could be considered established cloud-native application patterns.

The session will feature CNCF projects, public cloud providers and services, and edge-compute providers and services. The focus will be on guiding to build according to good architectural patterns that fits the use-cases you need to solve for.

The session combines overviews and examples with demos, using among other things, the CNCF project Spin, to inspire you to think about how and where edge-compute platforms can be of great benefits to what you do today.

Edge-native applications - what happened to cloud-native?


With the CNCF project Spin, we get to use WebAssembly's portability and component model, to build applications as monoliths, but being able to run them distributed across clouds and edge-compute providers networks.

Spin enables you to use programming languages like JavaScript/TypeScript, Rust, Go-lang, Python, and many more to write functions, which can execute in many different environments.

The workshop will be a fun little game, where teams will have to solve puzzles while learning the technology. The workshop has all instructions to guide you through building with Spin, and will be instructor-led.

Part 1/2: Geek-out with the WebAssembly Component Model: Embrace Edge- and Cloud-Native

Chrome DevTools offer a variety of options for accessibility testing, including simulations for visual impairments, checking for accessibility labels, color contrast and insights into the accessibility tree. We will discuss these techniques, as well as common sources of accessibility issues and how to approach them. We will also explore how to convince your team or manager to invest in accessibility testing and where to focus your attention if you have limited time & resources.

Let's make the web more accessible, one page at a time!

Accessibility Testing with Chrome DevTools

In this session, I'll do a deep-dive into the publish/subscribe API of Dapr, the Distributed Application Runtime, a graduated CNCF project, used by hundreds of organizations who run microservices at scale in production. Dapr provides APIs that abstract away the underlying infrastructure, and in this session we'll look in detail at the pub/sub API that can be used with many different message brokers while the application code remains unchanged.

Topics covered include: the various subscription types such as declarative, programmatic, and dynamic (streaming), bulk publishing, CloudEvents, routing, and the outbox pattern. For all topics, I'll be doing demos in C#, and run the demos across various message brokers, including Azure Service Bus, RabbitMQ, and Redis.

By the end of the session, you'll have a good understanding of the capabilities of the Dapr pub/sub API and know how to apply it in your distributed applications.

Async messaging deep dive with Dapr, take your pub/sub skills to the next level 📨🚀

We live in a world that constantly demands more from us, making focus a rare and valuable skill. Through trial, error, and necessity, I’ve discovered practical, science-backed techniques that help manage the chaos—strategies that anyone can use. From task management frameworks like the Eisenhower Matrix to unconventional motivators (yes, bribery works), I’ll walk you through methods that help turn distractions into productivity.

But productivity isn’t just about working harder—it’s about working smarter, protecting your time, setting boundaries, and finding joy in what you do. In this talk, I’ll share both tactical strategies and deeper psychological insights into why focus is so elusive and how we can reclaim it.

Whether you're struggling with ADHD, burnout, or just an ever-growing to-do list, you’ll leave this session with actionable tools to help you work more effectively, reduce overwhelm, and maybe—just maybe—start feeling in control of your time again. 

The Art of Focus: Managing Productivity with an ADHD Brain (And Why It Matters for Everyone)

In this session, we'll explore how changes in software design can have unexpected, profound impacts. In this story-based session, I'll reference both popular and little-known "laws" of computing and life. I'll show how to use these laws to write better software. This session will give you new mental models for thinking about the tradeoffs we make in software...and life. 

The Immutable Laws of Software and Life: Code Accordingly

Continuous Delivery

This talk tells the story of Computer Lib, the man behind it, and the philosophy that shaped it. It explores how Nelson’s ideas could have led to a very different digital world—one built around open, decentralised knowledge rather than the walled gardens and algorithmic control we have today. What if his vision had won? What would the internet look like if computing had followed the path of Computer Lib instead of Big Tech?

Nelson once wrote that “most authority is malignant.” This is a talk about the man who wanted to dismantle it, and the future we lost when the world ignored him.

Dream Machines and Walled Gardens

What if I told you that there is? Let’s take a journey together towards a wholly different approach to conflict - a collaborative one. In this talk, you’ll learn how to use conflict to fuel better software, better teams, and better companies. You’ll learn how to structure your team’s environment to draw out good conflict, to squelch the bad conflict, and to handle conflict when it becomes personal. We’ll discuss how to manage different confrontational styles, avoid self-sealing prophecies, and even how to deal with conflict when you lack control. Conflict should fuel your progress, not hinder it - and after this talk, you can make that happen.

How To Not Strangle Your Coworkers: Resolving Conflict with Collaboration

This talk explores what it really takes to launch and scale a SaaS in 2025 and why ignoring these factors can be a costly mistake.

The New Realities of SaaS: Why Building is Harder Than Ever

DevOps

The conversations that follow sound all too familiar... "Who's subscribed to this message?" "Do other services depend on this field in the payload?" "Why on earth is that thing in the payload?" "That service should never rely on this data!" And, of course, the obvious "Can't we -just- remove this?"

But are those the right questions to ask? As software developers, we aim to be agents of change, not chaos. To achieve this, we need to understand the impact of tweaking a message contract without breaking half of the system or forcing other teams beyond their deadlines. We should prioritize techniques that ensure compatibility while also considering how long that compatibility needs to be sustained. Oh, and let’s not forget that we’re supposed to solve this problem with zero downtime, as our users are spread across every time zone. In this session, we’ll discuss practical techniques and tooling that can enable the evolution of your event-driven system so that, next time a stakeholder approaches with a change request, your heart doesn't sink to the floor.  

Change is inevitable: versioning event-driven systems

Do you feel like assumptions made by developers often end up in production instead of domain experts' knowledge?
Do you often see that nobody knows the whole truth about a system, but only part of it?

In this talk, I'll show you how using EventStorming transformed our domain modeling process, allowing us to explore and get a good understanding of complex problems in hours instead of days. We'll dive into the specifics of this methodology and find out how it can help developers overcome common challenges and achieve better system design.

Join me for a discussion that could change how you approach your development process. By the end of our session, you'll have a clear understanding of the benefits of using EventStorming, and you may even be inspired to make it your go-to tool for future projects!

From Days to Hours: How EventStorming Transformed Our Domain Modeling Process

If you have a dataset that is even remotely connected, graph databases can be a game changer. Exploring connections, finding insights and patterns in data, evolving the schema, backing GenAI applications: these are all things that come natural in the land of graphs, and not-so-natural in relational arenas.

Join to learn the architectural differences that make graphs so efficient for networks of data, how to write queries in the Cypher language, how to model your dataset for graphs, and how to translate your relational dataset into a graph. This is a hands-on workshop!

Part 1/2: Querying and modeling for graph databases

This talk focuses on the tactical patterns with a pragmatic approach and explains how to layer your software, how to practically implement aggregates, repositories, domain services, application services and other fundamental building blocks with real-world examples and well-defined rules.
The solution structure and code samples are based on .NET and C#. 

Implementing Domain Driven Design as a Pragmatic .NET Developer

We'll examine the psychological aspects of this bias and its impact on text, images, and code and provide actionable strategies for increasing awareness and reducing bias. We will close with a live demo showcasing practical examples and innovative approaches to transform your interaction with generative AI.

This talk is ideal for anyone interested in generative AI and how we work with it. Come prepared to challenge your assumptions and change your relationship with AI.

Toxic Trust: The Psychology of Automation Bias in Generative AI

This session will explore what happens when number of applications, environments and environment types starts to reach double digits. You will learn how scaling up adds complexities and how to approach this on both team and organizational level.

Managing Terraform modules at scale

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


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

Big enterprises or small, problems are problems. There are plenty of tools and frameworks, but what really sets enterprise solutions apart from one-off applications are the fundamental patterns. In this session, we’ll break down a typical enterprise architecture piece by piece, focusing on the decisions engineers and architects make when tackling common problems and requirements. We’ll dive into areas like scalability, security, integration, and maintainability, giving you practical insights whether you’re new to the field or just need a refresher.

Modern Architecture 101 for New Engineers & Forgetful Experts

We don't prioritize ourselves, we don't plan our time, we don't keep ourselves accountable, and on top of that, we scold ourselves instead of giving constructive feedback.

The funny thing is - we already have the skills to be better leaders to ourselves. We use them daily with our teams, yet somehow, we fall short when it comes to US.

In this talk, we go through how facilitation and leadership skills commonly used to lead teams can be re-applied to ourselves. How do daily standups, planning meetings, and retrospectives look and work with yourself when done on a personal basis? Can you run a personal discovery or ideation workshop over your own work?

And how do these things integrate with the work you are doing in a team setting.

Learn the idea of facilitating YOU! and get some tips on concrete workshops and steps you can do alone to boost your productivity and well-being.

Facilitate You! - Use your facilitating skills to lead yourself

At Wix, we’ve refined these patterns to enhance performance across thousands of microservices. This session breaks down four key strategies that boost developer velocity while tackling common challenges:

1. Integration Events: Reduce query latency and improve user experience by shifting from synchronous calls to event-driven pre-fetching.
2. Task Queue: Streamline request flows by offloading non-critical tasks like notifications.
3. Task Scheduler: Enable precise, fault-tolerant delayed or recurring workflows with robust scheduling techniques.
4. Iterator for Long-running Jobs: Manage large workloads by breaking them into smaller, scalable chunks to enhance resilience.
We’ll discuss the benefits, challenges, and practical implementations of these patterns, showcasing principles applicable across .NET applications. From Azure Functions to Quartz.NET and beyond, learn how modern .NET tools empower developers to implement these strategies effectively. Walk away with actionable insights to refine your microservices architecture and elevate your team's productivity.

Async-ronizing Success: Patterns for Seamless Microservices

Experience the thrill of live coding as we develop the NDC Copenhagen app in real time! Will we end up with something that we can actually use for the rest of the event or will we horribly fail and watch Gerald put in blood, sweat and mostly tears for an hour?

This session will guide you through the process of building an app that lists speakers and sessions and what else we want to fit in, highlighting best practices and tips and tricks for cross-platform development with Blazor Hybrid.

Perfect for developers of all levels, you'll walk away with actionable knowledge on building dynamic and engaging apps quickly and efficiently.

Or, at the very least you'll have a good laugh and learned what NOT to do!

Building the NDC Copenhagen Mobile App Live! with Blazor Hybrid

This talk explores how Vibe Coding works in practice and how it’s transforming the everyday workflows of people in software development. Tools like GitHub Copilot, Lovable, and Cline enable a new kind of collaboration between humans and AI, where prompting becomes the core skill. Instead of focusing on syntax and boilerplate, developers can concentrate on creativity, goals, and iteration.

But Vibe Coding is about more than just speed. It lowers the barrier to entry, democratizes technical capabilities, and unlocks entirely new creative possibilities. At the same time, it raises important questions around data privacy, quality assurance, and the evolving role of tech professionals in a world where anyone can generate working code.

Whether you’re already experimenting with AI or just curious about what’s next – this talk will provide inspiration, strategies, and a fresh perspective on what software development is becoming: Prompt. Build. Repeat.

Prompt. Build. Repeat. – The Vibe Coding Mindset

In this talk, we'll explore how to build AI-powered real-time streaming pipelines. Whether it’s for fun, profit, or simply seeking revenge on the Karens of the world.
We will discuss the architecture, libraries, and tools you need to perform real-time sentiment analysis on live unstructured user data coming from your own system or even social media, using Apache Kafka and Apache Flink. You'll learn about the challenges of integrating AI models into these technologies, and we'll walk through a practical, real-world example.
Finally, we'll break down the differences between using powerful large language models (LLMs) and lightweight small language models (SLMs), understand the pros and cons of each and how to pick the best one for your specific scenario.

Whether you are experienced in streaming systems and data engineering, or just curious about applying AI to solve real-world problems, this session will give you the foundation, insights, and inspiration to try it out yourself.


AI vs. Karen: Real-Time Customer Sentiment Detection at Scale

Big Data

In this session, we'll introduce Microsoft.Extensions.AI and dive deep into its abstractions like IChatClient. We'll also highlight its integration with Microsoft's Semantic Kernel as its foundational layer.

Then, we'll jump into the code where we'll build our own custom chat client together! We'll quickly write code to use various models from OpenAI, and then we'll use that same code to jump to other providers like Amazon Bedrock and Ollama.

Join me as we learn about the best way for adding AI to any .NET app! 

Easily Add GenAI to .NET Apps using Microsoft.Extensions.AI

In this session, you’ll learn how to:
• Decode your own internal OS using tools like Gallup Strengths, Enneagram, and The People Code
• Identify your default responses to stress, feedback, and conflict — and when to patch or update
• Understand your motivators, communication style, and work preferences — and how they impact collaboration
• Recognize compatibility issues for what they are: system mismatches, not personal flaws
• Use AI as a personal coaching layer to help you align your internal settings and navigate difficult work scenarios

You’ll walk away with a clearer understanding of your system architecture, and digital tools to help you optimize how you problem-solve, communicate, and collaborate with others — even when their internal OS is nothing like your own.

Optimize Your Internal OS and Minimize Compatibility Issues at Work

This session aims to equip you with both the theory and the practical knowledge required for getting started with building AI Agents on Azure. We will cover the fundamentals of AI agents, their applications, and how they can work together in multi-agent systems to solve complex problems. Then, we build some AI Agents using the open-source framework Semantic Kernel and test them live.

At the end of the session, you will be able to answer these questions:
Why is agentic AI becoming a trend?
What are popular frameworks for building AI Agents?
Why have more than one agent?
How to actually get started?

This session is designed for developers and AI enthusiasts who are eager to dive into the world of intelligent agents and their collaborative capabilities. We will use code in Python but equivalent code is available for .NET and Java as well.

Building AI Agents and Multi-Agent Systems with Azure AI

In this talk we’ll go over what those agents can bring to the table of coding world, and why they can deliver the promise of coding smarter that the current generation of coding assistants can’t. We will then dive right into a quick live coding session where I’ll show what such agents can do in real life and how you can start using them to enhance your everyday life already right after the talk. And we’ll finish off with some remarks on what the future of programming might look like in the near future as those agents get included into your everyday life.

AI Coding Agents and how to code them

In this session, we'll explore how architecture, deployment patterns, and observability choices impact cloud spend, and why engineers are in the best position to optimize both performance and cost. You’ll learn actionable patterns for cost-aware system design, practical tools and strategies to embed FinOps into your engineering workflows and team culture. Whether you're managing Kubernetes at scale or designing a new microservice, this talk will help you build systems that are not only reliable, but financially responsible.

FinOps for Engineers: Why Your Architecture Has a Price Tag

The core of this talk demonstrates how the Enigma's complex encryption system can be elegantly modelled using functional programming principles in F#. We'll illustrate how the machine's components—rotors, reflector, and plugboard—naturally map to a pipeline of pure functions, with machine state threaded through using fold/reduce patterns. This approach not only simplifies the conceptual understanding of the Enigma but also highlights the expressive power of F# for modelling complex systems.

NDC { Copenhagen }

Agenda