Recent posts
How to Authenticate Server-Sent Events in ASP.NET Core
02 October 2026
After a talk I gave about the difference between SSE and SignalR, and how to implement user-targeted messages in both of the tools, I was asked a very important question that I hadn’t covered during the session. “Can an SSE be authenticated? (does it have Authorization headers)”. Since SSE is simply a way to stream events to the clients, via a normal HTTP request, the short answer is yes. The longer answer depends on what client/API you use. In this article, I explain the different ways to use SSE with authenticated users, what the pitfalls are, and how to avoid them.
Solving the Dual-Write Problem with the Transactional Outbox and Inbox Patterns
27 September 2026
In a previous post, I asked the question When should your application use a message broker? In that article I mentioned the transactional outbox pattern, which you should consider whenever you use a message broker. In this post, I’ll explain the pattern itself, and why it should be considered. Since anything can fail at some point, we’ll look at how to protect against those failures and how to implement the pattern using MassTransit in a .NET application.
When should your application use a message broker?
24 September 2026
When building a software, one of the first decisions we make is to let different parts of the system communicate through HTTP.
If service A needs something from service B we’ll just call the service B API:
var response = await client.PostAsJsonAsync("api/endpoint", class_instance);
This works fine, and usually all we need, until it doesn’t.
As systems grow, we will encounter situations where synchronous HTTP communication makes things awkward.
The receiving service might be temporarily unavailable, or maybe more than one service needs to consume the same event. The process might be slow and take several minutes, or maybe you don’t care when the work happens, as long as eventually it will happen.
That’s when a message broker becomes interesting. However, that doesn’t mean every application needs RabbitMQ, a service bus, or another messaging platform.
So when should you actually use one?
SSE vs SignalR: Targeting Users and Groups in .NET
19 September 2026
We previously looked at the difference between SSE and SignalR, specifically in .NET 10, explaining their communication models and how to implement a basic scenario with each of them. I also provided some guidance on choosing the right technology based on your application’s real-time communication needs. However, this is not the whole story, and I wish choosing were that easy. One important subject I left out was the trade-off involved in managing users and groups and sending targeted messages. It’s safe to say that you can achieve this using both SSE and SignalR, in different ways. Let’s look at how to do so together.
Feature Management in .NET: Simple Flags to Advanced Targeting
04 September 2026
Have you ever had to deploy code to production, but want to keep it inactive for the time being? I certainly had to do so for many reasons. Sometimes it was simply a feature that has to be enabled at a certain time, or a feature that is waiting for another team deployment that is scheduled for a few days later, but the idea remains the same, deploy the feature and keep it inactive until it’s time.
The most common way to do so is by using feature flags. A simple configuration in the app can accomplish this, but in .NET we have a more powerful tool that can do more than enabling/disabling a feature.
Let’s take a look together at what Feature Management offers to make it easier to handle this.