In this talk I will lay out the socio-technical landscape for APIs by discussing factors that influence the relationship between API providers and consumers, such as the alignment (or misalignment) of goals, the mode of communication, the design process, typical points of contention, etc. With this background, I will discuss a number of recurring patterns I have encountered in my career, including the Millstone, the Mountain (or the Volcano), the Rapids (with or without Beaver Dams), and the Sock Puppet. Identifying such patterns is important to better understand and address common challenges, so that we can achieve better outcomes for our APIs.

Talk (60 min)

Socio-technical API patterns

Architecture

Soft Skills

People

In this talk, I’ll share lessons I’ve learned so far:

- Growing and engaging a community around your project
- What actually works (and doesn’t) when pricing open source
- The realities of open core models and building in public
- Why plugin-based systems and extensibility create long-term value
- How to talk to users without getting misled (using the Mom Test)
- Why focusing on what really matters beats chasing every request
- Taking the leap to go full-time — and how to know when the timing is right
- The trade-offs and hard truths no one tells you about monetizing OSS

You’ll walk away with a candid, practical playbook for making open source sustainable — whether your goal is side income, a self-funded business, or simply building a project that lasts.

Stars Don’t Pay the Bills: Turning Open Source Into a Business

Tools

This session provides a practical introduction to passkey authentication and its implementation in ASP.NET Core applications. We'll explore the fundamentals of passkeys and the underlying public key cryptography. Then, we'll demonstrate how to integrate passkey authentication into your projects, supporting OS management, password managers (like 1Password), and hardware security keys (like a Yubikey).

Join this talk if you want to get a thorough understanding of passkeys and the skills to integrate them into your applications.

Going Passwordless - A Practical Guide to Passkeys in ASP.NET Core

.NET

Security

The MVVM Community Toolkit allows includes Source Generators that write all of the boilerplate MVVM code for you. The .NET MAUI Community Toolkit includes Converters, Behaviors, Custom Views like DrawingView + Popup + MediaElement; all of the essentials you need for your mobile apps. And the .NET MAUI Markup toolkit allows you to quickly + easily write your .NET MAUI UIs in C# (no XAML!).

As the creator of the .NET MAUI Community Toolkit, I am a bit biased, but I promise that you will use these libraries in all of your .NET MAUI apps going forward if you aren't already!

Join me in this session as we dive deep in the Community Toolkits to learn best practices and shine a spotlight on some of its best features!

The .NET MAUI Community Toolkits: Three (3) Essential Libraries for Every .NET MAUI Developer

Mobile

This talk will use working code examples in TypeScript to show ways to represent time and handle time zones, uses of the JavaScript Date object and Luxon date time library. We’ll also introduce Temporal, the upcoming ECMAScript standard.

The examples will be based upon my experience building applications in parking, scheduling, and logistics with complex requirements for date and time representation, and I look forward to sharing some of the lessons I’ve learned along the way.

It’s About Time! Practical examples of time zones in TypeScript

JavaScript

The usual way to achieve fast, efficient and effective Continuous Code Reviews without disrupting the flow of delivery is through Pair Programming or Team Programming. However, for various valid reasons, these can be a cultural stretch for many teams and organisations.

In 2012, a novice team practising trunk-based development set in place a fairly uncommon but efficient alternative to implementing continuous code reviews on mainline without ever blocking the flow of delivery.

This team went from a bunch of rag-tags to becoming a reference team within the organisation, with auditors falling to the floor due to the high quality the team delivered.


Non-Blocking Continuous Code Reviews, a Case Study

Agile

Workskills

We'll cover the forms of modern telemetry for .NET applications. Starting with centralized semantic logging, we'll emphasize the secret sauce that will make your coworkers love you: semantic logging scopes! Once you see them in action, you'll never want to be without them!

Other forms of telemetry are also included. Leaning into the Open Telemetry standard, we'll cover how to add metric measurements and timings into your application with extremely low overhead.

We'll also cover techniques for distributed tracing, including the standard span-based approach as well as linking techniques for disassociated backend processors. Throughout this talk, we'll cover common visualization tools that are compatible with your newly-instrumented applications.

By the end of this talk, you'll have concrete ideas to take back to your day job, earning you the respect and heartfelt thanks of anyone who has to track down issues in your website or client application!

.NET Telemetry in the Real World

DevOps

The industry has come up with completely new ways of working with graph data, which we’re going to take for a test drive in this talk! We’ll check out what changed in Neo4j, the only major graph database that is still with us after 10 years. Then we’ll discuss in-process analytical graph databases, which is an idea that didn’t even exist until just a few years ago. In particular, we’ll test KuzuDB and Memgraph with some demos and discuss when to use them. We’ll look at graph processing engines, like PuppyGraph, and see what makes them different from databases. Finally, to understand why graph databases have become more important than ever in the age of LLMs, we’ll build an AI agent augmented by a knowledge graph served from FalkorDB.


Modern Graph Databases

Big Data

Database

GenAI

You’re not inexperienced. You’re not lazy. You're not bad at your job. The issue is that no one’s real experience matches the cloud-native stories told in public.

We are surrounded by a narrative of effortless success: platforms that scale cleanly, teams that “just adopt Kubernetes,” architectures that assume infinite time, talent, and budget. Conference talks are polished. Case studies are sanitized. Failure is implied to be a personal shortcoming.

Privately, most practitioners are struggling. Technology is complex and brittle. Upgrades are painful. On-call is exhausting.

This talk argues that what we’re experiencing isn’t just impostor syndrome — it’s pluralistic ignorance amplified by burnout. Everyone is struggling, but no one admits it, because admitting feels like failure. So we stay quiet, internalize the gap, blame ourselves, and push past our limits.

In this talk, I want to say the quiet part out loud and break that silence together.

This talk is for everyone who's tired of pretending and who wants honesty instead of hype. We’ll explore how hype fuels self-doubt, why feeling “behind” is often realism, and why collective honesty—not more expertise—is what the cloud-native ecosystem is missing.

If you’ve ever thought “everyone else seems to have this figured out” — this talk is for you.

If You Feel Behind, You’re Probably Paying Attention

Learn about all the wonderful built-in ways to deal with date formatting, lists, currencies, items and sentences in any language you can throw at the browser, without shipping literal megabytes of packages to your user.

INTL: The best browser API you're not using

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

Accessibility

Some very cool things, that's what. I've worked on systems with the Functional core / Imperative shell architecture the last 9 years, and will share what I've learned.

Functional core, imperative shell: An architecture turned inside out

Functional Programming

In this workshop, we will learn about the important concepts around authoring web components as well as the technologies used to create, test, and distribute web component libraries for others to enjoy.

Workshop (60 min)

Part 1/2: Web Components 101: No Framework, No Problem

By leveraging the GDPR, we looked into various questions: How often do people lose or damage their phones? Where did they travel? And how regular are their sleep patterns? Alongside detailed insights into Spotify data, we provide a brief overview of the legal framework and examine how strictly other companies comply with the GDPR. While everyone in theory understands that data can hold immense power, this talk presents concrete examples – particularly given that we're dealing with what seems like just a music app.

The Sound of Privacy – What Your Spotify Data Reveals About You

We build layer upon layer of abstractions because that's how it's always been done, not because the problem demands it. The same happens in the kitchen, at the gym, and many other places in our life: we do things because we've always done them that way. We forget to ask "why?"

We talk a lot about building software fast, but do we remember to ask why we're building this particular thing? In an age where AI can generate code faster than we can think, the ability to ask "but should this code exist?" becomes more important than ever.

In this talk, we'll explore how to stop, ask the right questions, and make intentional choices, with a simple framework you can use right away. In your code, your architecture, the way you work and in your life.

Build With Intent

Work skills

What's coming next in C#

Programming Languages

In this talk, Ash (an experienced UX researcher and designer) will take you through the basics of UI design to help your screens look clean, professional, and pleasing to the eye.

Spaces, squares, and circles - an intro to UI design

Users retry actions mid-flight. They interrupt firmware updates. They unplug devices under load. They optimise for speed over safety. And when software interacts with physical systems, those behaviours become architectural risks.

In this session, we'll dissect real-world failures from connected products and explores how unpredictable human behaviour cascades into state corruption, retry storms, inconsistent device-cloud views and recoverability problems.

You’ll learn how to:
- Model human behaviour as hostile or non-deterministic input
- Design state machines that tolerate interruption and repetition
- Make critical flows idempotent across device and cloud
- Build systems that degrade safely when users don’t behave as expected

If your software leaves the browser or the data centre, this talk reframes reliability as a human systems problem, not just a technical one.

Humans Are the Most Unreliable Node in Your System

And so the mass layoffs begin, even before the leftover employees have been trained to use these tools. You try explaining that the benefits in productivity and costs have not yet been reliably tested, but it is too late. Management only sees thousands of lines of code being generated in seconds, and that is what they care about.

So what do you do? Easy: you come to this session, and share all the takeaways with them!

Join us to learn about all the things that LLMs (and hence agents and any derived tools) are horrible at: from risks and challenges that are inherent to their architecture, critical issues that are not solved yet, to all the tasks where they perform pretty badly and we humans will (most probably) always be needed. All accompanied by personal learnings and experiences, but also major publicly known failures that costed companies millions. Millions that your company will save if they keep YOU in their workforce.

Software developers: this is your quick-start guide on how to keep your jobs secure. No technical terms that managers will not understand, nor fluff that will make them miss the point. Simple, bold, direct facts that will open their eyes (backed with real business use cases and Excel-friendly numbers whenever a little extra scare is needed).

Why LLMs Suck (aka the Software Developer's Guide to Keeping Our Jobs)

Ethics

In this session, we focus on two key innovation areas: AI & intelligent data workloads and developer productivity.
We explore how new features such as the vector data type, vector search functions, and direct calls to embedding models enable semantic search and Retrieval-Augmented Generation (RAG) scenarios directly from SQL Server and Azure SQL.

We then dive into the expanding T-SQL feature set that significantly improves developer efficiency, including:
* Calling REST endpoints from within the database
* Using regular expressions for advanced pattern matching
* Fuzzy string matching for data quality and deduplication
* Enhanced JSON processing for semi-structured data

The session will be practical demos only and helps you understand not just what is new, but how and when to use these features effectively in real-world SQL Server and Azure SQL solutions.

What's new in SQL Server 2025 and Azure SQL Databases

Cloud

In this atypical overview talk, you'll get a practical tour of the CSS features that let you keep and respond to state — from things you can ship today to the cutting-edge stuff landing in browsers right now. Welcome CSS, to the state machine.

CSS State Machine

Kiota generates this client logic and request handlers to call REST APIs in multiple languages for you. In this session we are going to focus on .NET and dive into the specifics and details to make it a first-class citizen in a modern distributed application landscapes.
We will look at how Kiota helps you create a production-ready client library that can be shared alongside your API. These client SDKs allow easy consumption and offer a robust and resilient integrations to APIs. You are also going to learn how to properly test these libraries in various scenarios.
Also, we will dive into Kiota generated code including the RESTful object model, DTO mappings and also as a tool, how to use it in your CI/CD pipeline and some advanced scenarios such as telemetry and resilience strategies.
After this session you will be eager to start using Microsoft Kiota and begin building smart API clients and libraries.


Using Microsoft Kiota to go from OpenAPI to first-class .NET client SDKs

There is a distinction between a number that is zero — and the many ways we have of representing that number — and the absence of a thing, as well as a distinction between absence and emptiness. These distinctions have both practical and conceptual consequences that lead to surprises in code, in UX, in .NET and beyond.

There are a non-zero number of things to learn in this talk about nothing.

Much Ado About Nothing

Like many developers, I embodied the classic stereotype: Developers don’t do sports. I’ve been nerdy and, let’s face it, a little bit overweight my entire life. My first memories of sport participation involve being picked last for the team and ridiculed for trying.

But when I discovered the strength sport of powerlifting that all changed. What started as a casual pursuit of a niche sport quickly became a large and important part of my life.

In this talk, I’ll share with you
- Why individual pursuits still require teamwork
- Why enjoying the process is half the battle in reaching the desired outcome (and some strategies to achieve that)
- Why facing your fears often and in small doses leads to unmatched levels of badassery that will have you confronting challenges head on

Attendees will leave this talk not only with concrete actions they can bring to their life and work, but also inspired to try something new.

How Powerlifting Made Me a Better Software Engineer

How could it go this far? And where were the police when he needed them the most?

One of the reasons this was not followed up was something as basic as IT systems that did not communicate well enough with each other.

We are now building a data platform to address this—and dozens of similar cases. We connect data from multiple systems into a single distributed, flexible, and scalable platform, where data can be analyzed across sources for intelligence, optimization, and to develop a more data-driven and digitally advanced police force.

Along the way, we have encountered many challenges.

This is an honest presentation about what it’s like to build a data platform in a large organization. You will hear about both technical and organizational challenges, how we are working to solve them, and the potential of a data platform to transform policing in Norway.


Preventing crime with data - Building a data platform for the police

There's a better way. Instead of scripting interactions, we can give elements in our system their own intelligence. Multi-agent collaboration lets us create systems where entities are agents with their own perspectives and voices. Imagine an adventure game where the brass lantern, the white house, and the mailbox have something to say when responding to the player. Or consider a help desk where agents from billing, support, and legal weigh in to determine a course of action for a customer.

In this session, we'll build a text-based adventure game—you know the one—that works like this. You'll meet the orchestration workflow—router, agents, arbiter, committer, and narrator—and discover how LangGraph.js coordinates the chaos. We'll shine our brass lantern over the code to see how it all works. And, to make your boss happy, we'll discuss how this same approach solves problems beyond gaming.

When the adventure's over, you'll understand how to orchestrate agents to handle complex interactions. And you'll have a working example you can adapt for your own adventures—be they exploring the Great Underground Empire or building a customer service platform.

Agents & Arbiters - An Adventurer’s Guide to Multi-Agent Collaboration with LangGraph.js

Gaming

By now most of you have set up your own coding agent, maybe with sub-agents, custom instructions, and skills. But how do you go from a useful assistant to a system that runs autonomously, overnight, unsupervised, in production?

I'll walk through how we built a fully autonomous development workflow at Nordic Corporate Bank where an AI agent picks up a task, implements the solution, runs tests, creates a pull request, and reviews its own code, all before a human ever gets involved.

When developers open their laptops in the morning, finished pull requests are waiting for review. Build failures and production exceptions are automatically routed to the agent, which fixes them right away. Developers spend their time on architecture, design, and the problems that actually require a human, plus building the system that builds the system.
This is not a proof of concept or a keynote demo. This is code deployed to production every day. In a bank.

How We Built an Autonomous Development Workflow at Nordic Corporate Bank

AI-Assisted Development

Then, LLMs entered the chat. They answer our questions confidently and with a beautiful prose, even when they are making up data. Explainability then becomes essential to trust -or not- their output. But when the existing explainable AI methods cannot be directly applied to these models, what do we do?

In this workshop, we will delve into explainability and its importance in the current context of LLMs and agents. Starting from traditional ML to then focus on LLMs, we will cover the different methods that can be implemented, from well-known ones to novel proposals stemming from our internal research. We will also introduce research-proven prompting strategies, tips, and tricks to integrate explanations on third-party LLM services that are not natively explainable.

Through guided exercises, you will get to peek under the hood of AI models, LLMs' behavior, and agents reasoning, by trying out these different techniques, and seeing their benefits and limitations first-hand. You will experience the risks and challenges that generative AI and agentic AI bring when implementing explainability, and learn practical ways to tackle them.

Part 1/2: From Hallucination to Justification: Hands-On Explainability for LLMs

In this workshop you will learn basic functional programming with F#, while creating geometry. We will explore algebraic data types, lists, functions and recursion, all to make the turtle move. We will make polygons, fractals and space filling curves, and look into some mathematical properties of these geometric shapes. You can choose to concentrate on the F# tasks at hand, or you can allow yourself to be distracted by the beautiful geometry, and continue to explore different variants of the shapes.

The geometry in the workshop is based on the first chapters of the classical book "Turtle geometry" by Abelson and diSessa.

Bring your laptop, and if you want to come prepared, check out the “Getting started” section at https://github.com/heidisu/turtle-geometry.

No previous experience with turtles or F# is required.

Part 1/2: Fun with F# and turtle geometry

IoT systems at scale are different. The production environment is constrained by real world physics, where devices are deployed into parking cellars with poor cellular connectivity, or outdoor garages with flaky Wi-Fi. At this scale, hardware issues show up, cables degrade and human errors happens.

When we have 1 million connected devices, different classes of problems show up. Even if one device operates correctly on an individual level does not imply that the system operates correctly for 1M devices. Synchronized behavior, like devices checking for updates at midnight, quickly turns into a thundering herd that violates your service quotas and connection pools.

We will talk about how our rapid growth outgrew the initial system design and caused production to go down for several days. Retry logic and home automation systems became self-inflicted DDoS attacks. Non-essential services became global bottlenecks.

This talk is an experience report about the incidents and learnings from running Easee’s IoT Platform through a period where Easee scaled from 0 to 1 million chargers, in a journey of growth, near-collapse, and the way back.


1 Million Ways to Break Production: IoT Systems at Scale

In this talk, we will migrate an existing ASP.NET Core controller-based API to a minimal API approach together. During the migration, you will learn what the minimal API approach is all about and what the benefits of this approach are for you as a C# developer. Of course, we will discuss how to keep a good separation of concerns in the migrated code as well, because that is a major benefit of using controllers.

Do not expect a lot of slides in this talk. Most of the talk will be spent in code.

So come to this talk and leave with enough knowledge to be able to start migrating your existing Web API into this new minimal API approach and be ready for the future.

Refactoring an ASP.NET Core WebAPI Controller based API to a minimal API

This is hardly a hot take - many programmers prefer working in typed languages. But the best part? Types can do much more than most of us realize - catching bugs at compile-time is just the tip of the iceberg.

I didn't realize how powerful types truly were until I spent some time in Haskell. When I got back into TypeScript, it turned out I could keep using almost everything I'd learned.

Functional languages offer unique ways of working with types, and most modern languages let you tap into these powers without forcing you into obscure patterns.

You will learn how to:
- Think of types as sets of values.
- Model business domains with surgical precision
- Make incorrect code impossible, eliminate unit tests, and reduce the need for documentation.
- Apply practical type-driven design patterns (ADTs, branded primitives, smart constructors...).

This talk presents a fresh perspective on type systems through a familiar language. The examples are in TypeScript, but the advice is general.

Types Are Worth the Typing

In academia, the discourse is centered around two core questions. Firstly, what are the skills and competencies we should teach the students that enroll in computer science studies this fall? And secondly, how do we get them there, to that desirable set of skills and competencies? There is a tradeoff between building a solid foundation along the lines of traditions in the field, versus bringing in agentic workflows, or other technological specs that can be found directly in job listings. This tradeoff is not entirely new, but the educational and technological landscape of today permeated by GenAI is forcing the issue.

This talk attempts to give a peek into how the computer science education branch of academia is reacting in these times of uncertainty. How can we bring back the euphoria and passion that strikes when you finally figure that thing out after a week of debugging?

Software Developer Graduates 2031

Today with the newly supported functionality provided by Interest Invokers used in combination with the Popover API, we can radically simplify our implementations. This talk will cover what interest invokers are, how to implement them, position and style them, and and reasons to use them over the historical JavaScript techniques.

Rethinking Tooltips with Interest Invokers and Popover API

Because here’s the unexpected part: the same mindset we use in tech, problem solving, iteration, systems thinking, resilience, turns out to be incredibly useful when you’re rebuilding your life from scratch.

I’ll share what it’s like to navigate loss at scale, how to deal with the mental load of starting over, and how staying positive isn’t about pretending everything is fine, but about choosing what to build next. Along the way, we’ll look at how technology became both a tool and a lifeline. From rebuilding infrastructure on the farm, to creating content that connected me with a global community, to using automation and systems thinking to regain control in chaos.

This is a story about failure you didn’t choose, recovery you have to design, and how the skills we use every day as developers can help us, and others, get back up again. If you’ve ever faced setbacks, big or small, this talk will give you a different way to think about resilience… and maybe a few ideas for how to rebuild stronger than before.

The Day My Farm Burned Down

Jeff Fritz TBD

In this session, we’ll break down what it actually takes to deliver enterprise AI systems that make it to production and create real value. Drawing on real-world implementations across government, finance, and education, we’ll show why AI success is an ecosystem problem—not a model, prompt, or framework problem.

You’ll see how modern enterprise AI systems are built and explore how the Microsoft AI ecosystem (Foundry, Fabric, Copilot, and emerging “IQ” layers) is converging into a unified intelligence platform—and what that means for how developers design systems today.

Along the way, we’ll unpack the most common failure patterns and more importantly, we’ll show what actually works: - how to move from pilots to platforms
how to build an enterprise intelligence capability iteratively, and
how to deliver measurable value early while laying the foundations for agent-driven systems.

For developers, this talk introduces a fundamental shift in the role itself. You’re no longer just writing code - you’re orchestrating intelligence across low-code and pro-code agents, data platforms, copilots, and governed systems.

This is the rise of the Full-Stack AI Engineer.

If you want to move beyond demos and build AI systems that scale, ship, and survive real enterprise constraints—this session is for you.

From Code to Intelligence: The Rise of the Full-Stack AI Engineer

So if the harness is solved, what's left to build? Enter Agent Skills.
What differentiates my agent from yours is not the loop — it is the skills and tools we equip it with. A generic agent plus the right skills becomes a legal analyst. The same agent plus a different set of skills becomes a deployment engineer, a financial controller, or a research assistant. Skills are how you go from a tool-calling chatbot to an agent that actually does the job.

In this talk, we will use the Claude Agent SDK as our harness — solved, off-the-shelf, no reinvention required — and focus all our energy on the layer that actually matters. You will get a clear mental model of the skill + tool stack, live demos of building skills two ways (with the skill creator pattern, and by capturing real workflows as reusable capabilities), and a practical playbook for composing skills with MCP servers and CLI tools to build the "everything agent" your team actually needs.

Stop building harnesses. Start building skills.

Build Skills, Not Agents

Keynote: Who are you?

In this talk, Maddy Montaquila, lead PM for Aspire, shares her grounded perspective from the front lines, drawing on her work making Aspire the best platform for building agentic applications - and making Aspire itself agent-enabled.

It's possible to build AI-driven applications with coding agents, without giving up control, clarity, or your sanity. Join Maddy to learn about how using the right abstractions, strong defaults, and guardrails can let AI accelerate development instead of derailing it.

Use AI to build AI (without losing your mind) with Aspire

Across a guided, multi‑part lab, you’ll practice context engineering, design‑first UI exploration, test‑driven workflows, and multi‑agent orchestration using both local and cloud‑based agents. You’ll learn how to shape agent behavior, create specialized agents that support different phases of development, and integrate them into your everyday workflow.

By the end, you’ll have a practical understanding of how agentic development transforms the way software is built — enabling faster feature delivery, higher quality, and a more collaborative relationship between developers and AI.

Part 1/2: Context engineering, custom agents, and AI-first dev workflows w/ VS Code & GitHub Copilot

This session shows how an AI‑driven, always‑on toolchain became their shared workspace and reasoning engine, reshaping collaboration and redefining what building software feels like.

We stopped writing code, but shipped more code & products than ever before

Talk 1: When the code is not working for you - Helén Persson


Code can be running fine, but still not work great for us as humans. Maybe you have inherited a piece of legacy code? Maybe you are drowning in Dependabot alerts? Lets talk about how you can leave the code base better than when you found it.

Talk 2: Cognitive load is misunderstood - Sveinung Sande Dalatun


Is experiencing high cognitive load always bad? Does it make sense to talk about cognitive load on the team level? Are we better able to think about the big problems if we offload the small ones?
Cognitive Load Theory has become popular the last years, and its jargon is used everywhere. But with popularity comes misunderstandings. How can we move beyond the oversimplifications towards a vocabulary that is both more precise and more useful?

Talk 3: Reinventing the wheel considered useful - Erik Schierboom


Programmers are taught not to reinvent the wheel. This "wisdom" is rarely questioned, but there are very good reasons to go against this advice!

In this lightning talk, you'll learn why reinventing the wheel can actually make your software more secure. You'll also see how reinventing the wheel is a great way to improve your skills, which is becoming even more important with the advent of AI-assisted code generation.

Talk 4: Good enough - A love letter to failure - Elin Brusberg


This society is tough, getting tougher.
You may feel that more is required of you every day, and you are probably not wrong. I would argue though that the path to excellence lies not in perfection but in failure, and if you truly want to be better in life and work you need to switch focus and lean into the unpredictability of life.

Together we will reflect on tech failures and learn from them. What mistakes can you not come back from? When can a failure be a stepping stone to achieve your goal? What can you do to get less of the first and more of the second?

Maybe you will disagree with me and maybe you will see that failure not only is an option - it's a good one.


Lightning Talks 1

Talk 1: Power Games – From Fear to Freedom - Shomaila Kausar


Power dynamics (called Hersketeknikker) aren't a relic from 1981, they're alive and well in today's workplaces, in meeting rooms, on Slack, and in code reviews.
In this talk, we take theese manipulation tactics out of the textbooks and into reality. You'll learn to recognize them when they happen — directed at you, around you, or perhaps without even realizing you're using them yourself. And most importantly: what you can actually do about it.
For those who experience it.
For those who witness it.
For everyone who wants to contribute to a healthier workplace.
Because the tech industry deserves psychological safety — not just technical excellence.

Talk 2: 400 tech leads, same problems - none of them technical - Anemari Fiser


After training and coaching more than 400 tech leads across different companies, industries, and levels of experience, one pattern keeps repeating: when tech leads struggle, it’s rarely a technical gap.
In this talk, Anemari Fiser shares the most common challenges tech leads bring into coaching sessions and why “getting better technically” almost never fixes them. Instead, the real blockers show up as overload, unclear expectations, ownership confusion, and assumed alignment. These patterns consistently lead to slow decisions, delivery friction, and burned-out tech leads, even in teams with strong engineers and modern tooling.
Drawing from real coaching sessions, training group discussions, and concrete case studies, this talk explores where tech leads consistently get stuck. For each pattern, it looks at what the tech lead thought the problem was, what it turned out to be, and the small but meaningful shifts that helped them move forward: from rethinking 1-on-1s, to making expectations explicit, to letting go without losing trust.
This isn’t a talk about abstract “soft skills.” It’s about the invisible leadership work tech leads are expected to do without ever being taught how.
Attendees will leave with concrete ways to spot people problems early, make expectations explicit, and reduce the load they carry as tech leads.
If you’ve ever thought, “I didn’t expect the role to be this hard,” this talk is for you.

Talk 3: Conway's law in real life - Oda Hoem


A journey through the challenges and frustrations of being a developer in a product team within a non-product-oriented organization. What happens when you are thrown into a project where a ready-made solution is purchased to replace a critical subsystem—without completing the job of understanding existing processes or integrations? This talk dives into the concrete problems that arose, how we handled them, and the lessons learned after working with a product that was supposed to solve everything, but instead created more chaos

Talk 4: China's App Independence vs Europe's US Dependence - Jill Sarandi


From WeChat to Alipay, China’s digital landscape is dominated by homegrown platforms that shape daily life. In this talk, we’ll explore the contrast between the apps powering China and those popular in Europe, and why this matters more than ever. But the conversation doesn’t stop at comparison. I’ll argue that Europe’s future hinges on its ability to build and embrace its own digital platforms - platforms that reflect European values, protect user data, and foster innovation on home soil.


Lightning Talks 2

Part 2/2: Context engineering, custom agents, and AI-first dev workflows w/ VS Code & GitHub Copilot

Part 2/2: Fun with F# and turtle geometry

Part 2/2: From Hallucination to Justification: Hands-On Explainability for LLMs

Part 2/2: Web Components 101: No Framework, No Problem

In this session, we’ll walk through the 10 most common Azure missteps I've encountered in the real world, including gotchas in account organization, governance, compliance, performance, and how developers are misusing DefaultAzureCredential to authenticate to Azure.

Whether you’re deep into your cloud journey or just getting started, odds are your team is making at least one of these mistakes. By the end, you'll leave with practical, actionable advice to spot these issues early and fix them fast — before they turn into bigger problems.

The 10 Most Common Azure Mistakes (And How To Fix Them)

We used the rebuild as a chance to rethink their hosting architecture, moving from traditional web app hosting to a container-based setup using Azure Container Apps. This allowed us to align their infrastructure with their goals around performance, cost efficiency and sustainability.

By adopting scale-to-zero containers, we delivered:

An average 85% reduction in hosting costs and carbon emissions

Faster, cleaner deployments using GitHub Actions with zero downtime

A platform that is cheaper, greener and ready for the future, without compromising on developer experience

This is a practical, behind-the-scenes look at the decisions, trade-offs and real-world impact of using scalable, container-native infrastructure to power a major public website.

Whether you're modernising legacy systems, exploring containerisation or looking to make your web estate faster, leaner and more sustainable, this session shows what is possible when you bring smart engineering and real-world constraints together.

NDC { Oslo }

Agenda

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

Use AI to build AI (without losing your mind) with Aspire

Maddy Montaquila

What's coming next in C#

Fred Silberberg

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

The .NET MAUI Community Toolkits: Three (3) Essential Libraries for Every .NET MAUI Developer

Brandon Minnick

Refactoring an ASP.NET Core WebAPI Controller based API to a minimal API

Johan Smarius

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

Part 1/2: Context engineering, custom agents, and AI-first dev workflows w/ VS Code & GitHub Copilot

James Montemagno

Kayla Cinnamon

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

.NET Telemetry in the Real World

Stephen Cleary

Part 2/2: Context engineering, custom agents, and AI-first dev workflows w/ VS Code & GitHub Copilot

James Montemagno

Kayla Cinnamon

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

Using Microsoft Kiota to go from OpenAPI to first-class .NET client SDKs

Alex Thissen

Much Ado About Nothing

Kevlin Henney

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

1 Million Ways to Break Production: IoT Systems at Scale

Jan-Erik Carlsen

Eirik Ottesen

Going Passwordless - A Practical Guide to Passkeys in ASP.NET Core

Maarten Balliauw