Break the shackles of schemas in your #NServiceBus systems using #AzureCosmosDB #NoSQL ☁️

What factors should drive your choice between monolithic design and a distributed microservices architecture for your next API platform or backend? This article outlines key differences that influence scalability and team autonomy

To build and run NServiceBus solutions on Visual Studio @Code, all you need are Code, the C# extension, and this article to show you how to set up launch.json and tasks.json to debug your solution

When 100 parallel requests hammer a service, you’ll either overload downstream APIs or hit throttling, yet basic in-memory caching often fails to prevent this at scale. This article by Milan Jovanović explores that tension and why cache correctness is more than storing values

NServiceBus guarantees reliability and extensibility you just can't get with REST or other HTTP-based web services. Get a quick introduction to why building with NServiceBus makes building distributed systems better in our Quick Start tutorial

How do you handle thousands of concurrent operations without overwhelming your dependencies in .NET? The post maps several async patterns and real pitfalls for scalable APIs sharing production insights

When a method returns a list that should contain data but returns empty, you end up with scattered runtime checks and subtle bugs in production. The piece explains why this pattern of runtime failures matters

Many systems suffer from validation drift when backend and frontend enforce the same rules independently, with no shared source of truth. This article explains why that drift is a real cost and how a unified validation contract matters for reliable APIs

Building distributed systems on AWS SQS and Azure Service Bus is one thing, but what about hosting those systems on AWS Lambdas and Azure Functions? Find out in our webinar with @stimms:

Complex business operations, such as placing an order, involve multiple repositories and side effects. When each save happens independently, you lose a clear commit boundary and risk inconsistency, a challenge Chris Woodruff explores in this article.

Want to learn #NServiceBus? The quickest way is to build something. Check out our tutorial with step-by-step exercises

Clava has been using #NServiceBus in his production systems in the public utilities industry for 10 years. Get a taste for how NServiceBus can improve your mission-critical software systems by trying our Quick Start tutorial now.

Kind of what we've been trying to tell y'all all along. Well said @codeopinion!

"Other systems…can then subscribe to receive these events and cache the data locally. This ensures that when the data is needed, it can be provided without requiring a network round trip."

Aspire will give you a lot of OpenTelemetry metrics for free, but you can change/extend the default configuration to include custom metrics.

"Using PostgreSQL in your .NET projects? It’s not just for persistence anymore! 💡 You can now leverage PostgreSQL for messaging, enabling: ✅ Atomic transactions across DB updates & message processing ✅ Easier long-running workflows ✅ Reduced complexity for distributed systems

@kijanawoodard knows all the mistakes people make using NServiceBus. Take a look at this video and make sure you aren't making any!

Annotating code with custom attributes you can discover using Reflection is a powerfull skill. For example, we have a PreObsolete attribute to store information about APIs we plan to deprecate at some point in the future.

Behind the scenes of the Visual Studio feedback system … in short, if you want Visual Studio to do something, speak up! It might actually happen!

A "demoware" NServiceBus solution is one thing. Learn the techniques to bring it into the real world, like changing to RabbitMQ for production message queuing, testing the system, optimizing the system with behaviors, and handling production errors

"In addition to adding more skills to your repertoire, successful architects synthesize the things that they learned and become a force multiplier."

In the classic paper Data on the Outside versus Data on the Inside, Pat Helland argued that data within a service boundary should be treated differently than data residing outside of it. In this talk, @SzymonPobiega argues the same applies to messages

TL;DR … Yes.

It's that time of year - here's GitHub's ultimate gift guide for the developer in your life. Ok it's all GitHub-branded merch but 🤷 … Happy holidays!

Love how C# keeps getting more concise, in this case, with null-conditional assignment.

"Not all work needs the same level of scaling. Small tasks that are done fast can be done by a single worker while multiple workers take care of the more demanding, slower tasks. By using partitioning, we can scale each activity independently."

The New .slnx siolution format is what solution files always should have been. We've converted all of our repos for our upcoming NServiceBus 10 release. Let @mjovanovictech show you how to do it!

With an NServiceBus system, you get smarter handling of poison messages and the ability to easily retry/replay them. Check out the other ways NServiceBus makes building message-driven systems faster and easier

In .NET 10 you can run C# files as scripts, but imagine sharing scripts in GitHub repos and then executing them by owner/repo and path… Cool stuff!

We're sunsetting our ServiceInsight. Why? All the functionality is now present in ServicePulse, which is a (cross-platform) web application, so you don't need a Windows-only app anymore!

Copying memory unnecessarily can easily turn your system into a resource hog, degrading the performance of everything. Watch @danielmarbach's performance tricks webinar recording and learn how to spot this and other problems and avoid them

Never worry about losing business requests again with NServiceBus automatic error queue handling on AWS Lambda.

Microservices succeed when architecture balances autonomy with cohesion. This post discusses how to align design choices with long term system health.

"It's very sad that, in this modern era, the vulnerability at the top of the [OWASP Top 10] list is a simple injection attack, which is trivially avoided using parameterized database queries." The 4th Fallacy: The network is secure, on our blog

Designing extensible ASP.NET Core applications often requires balancing flexibility with clarity. This article demonstrates how the strategy pattern with dependency injection can achieve both.

Be the first to know when your system's external dependency goes down. Use #NServiceBus custom checks

What happens when legacy C# code meets modern language features like async and LINQ? This guide shows how thoughtful refactoring can bridge the gap and sustain distributed systems more effectively.

Using IN with large lists in SQL Server might feel convenient, but it can hit parameter limits and force the engine to recompile query plans on every variation. That can hurt performance in real systems. @DomenicHelfenst explains an alternative approach.

Why does so much business logic end up trapped inside minimal API endpoints and what happens when you later need that same logic for background jobs or message handlers? This article digs into that design tension @WoodruffDev

See how you can use #NServiceBus in an #ASPNetCore #WebAPI application. We've got a sample for that!

Working with WebSockets just got easier in .NET 10: WebSocketStream offers stream-based APIs that eliminate manual framing and buffering, making protocol and message processing simpler.

NServiceBus has a bunch of persistence options: SQL, Azure Storage, DynamoDB, MongoDB, RavenDB, and NHibernate. How do you know which to pick? Check out our guidance on persistence selection to make sure you make the right choice

Zero Trust for APIs means verifying identity, enforcing least privilege, and assuming breach at every call. In this guide, Sudhir Mangla explains how APIM and Entra ID make those principles practical for enterprise systems.

Aggregates are often overloaded because people model object relationships instead of where business rules truly belong which leads to inefficient designs and confusion over what boundary should enforce a given invariant

"Then came REST, or in other words, 'something I invented myself over HTTP.' Each RESTful endpoint is that developer’s definition of what REST means…different from what every other developer thinks REST means." Fallacy #8: The network is homogeneous

Google Pub/Sub decouples producers and consumers through topics and subscriptions, enforces idempotency via ackDeadline, and shapes delivery guarantees. This post by Poornima Nayar is a useful refresher on messaging fundamentals, from basic lifecycle stages to subscriber behavior.

You did microservices. But did you? Do you really have a distributed monolith instead? In this video, @DavidBoike provides a roadmap to microservices that avoid the pitfalls of coupling that slide toward the pit of distributed monoliths

Minimal APIs? CQRS? DDD? Controllers? Architecture should follow use cases, not trends. Choose the tool that solves the problem. Great read from @codeopinion https://codeopinion.com/minimal-apis-cqrs-ddd-or-just-use-controllers/ #dotnet #architecture

Figure out which technology choices are right for your distributed system with our Technology Selection page, part of the NServiceBus learning path

Learn about five essential techniques that make ASP.NET Core apps faster, lighter, and secure - HybridCache, MapStaticAssets and more... #dotnet #aspnetcore