Your RBAC table has 4000 rows - OpenFGA to the rescue en

Every system starts with roles: Customer, Advisor, Admin. Then the real world walks in. A customer may see their own accounts, and those of the minor child they hold a mandate for. An advisor sees their portfolio, until a colleague takes over during a vacation. A large payment needs a second pair of eyes, but not the eyes of the person who created it. Suddenly your role table has 4,000 rows and your if statements read like a hostage note.

In this session we replace that mess with relationship-based access control, the Zanzibar model behind Google's authorization, using OpenFGA. We use this to authorize users of a banking API built with ASP.NET Core. Authorization becomes a question you ask ("may this user do this to that object?") instead of logic you scatter across services.

Along the way we handle the hard parts: four-eyes approvals, time-limited mandates, listing "everything I may see" without N+1 checks, keeping relationship data in sync, testing your access rules in CI, and migrating from roles without a big bang.

You'll leave with a working reference model, a migration plan and a healthy respect for the question "who may do what?"

Platform engineering: making organizational, cultural and technical choices en

This session explores key concepts of platform engineering, the responsibilities of platform and application teams, and the cultural dynamics essential for successful collaboration. Gain actionable insights from real-world examples to enhance your platform engineering practices. The speakers will share their practical experience with designing, building, and operating a standardized platform for running cloud-native applications.

Get up to speed with Dapr en

Dapr provides a set of powerful building blocks to make our developer lives easier when building distributed applications. With features like service location, state management and pub/sub, Dapr solves common distributed system problems so you can focus on implementing business logic.

In this session, we'll show you how you can leverage the latest Dapr features in real-world scenarios to significantly reduce the complexity involved in building microservices.

Attendees should have a basic understanding of Dapr.

Attendees should have a basic understanding of Dapr.

Dapr workshop: build microservice applications the easy way en

Dapr is an open source, event-driven, portable runtime for building microservices. It provides powerful building blocks to make it easy for developers to build resilient microservice applications using a variety of languages and frameworks.

In this session you will get an introduction of Dapr and the Dapr building blocks. After that, you will learn how to apply Dapr yourself in a sample application during the hands-on part of the workshop.

The workshop features step-by-step instructions so you can work on this at your own pace. During the workshop you will get hands-on experience with the following Dapr building blocks: service invocation, state management, pub/sub, bindings and secret management.

Advanced Dapr en

Dapr is an open source, event-driven, portable runtime for building microservices. It provides powerful building blocks to make it easy for developers to build resilient microservice applications using a variety of languages and frameworks.

In this session we'll go beyond the basics and talk about advanced topics such as security and access control, rate limiting and integration with frameworks such as Azure API Management and Logic Apps. We assume that attendees already have a basic understanding of what Dapr is.

Dapr: build microservice applications the easy way en

Dapr is an open source, event-driven, portable runtime for building microservices. It provides powerful building blocks to make it easy for developers to build resilient microservice applications using a variety of languages and frameworks.
In this session we'll introduce the Dapr building blocks and show how they can be applied in a .NET microservices application. You'll learn about both the benefits and the limitations of using Dapr.

Symphony No. 42 in C#, Op. 1, Conducted by Dapr Workflow en nl

Dapr Workflow is a Dapr building-block that can be used to orchestrate tasks and create long-running, fault-tolerant, stateful processes. In this session I am going to demo how to use it in a .NET application and give you a glimpse under the hood to show you how it works internally.

Symfonie Nr. 42 in C#, Op. 1, Gedirigeerd door Dapr Workflow en nl

Dapr Workflow is een Dapr building-block dat gebruikt kan worden voor het orkestreren van taken en het creëren van langlopende, robuuste, stateful processen. In deze sessie geef ik een demo van hoe het gebruikt kan worden in een .NET applicatie en geef ik een kijkje onder de motorkap om te laten zien het het intern werkt.

How to build resilient Microservices with .NET Core and Docker en

Learn how to leverage ASP.NET Core and Docker to build a resilient microservices based application. The session starts off with a short introduction of .NET Core and Docker and an explanation why .NET Core and Docker is a match made in heaven. After that it's all demos and code. The topics covered during the session are: microservices architecture, event-driven architecture, CQRS pattern, eventual consistency, resiliency using Polly and development and deployment using Docker containers. The emphasis for this session is on the software-architecture and the code!

The source-code and an elaborate description of how to run the demonstrated solution locally is available on Github and will be shared with the audience.

Build scalable and resilient systems with Akka.NET en

The Actor Model programming paradigm for building highly concurrent systems was defined back in the seventies. In this session attendees will learn about Akka.NET, a modern open-source framework that can be used to build highly concurrent systems based on the Actor Model programming paradigm. The session introduces the Actor Model concepts and an overview of the Akka.NET framework. This will be followed by a deep dive into the code of a concurrent application built using Akka.NET.

How to get a grip on your microservices system using a service-mesh en

Many organizations are now building microservices based systems. But with the adoption of this architecture-style, the need arises for a good way to manage and monitor all the services and their traffic. To handle this, you can leverage what is called a service-mesh.

In this session attendees will learn what a service-mesh is and how to implement one for a microservices based system using Kubernetes and Istio. Topics covered are: intelligent traffic-routing, canary releasing, testing resiliency using chaos-engineering and monitoring using several available telemetry dashboards.

It's a very practical session with lots of demos and deep-dives into code and configuration. All the code shown in de demos (including an elaborate description on how to run the demo application) is available for attendees on Github.

How to build IoT solutions using Azure IoT Edge en

Azure IoT Edge is a service that enables you to build distributed IoT solutions that leverage "edge" devices. The IoT Edge run-time uses the power of containerization with Docker to run Machine Learning jobs, Stream Analytics jobs, Azure functions or custom code on edge devices like a PC, a Raspberry Pi, a robot or a drone. The first part of the session handles device management and deploying modules to your device from the IoT Hub. The second part will focus on how to build your own IoT Edge modules using Visual Studio Code.

For this session I need 2 solid internet connections. One can be WiFi but one needs to be UTP cable!

Building high-performance event-driven systems with NATS en

NATS is an open-source messaging system aimed at high performance and availability.

This session is all about NATS and NATS Streaming (a streaming server built on top of NATS). I will talk about the design philosophy behind NATS and why it differs from traditional message-brokers like for instance RabbitMQ. I will also walk you through the features it offers and finally I'll show you how to leverage NATS as the messaging infrastructure for event-driven systems.

I do this by demonstrating this in a working microservices based .NET application. Come to this session if you want to learn about NATS and NATS Streaming, when to use them (and when not to) and how to use them with .NET and C#.

Lessons learned implementing CQRS, DDD and Event Sourcing in .NET en

Over the last couple of years, I have been hired as the software-architect for several development teams with the assignment to build a new cloud-native and event-driven system based on a microservices architecture. .NET was selected as the primary development stack and this turned out to be a great choice. Most systems are still running in production today and fulfill the functional and non-functional requirements that were defined for the them.

The session will give an insight into the way .NET was used for implementing DDD, the CQRS pattern and Event Sourcing for storing state. It will cover the rationale behind the choices made and the lessons learned while designing and building this system. The session will cover both concepts as well as code.

Lessons learned from implementing BPM with Camunda en

Many organizations are looking for ways to implement Business Process Management (or BPM). There are several tools available that offer BPM functionality. But integrating these tools into the existing IT landscape is hard. These tools never offer the exact functionality as needed by the organization. Is it possible to extend the functionality with custom code? And how do you prevent massive vendor lock-in and tight coupling between the tool and the rest of the systems in the IT landscape?

In this session, I will share the experiences I have gained from implementing BPM with Camunda in several real world projects. I will show you which integration patterns work welland which architectural principles help to prevent lock-in and coupling.

One platform team, multiple customers: building a standardized integration platform (iPaaS) on Azure en nl

Most platform engineering talks are about tooling. Most platform failures are about something else: unclear boundaries, unsustainable operations, and a mismatch between what the platform team built and what customers can adopt. This session tells the story of an integration platform (iPaaS) built on Azure Integration Services, from first idea to an actual integration platform that has been running in production at multiple customers.

Azure gives you every building block for integration. Turning them into a platform that one team can operate for many customers is another matter. This session shares the lessons learned while building the platform, evolving it over time and operating it for multiple customers. I will share the principles that made this possible and the way we govern the product.

Principles are easy to write down and hard to live by, especially when they conflict. The core of the session addresses the tensions between them. We'll look at what each principle meant in practice, where they collided, and how we resolved the conflicts. Expect architecture, an overview of the platform, and honest lessons that we have learned. Whether you're building an internal platform or a commercial one, you'll leave with a set of principles to adapt and a clearer view of what makes a platform usable and maintainable.

Eén platform-team, meerder klanten: bouw een gestandaardiseerd integratieplatform (iPaaS) op Azure en nl

De meeste platform engineering-sessies gaan over tooling. De meeste platformen falen echter om iets anders: onduidelijke grenzen, onhoudbare operatie en een mismatch tussen wat het platform-team heeft gebouwd en wat klanten kunnen adopteren. Deze sessie vertelt het verhaal van een integratieplatform (iPaaS) gebouwd op Azure Integration Services, van het eerste idee tot een werkend integratieplatform dat inmiddels bij meerdere klanten in productie draait.

Azure biedt alle bouwstenen voor integratie. Die omvormen tot een platform dat één team kan beheren voor meerdere klanten is een ander verhaal. In deze sessie deel ik de lessen die we hebben geleerd bij het bouwen van het platform, het doorontwikkelen ervan en het beheren voor meerdere klanten. Ik vertel over de principes die dit mogelijk hebben gemaakt en over hoe we het product besturen.

Principes zijn makkelijk op te schrijven en moeilijk na te leven, zeker als ze met elkaar conflicteren. De kern van de sessie gaat daarom over de spanningen tussen die principes. We kijken naar wat elk principe in de praktijk betekende, waar ze botsten en hoe we die conflicten hebben opgelost. Verwacht architectuur, een overzicht van het platform en eerlijke lessen die we onderweg hebben geleerd. Of je nu een intern of een commercieel platform bouwt: je gaat naar huis met een set principes die je kunt aanpassen aan je eigen situatie en met een helderder beeld van wat een platform bruikbaar en onderhoudbaar maakt.

Architecture that tests itself: Fitness functions with Azure Resource Graph and Policy en

Architecture decisions rot. The diagram says "all traffic goes through the gateway," but production disagrees. Nobody notices until an audit, an incident, or a very awkward pentest report.

This session shows how to turn architectural intent into executable checks. Using Azure Resource Graph, Azure Policy, and a little code, we'll build fitness functions that continuously verify your decisions: no public endpoints, no cross-region data flows, naming and tagging conventions, and dependency rules between services. We'll wire them into CI/CD and scheduled runs so architecture drift becomes a failing build instead of a surprise.

You'll leave with a repeatable "architecture as tests" pattern, working examples to adopt, and a way to make ADRs enforceable instead of decorative.