In this workshop, we will explore agentic AI in the browser; systems that can observe their environment, make decisions, and take action using modern Web APIs. Participants will build autonomous, goal-driven agents that run entirely in the browser, without relying on server-side execution for core behaviour.

Through hands-on exercises, we will implement an agent loop, run agents inside Web Workers, persist state using IndexedDB, and safely expose browser capabilities such as file access and notifications. We will also focus on guardrails: permission models, explainability, user control, and offline-first operation.

By the end of the workshop, attendees will have a working agent architecture and a set of practical patterns they can apply to real-world web applications and internal tooling.

2 Days

1-2 June

Agentic AI in the Browser: Building Autonomous Web Agents

JavaScript

GenAI

Most software starts out pretty simple: front end, back end, maybe a database, and you’re done. Then the client wants an API, a mobile app, notification emails, realtime chat; cloud gives you elastic hosting, apps that dynamically scale based on workload and traffic, and if you’re just starting out with distributed systems design, the possibilities can be overwhelming. APIs, message queueing, REST, GraphQL, gRPC… what should you choose, how does it work, how do you get started?

This workshop gives you a hands-on introduction to the most important messaging patterns used in modern application development. Using C# and .NET, we’ll build a series of small example apps and services, wire them together using these patterns, and discuss how - and why - you’d apply the same patterns in your own applications.


Working with HTTP APIs: testing and tooling

Interactive documentation with OpenAPI and Swagger

Distributed queues with RabbitMQ and EasyNetQ

Contract-first development using protocol definitions

Integrating browsers with distributed systems

Adding instrumentation to your distributed apps

Principles of observability: spans, traces, metrics and logs


This workshop is aimed at developers with some experience writing applications using C# and Microsoft .NET. The workshop can be run in person or online. Attendees will be writing and running .NET code during the workshop, so will need a computer running Windows, macOS or Linux, and the Microsoft .NET 10 SDK from 

. The sample application and examples used during the workshop all run on .NET 10, and are tested on Linux, macOS and Windows.

Building Distributed Systems with .NET 10

.NET

To be fair, the people who abuse this term are also the people who probably fall under this category. I prefer “Agentic Programming” instead. I have pushed thousands of lines of code in production using agentic programming. Code that would have taken me months to write myself now takes merely days.

In this workshop, we’ll explore agentic programming as a disciplined engineering practice, not a toy.
Using Claude Code, I’ll show how to collaborate with AI agents to produce maintainable, reviewable, and production-ready code, without surrendering architectural control, correctness, or performance.

What Claude Code is, how it works, and how you should use it.

Designing clear agent boundaries and responsibilities.

How to turn vague intent into explicit, testable instructions.

Create plans that can run for hours on end, generating and testing code as they go.

This is not a “let the AI take the wheel” session. It’s about teaching the AI to work like a senior engineer, while you stay firmly in charge. If you believe AI coding tools are dangerous, flaky, or fundamentally incompatible with serious software engineering, then this workshop is for you.



A laptop with your favourite IDE installed

Node (we will also cover .NET, but it is optional)

Vibe Coding for Production

This hands-on workshop will equip you with practical skills to implement your own MCP servers, clients, and MCP-enabled knowledge bases — and build interactive AI applications that connect your organizational knowledge to advanced AI models in a controlled, secure manner.

Day 1: Foundations — Servers & Knowledge

Introduction to Model Context Protocol and its business applications

Core MCP concepts: Server/client architecture, agents, resources, and tool calling

RAG fundamentals and architecture patterns

Hands-on exercises: Building a local MCP server and RAG pipeline

MCP Apps: Creating interactive AI-powered applications

MCP Clients: Building your own host applications

Deployment options: Remote MCPs, Cloud providers and hosting alternatives

Preparing for production: Security considerations and optimization strategies

Final exercise: Building an MCP App that exposes your knowledge base

Basic Python or JavaScript programming knowledge

Familiarity with AI/ML concepts (helpful but not required)

Laptop with necessary development environment

This training is targeted at developers and people with a medium+ technical skill level and interest for AI.



Bring your laptop with your preferred IDE and either Python or Node installed. We recommend an AI-coding agent like Claude Code, Cursor or GitHub Copilot, but not required!


 
You need access to an LLM provider with an embedding model like OpenAI or Azure Foundry, but you can also use Ollama if you would like to run everything locally and free.

Context Is King: Building AI Apps with MCP & RAG

In this hands-on workshop, you'll build AI agents that can reason about data, use tools, and hold meaningful conversations.

You'll create a personal finance assistant. An agent that understands natural language, retrieves transaction data, maintains memory across conversations, and helps users make better financial decisions.




- Working with Large Language Models: LLM fundamentals, prompt engineering basics, and raw API calls without abstractions.
- Calling AI services from C#.
- Tool calling: Giving agents the ability to take actions and retrieve external data.
- Reasoning loops: How agents think, plan, and iterate.
- Memory and context management: Maintaining state across conversations.

We'll use Azure AI services throughout the workshop, but the patterns and code apply to other providers like OpenAI, Anthropic, and Google.


By the end of this workshop, you'll have:


- A working AI agent integrated into a .NET backend
- Practical experience with tool use and memory
- A clear mental model for when agents add value versus simpler AI approaches
- Confidence to apply these patterns in your own applications


Yes, if you want to move beyond basic AI integration and build something that reasons. 


- Know how to build APIs with C#
- Have some exposure to AI concepts (prompts, completions, embeddings)
- Prefer learning by doing over slides and theory



- Your favourite IDE
- .NET 10
- Docker
- Git and a GitHub account
- An Azure account (expect around 5–10 € of usage)

Build Your First AI Agent in .NET

This two-day workshop takes a deliberate journey from foundational messaging concepts to the patterns required for real-world, production-grade systems. We’ll start with the simplest possible asynchronous designs—queues, events, and pub/sub—and progressively evolve them as new problems emerge: duplicates, message loss, scaling limits, partial failures, and long-running workflows.

Instead of presenting messaging patterns as a checklist, this workshop shows why each pattern exists, what breaks without it, and what trade-offs it introduces. Every step forward is motivated by a concrete failure mode.
Over two days, we’ll grow a system from:
“Messages get sent” to: “Messages survive crashes, retries, scaling, and time”
Patterns explored include:

- Queues, events, and pub/sub fundamentals
- Idempotent consumers and delivery guarantees
- Outbox and Inbox
- Competing Consumers and back-pressure
- Retries, poison messages, and dead-letter queues
- Sagas for long-running workflows
- Scatter-Gather coordination
- Claim Check, routing topologies, and messaging bridges

By the end of the workshop, you won’t just know these patterns—you’ll understand when you actually need them, when you don’t, and how to combine them without creating accidental complexity.

From Basics to Beyond: Building Production-Grade Messaging Systems

What are the different architectures? Why should we choose one over the other? Or should we choose a combination of them for some applications? How do we make such decisions? What should be the process or the approach that will lead us towards selecting a more suitable or appropriate architecture, one that comes from proper analysis rather than infatuation or desire to build something because that's seems to be the current trend.


In this workshop, we will take a very systemic approach to going from requirements to choosing suitable architectures. We will cover the following topics, not by simple talking about these, but by way of hands-on exercises and interactive and collaborative sessions:

- Challenges with selecting Architectures
-  Functional and non-functional requirements
- Evaluating trade offs
- Methodical Mapping from requirements to patterns
- Architectural Patterns
- Underpinnings of monoliths and distributed architectures
- Hands-on exercises to analyze application requirements
- Groups labs to evaluate the architectural patterns for different application characteristics
- Using AI to assist with requirements analysis
- Cautiously Using AI to guide along the selection process
- Next steps beyond choosing architecture




- Senior programmers
- Team leads*Architects
- Technical managers and directors



Dr. Venkat Subramaniam is an award-winning author, founder of Agile Developer, Inc., an instructional professor at the University of Houston, and creator of the dev2next and Arc of AI conferences.
He has trained and mentored thousands of software developers in the US, Canada, Europe, Asia, and Africa, and is a regularly-invited speaker at several international conferences. Venkat helps his clients effectively apply and succeed with sustainable agile practices on their software projects.
Venkat is a (co)author of multiple technical books, including the 2007 Jolt Productivity award winning book Practices of an Agile Developer. You can find a list of his books at <

NDC { Copenhagen }

Workshops

09:00 - 17:00 (UTC+02)

Vibe Coding for Production

Nick Chapsas

Context Is King: Building AI Apps with MCP & RAG

Aleksander Stensby

Build Your First AI Agent in .NET

Gui Ferreira

From Basics to Beyond: Building Production-Grade Messaging Systems

Poornima Nayar

Architectural Patterns: Common Solutions for Building Large Scale Systems

Venkat Subramaniam

Agentic AI in the Browser: Building Autonomous Web Agents

Nhlanhla Lucky Nkosi

Building Distributed Systems with .NET 10

Dylan Beattie