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

A clear understanding of how to identify opportunities for AI augmentation in existing

Practical experience integrating Azure AI services into a .NET backend

Confidence connecting a modern frontend framework with an AI-enabled

backend—even if you’re not a frontend expert

Yes—if you're curious about adding AI to your apps and tired of abstract theory with no real-world code. This workshop is for developers who:

Have a basic understanding of JavaScript and web development

The focus is on backend and AI. We’ll scaffold the React UI—and even use AI to generate parts

of it—so you can stay in your backend comfort zone while still building a full-stack experience.

Your favourite IDE (Visual Studio, JetBrains Rider, VS Code, Cursor AI, etc.)

An Azure account (expect ~5–10 € of usage)

Your preferred AI assistant (e.g., GitHub Copilot, ChatGPT, etc.)

2 Days

Build a Full-Stack AI App with .NET

.NET

This workshop is here to give you the skills you need to make your APIs secure. We're going to think like an attacker to test APIs and like a defender to figure out the best ways to protect them. With deep-dive talks, real-world demos, fun quizzes, and hands-on labs, you'll learn how to lock down your APIs.
During this hands-on training, we'll explore:

The security model of API-based web applications

Recognizing and addressing authorization failures

Understanding Broken Object Property Level Authorization (BOPLA)

Fixing Broken Object Level Authorization (BOLA)

Testing the security of APIs that use JWTs

Best practices for making JWTs secure in modern APIs

Identifying, exploiting, and fixing Server-Side Request Forgery (SSRF) issues

Understanding Cross-Origin Resource Sharing (CORS)

Configuring secure CORS policies for various use cases

Tracking user authentication securely with sessions or tokens

Relying on OAuth 2.0/2.1 for securing APIs

Q & A throughout the workshop to clear up any doubts


This workshop is about more than theory. We're all about giving you practical security tips you can use right away as an API developer. We dig into the root causes of API threats and how to handle them. We don't just skim the surface of problems and solutions - we get into the why's and how's, looking at common fixes, why some fall short, and which ones are currently the best way to go.
By the end of this workshop, you'll be up-to-speed on the best practices for API security. You'll also leave with a handy list of steps to check and boost the security of your applications.




This training is perfect for developers and architects who work a lot with APIs. If your role involves building, testing, or designing modern apps, this workshop will give you a thorough, up-to-date understanding of the best ways to keep things secure. We'll often use NodeJS, Flask, and Spring Boot in our code examples and demos, but you'll easily be able to apply what you learn to other languages and frameworks.




These testimonials from previous workshops give you a good idea of what to expect:

Trainer is great and an expert in the domain. All of the topics are very relevant. Practical examples for most of the topics. Excellent communication and addressing of questions.

Even though the topic is broad, there was no single moment where my focus went astray. Philippe talks in a way to keep you interested to listen to him.

I liked the the pleasant and relaxed way of speaking and the fresh style of presentation of this kind of dry stuff :)

Philippe is a friendly and knowledgable trainer and delivered an interesting course that was well presented. Questions were answered promptly and in a detailed way.


To participate in this training, you should have some experience with building API-based applications. Knowledge of application security can be helpful, but is not required.




To participate in the lab sessions, participants need a computer with a full-featured modern browser installed (preferably Chrome).


Bulletproof APIs: Hands-On API Security

Security

This workshop will teach you everything you need to know to start building distributed systems in .NET and ASP.NET Core and how to combine multiple services to choose the right tool for each use case you might encounter. We will define clear requirements for a system and proceed to build the entire system using all the services and tools you will use to build your own systems later at your company.

Defining the system we need to build with clear requirements

Understanding Monoliths and Microservices

Understanding what “cloud native” means

Implementing observability with OpenTelemetry

Using .NET Aspire to run our system locally

This workshop is for backend developers with some experience writing web applications using C# and ASP.NET Core. You must be able to read, write, and debug C# at a decent level and have some experience with ASP.NET Core.

Visual Studio 2022 or JetBrains Rider or Visual Studio Code with the C# Dev Kit installed

Building scalable, cloud native, distributed systems in .NET

In this two-day hands-on workshop, you’ll take a real-world .NET API built with Dapper and incrementally migrate it to Entity Framework—entirely using GitHub Copilot inside VS Code. We’ll explore all three Copilot modes—Ask, Edit, and Agent—along with prompting strategies, context engineering, and reproducibility patterns.

Create custom markdown instructions and project settings to control Copilot output
Use prompt-driven Git workflows to incrementally transform production code
Run side-by-side “audition branches” to compare Copilot outcomes
Tune Agent Mode using SQL schemas, code templates, and naming conventions
Use Copilot to track its own decisions, enable reproducibility, and support auditability

By the end, your team will have a fully migrated project—and a blueprint for adopting Copilot at scale without losing trust or control.

Day 1: Setup, Edit Mode, and Agent Preview

Overview of the project: Dapper-based mailer API

Why enterprises are moving to lightweight editors like VS Code and Cursor

Setting up VS Code with Copilot: extensions, modes, and configuration

Writing effective custom instructions (markdown + JSON)

Git best practices: .gitignore, branching, and Copilot-generated commits

Step-by-step Entity Framework migration using Edit Mode

Prompt shaping: how small tweaks yield better results

Error handling and recovery via conversational feedback

Agent Mode preview: Running the same EF migration in Agent Mode

Side-by-side comparison of Edit vs Agent results

Take-home exercise: create an “audition branch” for your favorite approach

Deep dive into Agent Mode setup and safety

Using SQL files and markdown to generate models and contexts

VS Code settings for commit formatting and structural consistency

Project-wide refactors with controlled automation

Review flow: understanding, editing, and approving AI output

Afternoon: Auditing, Reproducibility, and Closing the Loop

Capturing and saving Copilot conversation history

Tracking refactor decisions through commit messages and chat logs

Creating an internal “AI audit trail” with reproducible prompts

Team strategies for integrating Copilot with code reviews and pull requests

Workshop wrap-up: What worked, what didn’t, and what’s next

Vibe Coding with Copilot and .NET: Modernizing Your Stack One Prompt at a Time

Many developers, data scientists and companies are rushing to adopt and leverage these developments in their business process, products and solutions.

What do I need to consider when developing an LLM based solution?

What is a generative pre-trained transformer, and how does it work?

How can these models be leveraged by application developers to deliver real business value?

In this workshop, you will explore how to leverage the OpenAI and 3rd party models to develop AI enhanced solutions. You will learn options for hosting and consuming different models and develop code and prompts to explore their capabilities. The integration with company knowledgebases to provide a ChatGPT experience tailored to your business requirements will be covered along with the concepts of using prompt engineering to influence the outputs generated by the model.

Hands-on labs using the latest LLM frameworks will be available in C# and Python, ranging from walk-through exercises to advanced challenges and group activities.

Open AI & GPT Workshop

Machine Learning

Introducing the modular monolith; all the benefits of a monolith such as reduced complexity, ease of deployment, easier debugging, and so on - but ready to be easily decomposed into services as required.

Join us as we explore the principles, patterns, and practices that empower developers to build robust, flexible, and extensible applications without prematurely involving the complexities of microservices and distributed systems.

In this workshop, we will use the fictional case study of a thriving business aspiring to expand, exploring key topics.

We'll investigate the different requirements that need to be met, starting with a code kata and how we can apply various design patterns to our way of thinking.

We'll then move on to actually building out a functioning, all-be-it, contrived application in .NET 8 and C#, learning as we go.

Modular Design Principles: Learn how to break down your application into cohesive modules that encapsulate distinct functionalities, promoting code reuse and easier maintenance.

Dependency Management: Discover techniques for managing dependencies between modules, ensuring clear boundaries and minimising tight coupling.

Scalable Architecture: Explore strategies for designing monoliths that can scale vertically and horizontally to accommodate growing demands.

Architecture enforcement: Dive into architecture testing and other approaches that help with maintaining the architecture and design.

Performance Optimization: Gain insights into optimizing module communication and data flow to enhance the overall performance of your application.

Future Migration Considerations: Explore how modular monoliths can serve as a stepping stone towards a microservices architecture, and the factors to consider when planning a future migration.

Reverse migration: Understand the considerations and techniques for reverse migration from distributed system back to a monolithic architecture.

We'll also cover aspects of event-driven architecture, messaging, No-SQL databases, and various supporting design patterns.


This workshop is aimed at backend developers with some experience writing web applications using C# and .NET. The workshop will not cover .NET Framework.


This is a hands-on practical workshop where you will be writing a lot of code. You will need to have the following to effectively participate:

SQL Server 2017 or later, with SQL Server Management Studio or Azure Data Studio

NDC { Porto }

Workshops

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

Building scalable, cloud native, distributed systems in .NET

Nick Chapsas

Bulletproof APIs: Hands-On API Security

Philippe De Ryck

Open AI & GPT Workshop

Alan Smith

Building Future-Proof Apps with the Modular Monolith

Layla Porter

Build a Full-Stack AI App with .NET

Gui Ferreira

Vibe Coding with Copilot and .NET: Modernizing Your Stack One Prompt at a Time

Rob Conery