Most developers reach for a message broker the second they hear "reliable events", but you might not need one. Spring Modulith ships with a durable event registry that can persist and replay failed events, and in this video I'll show you exactly how to use it.

In this hands-on tutorial, we build a meetup RSVP application using Spring Modulith to demonstrate how modules communicate through events and how the event publication registry ensures no event is lost. You'll see how to set up durable events with Spring Data JDBC and Postgres, simulate a failure, and watch Spring Modulith automatically republish outstanding events on restart.

- How to publish and listen to application events across Spring Modulith modules using ApplicationEventPublisher and @ApplicationModuleListener
- How to enable the Spring Modulith event publication registry with JDBC to persist events to a database table
- How to simulate event failures and use the republish-outstanding-events-on-restart feature to recover gracefully
- Why modular monoliths with Spring Modulith give you reliable inter-module communication without needing Kafka or RabbitMQ
- How to verify your modular structure with Spring Modulith's built-in test support

0:00 - Intro – Why you may not need a message broker
0:45 - Recap of the Spring Modulith series
1:45 - Spring Modulith documentation on events
2:30 - Creating the project on start.spring.io
3:30 - Setting up tests and verifying modular structure
4:30 - Creating the Meetup and RSVP records
5:30 - Building the events module (controller, service, repository)
8:00 - Publishing events with ApplicationEventPublisher
9:30 - Creating the Notifications module and listener
11:00 - Introducing a simulated failure
12:30 - Enabling the event publication registry in YAML
13:30 - Understanding the event_publication table
14:30 - Running the app and creating a meetup + RSVP
16:00 - Seeing the failed event in the database
17:00 - Restarting and watching the event republish
18:00 - Verifying the completed event and confirmation
18:30 - Wrap-up and why this matters

🔗Resources & Links mentioned in this video:
GitHub Repository: https://github.com/danvega/modulith-durable-events
Spring Modulith Documentation – Application Events: https://docs.spring.io/spring-modulith/reference/events.html
Spring Initializr: https://start.spring.io

👋🏻Connect with me:
Website: https://www.danvega.dev
Twitter: https://twitter.com/therealdanvega
Github: https://github.com/danvega
LinkedIn: https://www.linkedin.com/in/danvega
Newsletter: https://www.danvega.dev/newsletter

SUBSCRIBE TO MY CHANNEL: http://bit.ly/2re4GH0 ❤️

Dan Vega

Spring Modulith provides a built-in durable event publication registry that persists events to a database table, allowing failed or unprocessed events to survive server crashes and be replayed on restart. A step-by-step walkthrough demonstrates building a modular monolith with two modules (events and notifications) that communicate via Spring's ApplicationEventPublisher. The tutorial shows how to configure the event publication registry with Spring Data JDBC, simulate a listener failure, and verify that setting `republish-outstanding-events-on-restart=true` causes the failed event to be retried successfully on the next startup — all without needing an external message broker.

Events That Survive Crashes in Spring Modulith