The vertical slice architecture is an architectural pattern used in software development that structures the codebase of an application by creating complete end-to-end slices of functionality, which span across all layers of the application. Rather than structuring codebase by layer, the vertical slice architecture structures the codebase around a single feature, including all the necessary code components such as UI, domain, infrastructure, and application layers.

This approach allows for a more modular and decoupled codebase, enabling the development team to work on a single feature without being impeded by dependencies or interfering with other features. Each slice is self-contained and encompasses all the necessary code to provide a specific feature, making it easier to modify, test, and deploy. Additionally, this approach aligns better with the business requirements, since it focuses on delivering complete functionality to the end-users.

Skills needed

Implementing the vertical slice architecture requires a range of skills on the team, including:

1. Domain expertise: Team members with a good understanding of the domain are needed to identify and define the relevant business processes, entities, and rules.
2. Technical skills: Team members with technical skills, including architecture, design, development, testing, and deployment, are needed to create, implement, and deploy the solution.
3. Collaboration skills: Team members must be able to work closely together and communicate effectively to ensure that the vertical slices are aligned and consistent.
4. Agile skills: Teams using the vertical slice architecture must be able to work in an agile manner, adapting to changes in requirements, technology, and the business environment.
5. Continuous learning: Team members must be willing to learn continuously, keeping up with the latest developments in the domain and technology, and applying new knowledge to improve the solution.

The success of implementing the vertical slice architecture requires a team with a diverse set of skills, a commitment to collaboration and continuous learning, and a focus on delivering business value.

Example

Let’s consider an e-commerce application where users can search for products, add them to a shopping cart, and then checkout to complete their purchase.

Using the vertical slice architecture, each feature or use case would be implemented as a complete, end-to-end slice of functionality that cuts through all layers of the application, from the UI to the database.

So for example, the search feature would include the UI for entering search terms, the domain logic for querying the product catalog, and the persistence layer for retrieving product data from the database.

Similarly, the shopping cart feature would include the UI for adding and removing items, the domain logic for managing the cart state, and the persistence layer for storing the cart data.

And the checkout feature would include the UI for entering payment and shipping information, the domain logic for validating the order and calculating the total, and the persistence layer for saving the order data to the database.

Each of these features would be implemented as a separate vertical slice of the application, with its own set of UI, domain, and persistence components, and would be deployed and tested independently. This approach allows for faster development and more frequent releases, as each feature can be developed, tested, and released in isolation without affecting the rest of the application.

When to use

The vertical slice architecture is appropriate when there is a need to deliver end-to-end functionality for a particular feature or use case, as it allows a team to focus on delivering a fully functional slice of the application that spans all layers of the architecture, rather than working on individual layers in isolation. This approach is particularly useful in situations where the architecture is complex and the risk of integration issues is high. It is also useful when the business needs to see the features or use cases delivered in a relatively short amount of time.

When to avoid

The vertical slice architecture can be avoided if the application is relatively small, simple, and has a small team size. In such cases, a simpler architecture such as a layered architecture or monolithic architecture may suffice. Additionally, if the application does not have a large number of independent features or does not require frequent changes to the architecture, the vertical slice architecture may be an unnecessary overhead. It is also important to consider the skills and experience of the development team, as the vertical slice architecture can be complex to implement and maintain, and may require specialized knowledge of DDD, CQRS, and event sourcing.