Event-Driven Architectures with Spring Modulith and AsyncAPI

Ivan Garcia Sainz-Aja - Izertis

Event-driven architectures are transforming how we build scalable, resilient systems.

However, prematurely distributing an application across microservices can lead to significant operational overhead and unintended complexity.

This complexity stems not only from infrastructure concerns but also from model fragmentation caused by poorly defined boundaries. The result? The infamous “This API call could have been a join” scenario. Instead of agility and scalability, you end up with a system that is over-complicated, difficult to manage, and unable to deliver the benefits promised by EDA.

With Spring Modulith Events, you can still design your service architecture using event-driven principles within a single modular monolith (Modulith), which provides:

• More flexible model boundaries that are easier to evolve and refactor.
• The ability to delay microservice distribution until your domain and model are more stable.

As your understanding of the domain matures, if the need arises to split modules into microservices (for scalability, independent deployability, fault tolerance, etc.), Spring Modulith allows for smooth transitions:

• Externalize events with minimal changes to your existing codebase.
• Use the AsyncAPI specification and API-first code generation to define clear and robust interfaces between your services—without duplicating or tightly coupling code.

Why This Session?

Systems are inherently growing in essential complexity, but there’s no need to add unnecessary complexity just to implement modularization or event-driven patterns. With Spring Modulith and Events, you can avoid the pitfalls of premature distribution while building well-designed, event-driven services. AsyncAPI further supports this by helping you manage and stabilise interfaces between modules, preventing unintended breaking changes.

Session Timeline

• Introduction to Event-Driven Architectures and challenges.
• Spring Modulith and Events
• Synchronization and Transactionality of Events
• EventPublicationRegistry: an Outbox Pattern out-of-the-box
• Event Externalization with Spring Cloud Stream
• Introduction to AsyncAPI: Reverse engineering and code generation with ZenWave SDK
• Distribution and versioning of APIs with Maven