A new feature request usually arrives as a noun: reporting, onboarding, approvals, notifications. Nouns are large, and the team that receives one can start almost anywhere. The place it starts decides what the product owner sees first, what gets tested first, and how much of the original intent is still recognizable when the first release meets real users. Slicing is the habit of choosing that starting point on purpose, and it is one of the quieter decisions in feature development.
Layers are a poor unit of progress
The default way to split work is by technical layer: the database changes first, then the service, then the interface. It feels orderly, because each layer has a natural owner and a natural sequence. The weakness is that nothing visible exists until the last layer lands. Until then the product owner has only status updates to review, and any misunderstanding about the behavior stays hidden inside layers that look finished.
A layered plan also postpones the hardest integration questions. The interface team learns late that the service returns data in a shape that does not fit the screen. The service team learns late that the database cannot answer a question the screen needs to ask. Each discovery is cheap on the first day and expensive at the end.
What a vertical slice is
A vertical slice cuts through every layer, but only for a narrow piece of behavior. Instead of “all of reporting”, the slice is “one user opens one report and sees one kind of result”. It touches the interface, the service and the data, and it can be run, looked at and accepted by itself.
The idea has a long history in agile practice. The Scrum Guide describes refinement as the act of breaking down and further defining backlog items into smaller, more precise items. Alistair Cockburn’s walking skeleton is a close relative: a tiny implementation of the system that performs a small end-to-end function and links the main architectural components. In both, the purpose is the same. Make something small enough to finish and whole enough to judge.
Choosing the first slice
Several questions help pick a slice, and they work better when asked in this order.
- Which behavior carries the idea? Every product feature has a core: the one thing that, if it worked, would show the product owner that the idea was understood. Start there, not with settings, edge screens or administration.
- Which behavior is the riskiest? If one part depends on an unfamiliar integration or an uncertain data source, put it in an early slice so the risk surfaces while changing course is still cheap.
- Which behavior can be accepted in one sitting? A slice the product owner cannot judge in a single review is probably two slices.
- Which behavior can run beside the current product without changing it? An early slice that touches shared code widely creates coordination work for everyone else. A slice with a narrow footprint keeps the existing roadmap moving.
Writing the slice down
A slice needs a short statement that both the product owner and the engineers can read. A workable form has three parts: the behavior in plain words, the condition under which it counts as accepted, and what is explicitly left out of this slice. The third part matters most. Naming what is not included stops the slice from growing quietly, and it gives later slices a visible list to draw from.
Where a slice meets the existing system
For teams that already run a product, the first slice also tests the boundary with the existing system. The new behavior has to read data the current product keeps, respect rules it already enforces, and appear in a place users already know. JetRuby describes this way of working next to an in-house team on its page about feature development services, where a product owner and an engineer turn intent into acceptance criteria and build the first agreed piece alongside the core system. The slicing questions above are the same ones that decide what that first piece should be.
Signs that a slice is well chosen
- It can be demonstrated with real data in a real environment, not a mock-up.
- Its acceptance statement fits in a few sentences.
- Removing it would leave the existing product exactly as it was.
- The next slice can be chosen after seeing it, rather than being fixed in advance.
The last point is easy to miss. A set of slices planned in full detail at the start is just a layered plan cut into smaller pieces. The value of the first slice is the information it produces: whether the data behaves as assumed, whether the screen reads as intended, whether the product owner recognizes the idea in the result. That information should be allowed to change the second slice.
Common mistakes
- Slices that are layers in disguise. “Build the API for reports” is a layer with a friendlier name. If the slice cannot be demonstrated to the person who asked for the capability, it is not vertical.
- A first slice that is too ambitious. Folding in every edge condition turns the first slice into the whole feature. Handle the main path first and name the edge conditions as later slices.
- A first slice that is too trivial. A static screen with no real data proves nothing about the hard parts. The slice should touch real data and real rules, even if only for a narrow input.
- No stopping rule. Without an agreed acceptance statement, “one more tweak” has no end. Decide what done means before the work starts.
In short
Large requests become manageable when the first piece is small, whole and judged by the person who holds the idea. Choose the behavior that carries the intent, include the risky part early, keep the footprint narrow, write down what is left out, and let what the first slice teaches shape the next one.
Read more: AI-Driven Software: Changing the Game for Businesses





