La charla será en español 🇪🇸

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.