At first glance, Vertical Slice Architecture and Self-Contained Systems share many similarities. One might easily assume they are just different terms for the same approach. However, upon closer examination, significant differences become apparent. This article explores the similarities and differences between these two approaches.
Introduction
The term ‘Vertical Slice Architecture’ was coined by Jimmy Bogard in 2018 in an article, although many questions remain unanswered—for example, whether Vertical Slice Architecture exclusively refers to individual slices within a deployment monolith or can also be viewed as a standalone form of microservices. Other authors have provided concrete implementation examples (see https://www.milanjovanovic.tech/blog/vertical-slice-architecture-structuring-vertical-slices) and contributed to spreading the concept (see https://medium.com/@andrew.macconnell/exploring-software-architecture-vertical-slice-789fa0a09be6). However, a universally accepted and complete definition is still lacking. Vertical Slice Architecture is especially popular in the .NET community but not limited to it.
Self-Contained Systems have been substantially described through various publications and talks, detailing the approach extensively. Today, Self-Contained Systems enjoy broad acceptance within the software community. A microsite describes the approach consistently and offers numerous additional resources. Originally prevalent primarily in the Java and Spring Boot environments, the approach remains technology-agnostic.
Similarities
Structuring
Vertical Slice Architecture and Self-Contained Systems structure large systems into smaller, manageable units. This creates cohesive modules organized along business boundaries, helping to reduce cognitive load.
Relationship to Microservices
Both approaches can be viewed as specializations of microservices, yet they differ from microservices in detail. While Self-Contained Systems explicitly and extensively articulate their relationship with microservices (see https://scs-architecture.org/vs-ms.html), this connection remains rather indirect and implicit in Vertical Slice Architecture. Interestingly, Bogard does not address this aspect in the foundational blog post at all. Vertical Slice Architecture and microservices diverge especially regarding the strict requirement for an independent codebase.
Isolated Business Logic
Both approaches require complete isolation of business logic. Vertical Slice Architecture organizes logic around individual use cases, whereas Self-Contained Systems can encompass multiple related use cases. Additionally, both Vertical Slice Architecture and Self-Contained Systems allow for optional APIs and support polyglot persistence. This aspect is particularly emphasized in Vertical Slice Architecture due to its origins in the context of CQRS.
Variable Technology Stacks
Furthermore, both approaches permit the use of different technology stacks. Self-Contained Systems strongly promote this through physical separation, while Vertical Slice Architecture offers this flexibility only with independent deployments. Clearly defined scopes in both approaches facilitate separation of responsibilities and encourage development by autonomous teams.
Minimal Coupling
Both approaches advocate minimal coupling, though Self-Contained Systems are particularly strict here, explicitly preferring asynchronous communication mechanisms. Both typically use web interfaces for integration; while not explicitly required by Vertical Slice Architecture, it remains common practice.
Differences
Integration
The communication between systems differs significantly: Self-Contained Systems explicitly rely on asynchronous collaboration, while Vertical Slice Architecture seeks maximum decoupling but does not fundamentally exclude collaboration.
Moreover, Self-Contained Systems provide clear guidelines for external communication (REST or asynchronous messages), whereas Vertical Slice Architecture largely avoids such restrictive specifications. In Self-Contained Systems, each unit has its own UI; in Vertical Slice Architecture, slices often share a common user interface and provide controllers to handle external events.
Another key difference concerns shared infrastructure. Self-Contained Systems strongly discourage shared infrastructure usage, whereas Vertical Slice Architecture explicitly permits it.
Deployment and Modularization
Another distinction lies in deployment. Self-Contained Systems are always deployed independently, while Vertical Slice Architecture can operate either within modular monoliths or as standalone deployments.
There are also differences regarding business orientation: Self-Contained Systems structure systems along business domains, whereas Vertical Slice Architecture strictly focuses on features, potentially resulting in finer-grained and cross-domain modules.
Regarding scalability, Self-Contained Systems inherently provide individual scalability due to their independence; Vertical Slice Architecture enables this only if slices are deployed independently.
Persistence
Self-Contained Systems each use isolated data storage systems, while Vertical Slice Architecture allows for shared data storage. Additionally, there are differences regarding data ownership: Self-Contained Systems explicitly require clear data ownership by a leading system, whereas Vertical Slice Architecture lacks explicit guidelines on this point.
Greenfield and System Modernization
Self-Contained Systems explicitly suit both new system development (greenfield) and the modernization of existing systems through incremental modular decomposition. In contrast, Vertical Slices emphasize rapid feature development and do not explicitly address modernization, although they can generally support it.
Conclusion
Although numerous differences exist between Self-Contained Systems and Vertical Slice Architecture, both approaches address similar challenges in software architecture. Self-Contained Systems are strictly defined and structured, while Vertical Slice Architecture remains pragmatic and less formal. This makes Vertical Slice Architecture more accessible on the one hand, but potentially raises barriers due to its lack of explicit definitions. In practice, the characteristics described here can be adapted through minor variations to individual requirements.
The choice of the appropriate approach depends on individual factors: Where encapsulation and independent deployability are crucial, Self-Contained Systems are preferable. For feature-driven development, Vertical Slice Architecture can be a pragmatic choice. However, keep in mind that with an increasing number of slices, the complexity of the overall system grows.
As always with architectural work: Only if the specific constraints and essential quality attributes within the individual context are known can we make sound architectural decisions. In any case, Vertical Slice Architecture and Self-contained Systems belong in the architectural toolbox.