The Rise of Self-Contained Systems: A Simpler Approach to Architecture
The software development world is constantly evolving, with debates raging over the best architectural approaches. While microservices were initially hailed as a solution to the problems of monolithic applications, their implementation often led to increased complexity and distributed challenges. A potential alternative, gaining traction, is the concept of self-contained systems (SCS).
The Microservices Dilemma
Microservices promised independent deployment, scaling, and team autonomy by breaking down monolithic applications into smaller, manageable services. However, many projects adopted microservices without truly needing the scalability they offered. This resulted in over-engineered systems and the rise of "nanoervices," leading to a distributed "bowl of mud" rather than a clean, modular architecture. The complexity overhead associated with microservices often outweighed the benefits for systems that didn't require hyper-scale capabilities.
Introducing Self-Contained Systems
Self-contained systems offer a different approach by building independent, vertical slices of functionality. Each system includes its own UI, backend logic, and database. Critically, it avoids runtime dependencies on other systems. These systems function as independent applications, promoting modularity without the tight coupling often seen in microservices.
The Core Principles of SCS
The power of SCS lies in its clear boundaries. By design, SCS minimizes inter-system communication, reducing the need for complex infrastructure components such as:
-
Circuit breakers
-
Distributed tracing
-
Extensive DevOps layers for frequent deployments
Furthermore, the inclusion of its own UI avoids the anti-pattern of a monolithic front end interacting with numerous microservices.
Communication Between Systems
While self-contained systems strive for independence, communication is sometimes necessary. This is primarily achieved through two methods:
-
UI Links: Direct links within the user interface to navigate between systems.
-
Asynchronous Event-Based Messaging: Decoupled communication using events to exchange data without direct dependencies.
SCS: A Return to Modularity
In many ways, self-contained systems echo the principles of modular application design from the 1990s. This architecture facilitates:
-
Small and autonomous teams
-
Business-aligned boundaries
-
Reduced complexity and improved maintainability compared to poorly implemented microservices architectures
Real-World Success
Self-contained systems are gaining recognition, with success stories emerging from conferences like Spring IO 2025. One example involved splitting an old ERP system into multiple SCS using event replication for data sharing. Each team took end-to-end ownership of their slice, encompassing the UI, backend, and storage, resulting in a well-organized and maintainable system.
Conclusion: Choosing the Right Architecture
While not a perfect solution for every scenario, self-contained systems offer a cleaner and more scalable alternative to overly complex microservices architectures. For applications requiring extreme real-time performance and massive concurrent users, microservices may still be the right choice. However, for business applications, internal tools, and systems that don't demand hyperscale, SCS provide a simpler, more manageable, and potentially more effective solution.