Most teams build software the wrong way. They start with databases, then APIs, then UIs-layer by layer. It feels organized. It feels safe. But by the time users see anything, six months have passed. And when they finally do, it’s not what they asked for. Or worse, it’s half-baked, missing the point entirely.
There’s a better way. It’s called vertical slicing. Not horizontal. Not component-by-component. Not plumbing-first. But end-to-end. One small, complete feature that does one thing well-from the button click to the database update, with real feedback in between.
Think of it like building a house. Horizontal slicing is laying all the bricks, then all the pipes, then all the wires. Vertical slicing? You build one room. Door, light, sink, toilet, walls-all working. Then the next room. And the next. Customers don’t care about your foundation until they can use the shower.
What Vertical Slicing Actually Means
Vertical slicing isn’t a buzzword. It’s a shift in thinking. A vertical slice is a thin slice of functionality that cuts through every layer of your system to deliver real user value. Not theory. Not code that works in isolation. But something a real person can use, test, and tell you whether they like it.
Here’s a real example: "As an admin, I want to be prompted with a notification every time there’s a purchase so I can email the customer." That’s a vertical slice. It requires:
- A frontend prompt (UI)
- Backend logic to detect purchases
- A database change to log the event
- Email service integration
- Testing that it works end-to-end
All of it, in one go. Done in two weeks. Not six.
This is different from horizontal slicing, where one team builds all the databases, another builds all the APIs, and a third builds all the UIs. By the time they glue it together, everyone’s confused. The UI doesn’t match the API. The database schema changed. The emails never send. Integration becomes a nightmare.
Why Horizontal Slicing Fails
Horizontal slicing sounds logical. Build the foundation first. Then the walls. Then the roof. But software isn’t a house. You can’t test a foundation alone. You can’t show a client a database schema and say, "This is your new system."
Teams using horizontal methods often face:
- Delayed feedback-users don’t see anything for months
- Integration hell-everything breaks when layers finally connect
- Wasted effort-features built that no one wanted
- Low morale-developers feel like cogs, not creators
Adobe’s team in 2022 hit this wall hard. They had 12 engineers working on separate layers. After four sprints, they had a fully built API, a polished UI, and a solid database-but nothing worked together. The Product Owner asked, "Where’s the value?" No one could answer.
That’s when they switched. They stopped thinking in layers. Started thinking in actions.
How to Slice Vertically
It’s not magic. It’s a process. Here’s how to do it right:
- Start with the user action. What’s the smallest thing a person wants to do? Not "add a user," but "add a user and get a confirmation email."
- Define the "happy path." Ignore edge cases. Ignore error states. Just make the main flow work. You can fix bugs later.
- Include every layer. UI, logic, data, notifications, logging-everything needed for that one action to complete.
- Set a 1-4 week limit. If it takes longer, you’re slicing too thick. Break it down further.
- Test it with real users. Not QA. Not stakeholders. Real people who’ll use it. Watch them. Listen to their frustration.
Monday.com’s 2026 guide says: "If you can’t explain the slice in one sentence, it’s not vertical."
Example: "As a customer, I want to reset my password with a link sent to my email." That’s one slice. One week. Done.
Not: "Build password reset functionality." Too vague. Too broad. Too horizontal.
Why This Works
Vertical slicing isn’t about speed. It’s about learning.
Every slice is a hypothesis: "If we build this, users will do X." You build it. You test it. You learn. Then you adjust.
Here’s what happens when you do it right:
- Feedback loops shrink. Stakeholders see progress every sprint. They give input. You adapt. No surprises.
- Risk drops. Instead of one big integration failure, you have 10 small ones. You fix them early.
- Value appears fast. Revenue-generating features ship in weeks, not quarters.
- Teams get aligned. Designers, devs, QA-all working on the same goal. No silos.
Teravision Tech’s 2023 study found teams using vertical slicing delivered features 40% faster. But more importantly, 78% reported higher stakeholder satisfaction.
Customers don’t care about your ORM. They care if they can log in.
Common Mistakes
It sounds simple. But most teams mess it up.
Mistake 1: "Vertical" slices that are still horizontal. "Build the notification system." That’s not vertical. That’s a component. A true vertical slice includes the trigger, the display, the user action, and the outcome-all together.
Mistake 2: Too big. "Build the entire checkout flow." That’s not a slice. That’s a project. Break it down: "Let users add an item to cart." Then "Let them enter shipping info." Then "Let them pay with PayPal."
Mistake 3: Ignoring cross-functional work. If your UI team waits for the backend team, you’re not doing vertical slicing. You’re just renaming horizontal.
Mistake 4: Skipping testing. If you don’t test with real users, you’re just building in the dark. Vertical slicing fails without feedback.
Reddit user u/CodeCraft34 wrote in November 2025: "We reduced our sprint cycle from 6 weeks to 3. But only after we stopped calling database changes 'features.' We had to unlearn years of bad habits."
Tools That Help
You don’t need fancy software. But you do need structure.
- Kanban boards to track each slice from "idea" to "done"
- Sprint boards that show vertical slices, not technical tasks
- Product roadmaps that visualize user outcomes, not technical milestones
- Jira’s 2025 vertical slice tracking-now lets you map dependencies across layers within a single feature
Adobe’s team started with sticky notes on a wall. They drew lines between UI, backend, and DB tasks for each slice. Seeing those connections changed everything.
When Vertical Slicing Doesn’t Work
It’s not a cure-all.
Vertical slicing struggles in:
- Legacy systems where layers are tightly coupled and can’t be changed independently
- Highly regulated industries like healthcare or finance, where full system validation is required before any release
- Teams with rigid roles-if your database engineer won’t touch UI code, you’ll fight this every sprint
But even then, you can adapt. Hybrid approaches are emerging. For example: build foundational layers horizontally, then wrap them in vertical slices for user-facing features.
Gartner reported in late 2025 that 68% of high-performing teams now use vertical slicing as their default. That’s up from 32% in 2020. The shift is real.
Start Small. Think Big.
You don’t need to overhaul your whole process. Pick one feature. One user story. One slice. Build it end-to-end. Ship it. Get feedback. Repeat.
Ask yourself: "What’s the smallest thing we can build that delivers real value?" Not the easiest. Not the fastest. The one that matters most to someone who’ll use it.
That’s the heart of vertical slicing. It’s not about code. It’s about connection. Between the user and the product. Between the team and the outcome.
Stop building walls. Start building rooms.
What’s the difference between vertical and horizontal slicing?
Vertical slicing builds complete, user-facing features that go through every layer of the system-UI, logic, database-all in one go. Horizontal slicing builds each layer separately: all databases first, then all APIs, then all UIs. Vertical delivers value fast. Horizontal delays value until everything is done.
Can vertical slicing work with remote or distributed teams?
Yes, but it requires more discipline. Adobe’s 2025 retrospective showed that distributed teams struggled at first because they defaulted to layer-based handoffs. The fix? Daily syncs focused on slice progress, shared Kanban boards, and video walkthroughs of each feature. Tools like Jira’s vertical slice tracking helped visualize dependencies across time zones.
How do you know if a slice is too big or too small?
A slice is too big if it takes more than four weeks to complete. Too small if it doesn’t deliver meaningful user value-like "add a button" or "change a color." Good slices are tied to user actions: "Send a confirmation email," "View order history," "Filter search results." If a user can’t say "I did that," it’s not a real slice.
Does vertical slicing mean we don’t need good architecture?
No. In fact, it demands better architecture. When you build end-to-end features quickly, you can’t afford technical debt. Poorly designed APIs or tightly coupled components will break every slice. Vertical slicing exposes bad architecture fast-so you fix it early, not after six months of work.
Is vertical slicing just Agile with a new name?
It’s not a new name-it’s a refinement. Agile encourages iterative delivery. Vertical slicing gives you a clear method to do it: deliver one complete, testable user feature per sprint. It turns Agile’s "build small" into "build complete." Scrum.org’s 2025 forum called it "the missing link between Agile theory and real-world delivery."
Ian Cassidy
8 February, 2026 - 15:23 PM
Vertical slicing? Sounds like just another buzzword from the Agile circus. I’ve seen this before-teams think they’re being ‘lean’ by building one ‘room’ at a time, but half the time they’re just delaying the real architecture work. You can’t ship a shower if the pipes don’t even exist yet.
At my last gig, we tried this. Two weeks in, the frontend team had a button that did nothing. The backend team was still arguing over schema design. No one talked. The ‘slice’ was just a fancy word for ‘half-baked prototype.’
Real engineering isn’t about pretending you can skip layers. It’s about knowing when to build the foundation-and when to stop pretending you can ship a working feature before the foundation’s cured.
Amy P
9 February, 2026 - 08:47 AM
OH MY GOD. THIS. THIS IS EXACTLY WHAT WE NEEDED IN 2022.
I remember our team-14 people, 6 sprints, zero user feedback. We had a beautiful API, a UI that looked like a Apple ad, and a database with 47 tables. But when we showed it? Users said, ‘Wait… so I click this… and then what?’
We switched to vertical slices. First slice? ‘Reset password.’ One week. One email. One button. One user tested it. She cried because it worked. Not because it was fancy. Because it *worked*.
Now we ship a slice every 5 days. Our NPS went from 12 to 68. We stopped building monuments. We started building doors.
Stop building walls. Start building rooms. I’m crying. I’m so proud.
Ashley Kuehnel
9 February, 2026 - 15:58 PM
Hey everyone, I just wanted to say thank you for this post-seriously. I’m a junior dev and this is the first time I’ve seen someone explain vertical slicing in a way that made sense.
Before this, I thought ‘vertical slice’ was just a fancy way to say ‘do more work.’ But now I get it: it’s not about doing more. It’s about doing *meaningful* work.
We tried it last sprint on our cart feature. Instead of building the whole checkout flow, we did just ‘add to cart’-with real email confirmation. User tested it. Said it was ‘too simple.’ We laughed. Then they said, ‘Can I do this on my phone?’ So we added mobile. Then they said, ‘Can I undo it?’ So we added undo.
It wasn’t perfect. But it was real. And that’s the magic. You don’t need to build everything. Just build the next tiny thing that matters.
Also, if you’re stuck, just ask: ‘What’s the smallest thing a person would be mad if we didn’t do?’ That’s your slice. I promise.
Colby Havard
10 February, 2026 - 23:25 PM
It is, of course, entirely unsurprising that the author of this piece has conflated the metaphysical with the methodological. Vertical slicing, as presented here, is not a ‘shift in thinking’-it is a rebranding of the ancient principle of incremental delivery, itself a derivative of the scientific method.
One cannot, in good faith, claim that building a ‘room’-a singular, end-to-end user action-is somehow superior to the disciplined, layered construction of systems. The house must have a foundation; the bridge, a keystone.
Moreover, the assertion that ‘customers don’t care about your ORM’ is both trivial and misleading. They do not care about the ORM because, ideally, they should not have to. The architecture must be sound, even if invisible. To prioritize surface-level utility over structural integrity is not innovation-it is negligence.
And yet, the anecdotal evidence presented here-Adobe, Monday.com, Teravision-is statistically insignificant. A sample size of three corporations, with no control group, no peer review, no longitudinal data-this is not evidence. It is marketing.
One must ask: if vertical slicing is so superior, why do the most scalable, resilient systems in existence-banking, aerospace, telecommunications-still rely on horizontal decomposition?
Perhaps, dear reader, the answer lies not in the ‘room,’ but in the foundation.
Peter Reynolds
11 February, 2026 - 21:01 PM
i think the point is less about architecture and more about not wasting time building stuff no one wants
we had a whole module built for 'advanced analytics dashboard' that took 3 months
user tested it once
they said 'i just want a number'
we deleted it all
built a single number in a week
they loved it
vertical slice = stop building castles
start building signs
Mark Nitka
12 February, 2026 - 22:30 PM
Colby’s comment above is classic. The fear of ‘skipping layers’ is real-but it’s also the biggest blocker to real progress. I’ve led teams on both sides. Horizontal teams spend 80% of their time waiting. Vertical teams spend 80% of their time learning.
Yes, architecture matters. But architecture evolves. You don’t design a bridge by building the whole thing first-you prototype piers, test loads, adjust. That’s what vertical slicing is: iterative structural refinement.
Adobe didn’t throw out their architecture. They made it *responsive*. Every slice exposed a flaw. Every flaw got fixed before it became a legacy.
Stop thinking of architecture as a monument. Think of it as a living system. Vertical slicing doesn’t ignore it-it forces it to evolve with real feedback.
And if your database engineer won’t touch UI code? That’s not a technical problem. That’s a cultural one. Fix that first.
Zach Beggs
13 February, 2026 - 02:14 AM
i like this. we started doing this on our support portal. instead of 'build ticket system' we did 'user can submit a ticket and get a confirmation email' in 4 days. it was ugly. but it worked. now we add one thing every sprint. no more 'we'll do it later.'
also: if you're still arguing about 'is this agile?' you're missing the point.
adam smith
13 February, 2026 - 04:04 AM
This is just Agile 2.0. We did this in 2015. Stop reinventing the wheel.