YARP - more than Yet Another Reverse Proxy

YARP (Yet Another Reverse Proxy) is a reverse proxy developed internally by Microsoft using the infrastructure from ASP.NET and .NET 6 or newer.

In this session we''ll go into the basics of YARP, and look at few use cases such as load balancing, rate limiting, A/B testing, transforming data, etc. All using real-life problems as a starting point.

We'll see how to deploy and customize YARP to your liking, and how it can provide an alternative to Azure API Management.

Azure Durable Functions - the good, the bad and the downright ugly

Azure Durable Functions can be very useful but they are a bit of a 'black box'. If you're not entirely sure what you're doing, you can set yourself up for hours of debugging trying to find obscure issues.

The goal of this session to make sure you know everything you need to avoid possible pitfalls, and to show you the inner workings of Durable Functions.

We will go over what the "Durable" in Durable Functions actually means and how that works behind the scenes. We will also look at example code for several typical use cases such as fan out/in and chaining.

Once we understand what Durable Functions are and how they work, we will take a look at the pitfalls I encountered while setting up, debugging and deploying a complex Azure Durable Function setup to production. We'll look at mistakes I made and how to avoid them.

If you're looking to get started with Azure Durable Function, this is the session for you!

The Modular Monolith: future-driven architecture without breaking the bank

In this session we will be taking a look at what a Modular Monolith is and why it's such a good choice for new applications from a business and technology standpoint.

We'll look at how so structure your monolith, how to set up the architecture, interesting libraries to use, common mistakes to avoid, ...

We'll talk extensively about terms like DDD, CQRS, Vertical Slicing, Event-Driven Architecture, and how these are important for a Modular Monolith.

Finally, once our Modular Monolith is set up, we'll look at how to start splitting of modules into their own microservices.

At the end of this project, you will have all the knowledge to build your own Modular Monolith successfully, while avoiding common pitfalls.

This is a minimum 1 hour session.

Refactoring your legacy applications the right way!

If you have worked in a legacy codebase or 'big ball of mud', you know that it can make development unnecessarily slow, frustrating and costly. The solution, many developers would say, is to just rewrite the whole thing. But good luck getting every stakeholder to agree to such a costly and risky process.

In this session we will take a look at the different ways you can clean up your codebase. while minimizing risk and costs. We will discuss some of the different strategies like the 'Strangler Fig Pattern' and we'll go over a few tips and best-practices on how you can avoid the same mistakes in the future.

How to be a good coach and set junior colleagues up for success

Do you want to enable your junior colleagues and have them become valuable members of your team? Well duh, you might say. However a lot of people who get someone under their wings actually set them up to fail without realizing it.

In this session we will take a look at my successes and failures as a (technical) coach. The good parts, but also how I could have done better.

I will share best-practices and ways to avoid unintentionally sabotaging your juniors. Finally, I will share some tips and tricks I learned from my background as an ex-high school teacher.

The end-goal is to share my experiences with you, and to make it easier for you to turn new hires into happy and valuable additions to your team.