Want to master Clean Architecture? Go here: https://dub.sh/clean-architecture
Want to master Modular Monoliths? Go here: https://dub.sh/modular-monolith

Join the .NET Architects Club: https://www.skool.com/mj-tech-community-5418/about
Get the 2026 .NET Developer roadmap here → https://the-dotnet-weekly.ck.page/2026-roadmap

If you've ever wanted to implement reliable messaging inside your applications, you've probably explored the Outbox and Inbox patterns. In this video, we're taking a look at both of these patterns to understand what problems they solve. I'll also show you how we can implement both in just a couple of lines of code using the Wolverine messaging library.

When you want to publish a message to a broker and write to your database at the same time, you run into the "dual write problem". We'll look at how the Outbox and Inbox patterns use database transactions to give us atomic guarantees, preventing our systems from ending up in an in-between state. Then, we'll dive straight into the .NET code, configuring Wolverine to handle message persistence natively.

What we will cover in this video:
- Understanding the Outbox pattern and how it solves the dual write problem.
- How the Inbox pattern works to ensure reliable incoming message processing.
- Configuring Wolverine with RabbitMQ and Postgres.
- Adding EF Core message persistence for automatic outbox and inbox support.
- How to use the Wolverine Outbox pattern outside of a message handler, like in a standard API endpoint.
- Testing our implementation and reviewing the distributed traces.

🔗 Resources Mentioned:

Beginner-friendly introduction to Marten: https://youtu.be/b-a7CQ_I7JI

How to implement the Outbox pattern from scratch: https://www.milanjovanovic.tech/blog/implementing-the-outbox-pattern

Wolverine Documentation: https://wolverinefx.net/guide/durability/

Check out my courses:
https://www.milanjovanovic.tech/courses

Read my Blog here:
https://www.milanjovanovic.tech/blog

Join my weekly .NET newsletter:
https://www.milanjovanovic.tech

Chapters

We Are .NET

A walkthrough of implementing the outbox and inbox messaging patterns in .NET using the Wolverine messaging library. Covers the dual-write problem, how outbox/inbox patterns solve it using database transactions, and practical setup with Wolverine's EF Core integration and PostgreSQL. Demonstrates enabling durable outbox on sending endpoints and durable inbox on listeners with minimal configuration, plus two approaches for using the outbox outside the Wolverine pipeline (in minimal API endpoints or background jobs). Also shows the Wolverine schema tables created at runtime and how the store-and-forward mechanism differs from a traditional polling outbox processor.

Reliable Messaging in C#: Wolverine Outbox & Inbox Tutorial