Goodbye Microservices, Hello Self-Contained Systems

Microservices are a popular approach to building modern software, offering scalability and flexibility. However, for many teams, these come with challenges such as increased complexity, difficult debugging, and managing numerous small services.

In this talk, I'll introduce an alternative: Self-Contained Systems (SCS). Unlike microservices, SCS enables each part of your application to operate independently, with its own UI, logic, and database, thereby simplifying both development and deployment.

You'll learn why SCS can be a better fit for many projects, how it reduces the complexity of distributed systems, and when it makes sense to use this approach over microservices. Based on my current customer project, I'll show you how to build self-contained systems using Java and Vaadin.

Value for the audience:
The audience will gain a realistic view of the limits of microservices, based on practical project experience rather than hype.
They will learn about Self-Contained Systems (SCS) as a proven alternative that keeps autonomy but reduces the complexity of distributed systems.
They will see concrete examples with Java and Vaadin, showing how to design and implement SCS in practice.
They will leave with guidelines for choosing the right architecture for their projects—when microservices make sense and when SCS is the better fit.

Problems addressed:
Many teams adopt microservices, hoping for flexibility and scalability, but end up with a system that is hard to understand, debug, and operate.

Running dozens of small services introduces challenges in deployment, monitoring, and failure handling, often requiring large DevOps investments.

Microservices often don’t fit smaller teams or organizations that lack the resources to manage distributed systems effectively.

Talk language: English
Level: Advanced
Target group: Software Architects, Software Engineers

Company:
Martinelli GmbH

Simon Martinelli