Hubbry Logo
Vertical sliceVertical sliceMain
Open search
Vertical slice
Community hub
Vertical slice
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Vertical slice
Vertical slice
Vertical slice
View on Wikipedia
from Wikipedia
A vertical slice from the components of a project

A vertical slice (VS) is a type of milestone, benchmark, or deadline, with emphasis on demonstrating progress across all components of a project.[citation needed] It may have originated in the video game industry.[citation needed]

Overview

[edit]

The term vertical slice refers to a cross-sectional slice through the layers that form the structure of the software code base. It is mostly used in Scrum terminology where the work is planned in terms of features (or stories). For example, as a very basic approach, a software project may consist of three layers (or components):

  1. Data access layer (bottom)
  2. Business logic layer (middle)
  3. User interface layer (top)

In this common approach, a vertical slice means a bit of every layer. Again as an example, a new feature request like "showing x information on main screen" would contain these work bits:

  • Work in the UX/UI that will display the information
  • Work in the service layer to transform the information
  • Work in the database layer to store / fetch the information.

So a vertical slice can be defined as "the sum of the work that has to be done in every layer that is involved in getting a specific feature working." A vertical slice doesn't necessarily affect every component in the software. For example, if the solution contains a web service, it would live in the same "floor" as the UI, and a feature like "supporting login/logout in webservice" that involves only the web service does not require a change in the UI, but the business and database access layers.

Vertical user stories

[edit]

A vertical user story encapsulates the action of one function.

An example of a vertical user story is, "As an end user I must be able to log into my company portal so that I can perform the functions of my job."

Acceptance criteria

[edit]

Acceptance criteria are conditions of satisfaction. This story is "done" when the detailed functionalities are completed.

For example:

  • Verify that I can log into the system
  • Verify that my login credentials will be remembered
  • Verify that I can reset my own password by clicking the "Forgot Password" link
  • Verify that I cannot navigate back to the landing page without first logging in

Dissected by layer

[edit]

As a developer, you will need to think about every file encapsulated in each layer that needs to be created and/or extended in order to complete this "Login User" story.

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Vertical slice

View on Grokipedia
from Grokipedia
A vertical slice is a project management and software development technique that involves creating a complete, end-to-end implementation of a specific feature or segment, integrating all necessary layers such as user interface, business logic, and data access to demonstrate functionality and progress. In video game development, it specifically refers to a fully playable portion of the game that showcases the intended player experience using final-quality assets, including gameplay mechanics, art direction, user interface, sound design, and core systems, often serving as a proof of concept for securing funding or publisher partnerships. This approach contrasts with horizontal slicing, which focuses on parallel development across layers without full integration, by emphasizing vertical integration to deliver immediate value and enable early feedback. Originating prominently in the during phases, vertical slices help developers assess feasibility, identify technical gaps, and align on vision before committing to full-scale production. They are particularly valuable in Agile methodologies for breaking down user stories into deliverable increments that provide holistic stakeholder input, fostering cross-functional collaboration and reducing risks associated with siloed development. In broader , the concept extends to , where applications are structured around distinct use cases or requests rather than traditional layered hierarchies, grouping related concerns—like validation, data access, and presentation—within self-contained units to minimize inter-slice coupling and simplify maintenance. Key benefits of vertical slices include accelerated iteration through , enhanced focus on by simulating real-world usage, and improved , as each slice can evolve independently without disrupting shared components. In game funding contexts, they build investor confidence by providing tangible demonstrations of potential, often incorporating essential elements like immersive worlds and seamless controls alongside optional enhancements such as tutorials. This methodology promotes efficient resource allocation, with developers prioritizing polished segments over incomplete breadth, ultimately leading to more cohesive and market-ready products.

Definition and Origins

Core Definition

A in refers to a complete, thin of a single feature or that spans all technical layers of an application, including the , , and data access, to deliver observable end-user value. This end-to-end approach ensures the feature is fully functional and integrable from the outset, enabling early demonstration and feedback. Conceptually, a vertical slice contrasts with layered development by emphasizing functionality over isolated components; rather than building horizontally across layers for multiple features, it integrates vertically to create a cohesive, working unit that provides immediate utility. In agile contexts, this aligns with user stories by breaking down work to span layers in a single iteration, fostering incremental progress. For instance, a feature as a vertical slice would encompass the UI button for user input, the logic, and database verification, resulting in a fully operational capability rather than partial layer implementations.

Historical Development

The concept of the vertical slice emerged in the early 2000s as part of agile methodologies, heavily influenced by (XP) practices developed by between 1999 and 2000. XP emphasized delivering small, functional increments of working software over extensive upfront documentation, encouraging teams to build end-to-end features that provide immediate value and enable rapid feedback. This approach contrasted with traditional methods and laid foundational principles for slicing development into complete, testable units rather than isolated components. The term "vertical slice" gained prominence in the mid-2000s alongside the popularization of Scrum frameworks and user story refinement techniques. Descriptions of user stories as vertical slices that cut through all layers of a system—such as user interface, business logic, and data persistence—to deliver a cohesive, valuable increment to the user helped teams avoid horizontal slicing, which focuses on technical layers without user-facing outcomes, and became a standard in agile literature for ensuring iterative progress aligns with business needs. This refinement, building on XP's iterative ethos, influenced widespread adoption in software teams seeking to balance completeness with speed. While the practice of creating end-to-end prototypes predates the term in both software and game development, the specific phrase "vertical slice" appears to have originated in the around the late 2000s to early . By the , vertical slices were adopted in game development as a key practice for demos, evolving from earlier prototyping traditions that prioritized playable builds to test and secure publisher interest. These early prototypes, often rudimentary but functional segments of , mirrored agile's focus on demonstrable progress, allowing developers to refine core loops before full production. The approach proved essential for indie and AAA studios alike, enabling risk reduction through iterative validation of artistic, technical, and narrative elements.

Vertical Slices in Software Development

In Agile Methodologies

In agile methodologies, vertical slices play a crucial role in breaking down large epics into smaller, manageable user stories that deliver incremental value to the end user. This approach ensures that each user story adheres to the INVEST criteria—Independent, Negotiable, Valuable, Estimable, Small, and Testable—by focusing on end-to-end functionality that spans multiple layers of the system, such as user interface, business logic, and data persistence, rather than isolated components. By structuring stories this way, teams avoid dependencies that could hinder parallel work and prioritize features that provide tangible benefits early in the development cycle. Vertical slices integrate seamlessly into sprint planning, where they form the basis for selecting work items that can be completed within a single , typically lasting one to four weeks. This enables agile teams to gather early feedback from stakeholders during sprint reviews, as each slice demonstrates working software that fulfills a portion of user needs, allowing for rapid adjustments based on real-world validation. Furthermore, by completing features across all architectural layers in one , vertical slices help reduce , as teams address integration and testing holistically rather than deferring cross-layer issues to later phases. A practical example of this refinement process involves decomposing a "user registration" epic into vertical slice user stories. For instance, one story might specify: "As a new user, I want to sign up for an account so that I can access personalized features," encompassing form input, email validation, password hashing, and database storage in a single, testable unit. This slice delivers immediate value, such as enabling the first user sign-up, while subsequent stories could extend it to editing or canceling accounts, ensuring progressive enhancement without partial implementations.

Vertical Slice Architecture

Vertical Slice Architecture is an approach to that organizes code around specific features or use cases, known as vertical slices, rather than traditional horizontal layers such as controllers, services, and repositories. In this model, all components related to a single feature—such as user authentication—are grouped together in a dedicated module or folder, encompassing everything from input handling to data access and output generation. This contrasts with layered , where code is segmented by technical concerns, often leading to widespread dependencies across layers. By coupling components vertically along the axis of change for each feature, the architecture minimizes horizontal dependencies and promotes isolation between slices. The concept was popularized by Jimmy Bogard in his 2018 blog post, where he advocated for building applications around distinct requests to encapsulate all concerns from frontend to backend within each slice. This organization aligns closely with (CQRS), which separates read and write operations. It is often implemented using libraries like the , a implementation created by Bogard to handle requests via dedicated handlers. In such implementations, each vertical slice typically includes a request object (e.g., a command or query) paired with a handler that encapsulates the full for that feature, including any necessary data access or validation, without relying on shared abstractions like generic repositories. For instance, a "user login" slice might contain a LoginCommand and its LoginCommandHandler, keeping all related logic self-contained and reducing the need for cross-cutting concerns that span multiple features. This structure enhances maintainability by allowing developers to refactor or extend individual features independently, as new slices add code without modifying shared components, thereby avoiding unintended side effects. In practice, handlers facilitate this by isolating feature-specific logic, making it easier to test and evolve slices in isolation—for example, updating logic in the handler without impacting other areas like order . Overall, vertical slice architecture scales better for , as it reduces the of navigating layered dependencies and supports faster iterations on user stories.

Applications in Game Development

Purpose and Use Cases

In game development, the primary purpose of a vertical slice is to serve as a playable that demonstrates core mechanics in an end-to-end manner, integrating elements such as character movement, , and level progression within a single, cohesive level. This approach allows developers to validate the overall loop by combining placeholder or final-quality assets across disciplines like art, sound, AI, and physics, ensuring a representative taste of the intended player experience. Unlike broader , a vertical slice focuses on polish and functionality to prove the feasibility of the game's vision. Vertical slices are commonly used as early proof-of-concept deliverables for pitches, where a playable segment showcases the "fun factor" and production readiness to secure from publishers or platforms like Funding Club. In production pipelines, they function as key s that align cross-functional teams—designers, programmers, and artists—around a shared , often marking the transition from to full development. This role helps establish realistic timelines by revealing the effort required for shipping-quality . Additionally, vertical slices enable by identifying potential issues in , inefficiencies, or viability early in the process, such as muddy or production blockers, thereby reducing costly rework later. For instance, in an , a vertical slice might consist of a single level that incorporates integrated systems to test and refine the core loop before committing resources to the full title. This strategic application underscores their value in confirming not just if a game should be made, but whether it can be produced effectively.

Notable Examples

A prominent example of a vertical slice in AAA game development is Obsidian Entertainment's prototype for (2019), which featured an outdoor map connected to a and areas to demonstrate core RPG mechanics, companion interactions, and choice-driven gameplay. This slice, completed about one year into development, impressed publishers by showcasing the game's scope and feasibility, leading to greenlighting for full production. A notable industry trend involves using vertical slices for and backer engagement, exemplified by 's alpha builds since its 2011 campaign launch. Cloud Imperium Games released vertical slices of ship combat modules, such as the 2017 Squadron 42 demo featuring seamless transitions from operations to dogfighting and rescue missions, to demonstrate progress on multiplayer space simulation elements and secure ongoing funding over $861 million as of September 2025. These modules highlighted polished flight controls, weapon systems, and modular ship customization, building community trust amid extended development.

Comparison with Horizontal Slices

Key Differences

Vertical slices in and prototyping are feature-centric, encompassing work across all architectural layers—from to and data persistence—to deliver a complete, end-to-end piece of functionality that provides tangible value. In contrast, horizontal slices are layer-centric, focusing on completing a single technical layer, such as the or database components, across multiple features or user stories without integrating them into a working whole until later. This distinction arises in Agile methodologies, where vertical slices align with user stories by prioritizing demonstrable features, while horizontal slices often emerge from component-based breakdowns that segregate work by technical expertise. Methodologically, vertical slices promote cross-functional collaboration within a to build thin, iterative increments of a feature, enabling rapid progression toward a . Horizontal slices, however, facilitate parallel development by specialized teams or individuals, such as separate groups handling UI design versus backend services, but require subsequent integration efforts to realize any functionality. In terms of delivery impact, vertical slices allow for early user testing and feedback on complete features, as each slice stands alone as a deployable unit. Horizontal slices, by deferring integration, support concurrent progress on but postpone the delivery of user-facing value until all layers are assembled. A common visual analogy illustrates these differences: a vertical slice resembles cutting a piece of cake straight through all its layers, yielding a complete, edible portion that includes every element from top to bottom. Conversely, a horizontal slice is akin to separating and preparing each layer of a multi-tiered dish, like , individually—resulting in isolated components that must be stacked later to form a cohesive whole. This layered separation in horizontal approaches mirrors traditional waterfall-style development, while the through-cut of vertical slices embodies the iterative essence of Agile practices.

Pros and Cons

Vertical slices offer several advantages in and game creation by enabling end-to-end feature implementation that aligns closely with priorities. One key benefit is the facilitation of faster feedback loops, as teams can deliver deployable, working increments within a single sprint or , allowing stakeholders to validate functionality early and iteratively refine requirements. This approach reduces integration risks compared to layer-by-layer development, since cross-layer dependencies are addressed within the slice itself, minimizing surprises during assembly. Additionally, vertical slices promote better alignment with by focusing on user-centric outcomes rather than isolated technical components, enabling teams to prioritize high-impact features and achieve quicker time-to-market for viable products. In game development, these benefits extend to practical milestones, such as showcasing core mechanics to secure or build player interest, while providing a controlled environment to test integrated systems like , , and audio. Overall, the feature-focused structure of vertical slices enhances maintainability and flexibility, as changes are localized, reducing unintended side effects across the project. Despite these strengths, vertical slices present notable drawbacks, particularly in code management and . A primary concern is the potential for duplicated code across slices, as shared logic like validation or error handling may be replicated rather than centralized, leading to maintenance overhead. In large teams, challenges arise from cross-layer dependencies that require heightened coordination, complicating workload distribution and potentially hindering specialization if developers work in isolation on slices. Furthermore, the initial setup demands higher coordination effort, including an adjustment period for teams accustomed to horizontal approaches, which can lower early due to boilerplate implementation in each slice. Contextual trade-offs highlight vertical slices' suitability for small, feature-driven projects but limited scalability in infrastructure-heavy endeavors, where extensive shared components amplify duplication and consistency issues. In game development, resource intensity can strain small teams, risking or inflexible design directions if the slice sets premature expectations.

Implementation and Best Practices

Steps to Create a Vertical Slice

Creating a vertical slice begins with identifying a high-value or feature during backlog refinement sessions, where the team selects an item that delivers tangible end-user value and can be completed within a single . This step ensures the slice focuses on a self-contained functionality, such as enabling basic search in an application, avoiding overly broad epics that span multiple sprints. Backlog refinement involves collaborative discussions to prioritize stories based on business impact and feasibility, often using techniques like story mapping to visualize user journeys. Next, the team maps dependencies across all application layers—including , , and data access—while prioritizing a minimal viable that satisfies the core user need without excess features. This mapping reveals necessary integrations, such as connecting a search UI to backend query logic and database retrieval, and helps minimize cross-slice couplings to keep the effort focused. The goal is to define the thinnest possible functionality that works end-to-end, often documented in a refined with acceptance criteria. In vertical slice architecture, this organization groups related concerns by feature rather than by technical layers. Development then proceeds iteratively, with the building and integrating components layer by layer, incorporating testing at each integration point to ensure functionality flows seamlessly from to . Tasks are broken down to allow parallel work across disciplines, such as designing the UI alongside implementing queries, followed by unit and integration tests to validate interactions. This iterative approach catches issues early, maintaining momentum toward a deployable artifact. Finally, the completed vertical slice is deployed to a staging or production-like environment for user feedback, enabling demonstration during sprint reviews and rapid based on real-world input. This step closes the feedback loop, confirming the slice delivers value and informing adjustments for subsequent slices. For a simple search feature—from initial wireframe to end-to-end testing—this entire process fits within a single sprint.

Tools and Techniques

Story mapping serves as a key technique for visualizing vertical slices in agile development, arranging user stories along horizontal axes by user activities and vertical axes by priority to identify incremental, end-to-end features for delivery. This approach enables teams to create a "walking skeleton" of the minimal viable product in the first row, followed by layered enhancements that form complete vertical slices without dependencies on lower-priority elements. Test-driven development (TDD) supports layer integration within vertical slices by structuring each development cycle as a complete vertical implementation spanning UI, , and data access layers. In TDD, developers write tests first to define implicit contracts that ensure seamless integration across layers, validating the slice as a functional unit before proceeding. This method promotes robust, testable slices that align with agile's emphasis on rapid feedback. Continuous integration/continuous deployment (CI/CD) pipelines facilitate rapid deployment of vertical slices by automating code integration, validation, and release processes in agile environments. CI allows daily integration of small slice updates with automated testing, while enables frequent, on-demand deployments—such as multiple releases per day—decoupling feature delivery from broader system constraints to support iterative value delivery. In vertical slice architecture, libraries like MediatR handle requests by implementing a for in-process messaging, dispatching commands, queries, and notifications to dedicated handlers within each feature slice. This decouples slice-specific logic, allowing independent development and testing of requests across the application without tight coupling to other features. In vertical slice architecture, particularly when implemented in C# ASP.NET Core, best practices for managing constants and shared code emphasize placing them as close as possible to their usage to preserve feature independence and minimize coupling. Feature-specific constants, such as magic strings or values unique to a particular use case, belong within the feature slice, for example in a Constants.cs file or static class inside the feature folder (e.g., Features/Orders/CreateOrder/Constants.cs). Shared domain constants, including validation limits and business rules, belong in the Domain layer, typically as static members on entities, value objects, or domain services. Infrastructure or technical constants, such as configuration keys, belong in an Infrastructure layer or shared kernel. Teams should avoid generic "Common" or "Constants" projects/classes that can become dumping grounds; apply the "Rule of Three" (extract only after three usages) and prefer duplication over premature abstraction for feature-specific logic. This approach aligns with VSA principles of high cohesion within slices and low coupling between them. For game development prototypes, engines such as Unity and enable the creation of vertical slices by integrating core mechanics, assets, and polish into a playable segment that demonstrates end-to-end . In Unity, developers use C# scripting and the to build, debug, and iterate on slices incrementally, prioritizing features from a backlog to produce a functional . similarly supports rapid prototyping of polished slices through its blueprint system and C++ integration, facilitating cross-disciplinary collaboration. Project management tools like Jira and Azure DevOps track vertical slice progress by organizing work items into boards that visualize status across sprints and teams. In Azure DevOps, taskboards display tasks grouped by stories, allowing drag-and-drop updates to "To Do," "In Progress," and "Done" states, with remaining work estimates feeding into burndown charts for accurate progress monitoring. Jira extends this through integrations that link cross-functional issues, enabling shared tracking of slice completion across multiple teams. A recommended is using feature flags to isolate vertical slices during development, toggling functionality on or off without code changes to enable trunk-based workflows and controlled testing. This ensures slices remain independently deployable, reducing risks in progressive rollouts and allowing exposure to specific users for validation before full integration.

References

  1. https://monday.com/blog/rnd/vertical-slice/
  2. https://xsolla.com/blog/funding-101-the-impact-of-the-vertical-slice
  3. https://www.jimmybogard.com/vertical-slice-architecture/
  4. https://www.visual-paradigm.com/scrum/user-story-splitting-vertical-slice-vs-horizontal-slice/
  5. https://edworking.com/blog/productivity/what-is-vertical-slicing-and-why-it-is-important
  6. https://framework.scaledagile.com/story
  7. https://www.gamedeveloper.com/design/why-we-should-stop-saying-vertical-slices-
  8. https://scaledagileframework.com/story/
  9. https://www.humanizingwork.com/the-humanizing-work-guide-to-splitting-user-stories/
  10. https://scaledagileframework.com/wp-content/uploads/2021/07/User-Story-Primer.pdf
  11. https://agile.appliedframeworks.com/applied-frameworks-agile-blog/user-stories-making-the-vertical-slice
  12. https://www.jimmybogard.com/
  13. https://github.com/LuckyPennySoftware/MediatR
  14. https://ltpf.ramiismail.com/prototypes-and-vertical-slice/
  15. https://tonogameconsultants.com/vertical-slice/
  16. https://fungies.io/whats-vertical-slice-a-quick-guide/
  17. https://80.lv/articles/tim-cain-showcased-the-outer-worlds-vertical-slice
  18. https://starcitizen.tools/Squadron_42_Vertical_Slice
  19. https://www.youtube.com/watch?v=BHR1aEdTA4M
  20. https://x.com/starcitizenbot/status/1962380434492293354
  21. https://www.mountaingoatsoftware.com/blog/using-vertical-slicing-and-estimation-to-make-business-decisions-at-adobe
  22. https://www.scrum.org/forum/scrum-forum/26147/horizontal-vs-vertical-story-slicing-or-why-horizontal-slicing-considered
  23. https://softwareengineering.stackexchange.com/questions/228110/disadvantages-of-vertical-user-stories
  24. https://www.zenhub.com/blog-posts/vertical-slicing-for-cross-functional-team
  25. https://agilealliance.org/glossary/story-mapping/
  26. https://arxiv.org/abs/2407.13258
  27. https://framework.scaledagile.com/continuous-delivery-pipeline
  28. https://www.milanjovanovic.tech/blog/vertical-slice-architecture
  29. https://www.milanjovanovic.tech/blog/vertical-slice-architecture-where-does-the-shared-logic-live
  30. https://learn.unity.com/course/design-and-publish-your-original-game-unity-usc-games-unlocked/unit/milestones/tutorial/your-first-milestone-vertical-slice
  31. https://learn.microsoft.com/en-us/azure/devops/boards/sprints/task-board?view=azure-devops
  32. https://docs.getunleash.io/what-is-a-feature-flag
Add your contribution
Related Hubs
User Avatar
No comments yet.