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.

Escaping Legacy Limbo: A Step-by-Step Guide to Refactoring and Modernization

If you’ve worked on legacy code or a “big ball of mud,” you’re likely familiar with the frustration, slowdowns, and increased costs that come with maintaining it. Refactoring is often seen as the solution to these problems, but how do you actually start?

The common suggestion? Rewrite everything from scratch. But convincing stakeholders to support such a risky and expensive approach rarely works.

In this session, we will explore practical, low-risk strategies for cleaning up your codebase without starting from scratch. We’ll examine techniques such as the Strangler Fig Pattern and share best practices for refactoring, helping you avoid common pitfalls that lead to tangled, unmanageable code. By the end, you’ll have valuable tips and techniques that will make the refactoring process easier and more sustainable for you and your team.

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.