Skip to content
Proudly Canadian, serving Windsor to Toronto, Ontario · clients welcome from every countryContact usClient login
CodeLumaDevelopment Inc.

Home / Blog / Article

CodeLuma insights · September 23, 2026 · 7 min read

MVP Scope Cutting: The Must-Have vs. Later Filter

A simple four-question scoring method for sorting your feature backlog so your first release supports one core user journey, with the rest safely parked for later.

Every founder we talk to has the same backlog problem: forty good ideas and a launch date that only has room for four. The hard part isn't coming up with features, it's admitting that most of them can wait. Scope cutting feels risky because it's easy to imagine the customer who leaves because a feature was missing, and much harder to imagine the launch that never happens because the list never got shorter. This article walks through a simple, repeatable way to sort a feature backlog so your first release supports exactly one core user journey, and nothing else.

Illustrative process, not a fixed formula
Illustrative process, not a fixed formula

Why Scope Cutting Is Hard (Not Stupid)

If you've struggled to cut your own backlog, it's not because you're bad at prioritizing. Scope creep usually comes from good instincts pointed at the wrong problem. Stakeholders each protect the feature they championed. Nobody wants to be the person who said no to the thing a big client asked for. And every feature already has a story attached to it, which makes it feel more load-bearing than it actually is. The fix isn't willpower, it's a method that takes the decision out of the room's politics and puts it into a shared, visible score.

A clipboard with a checklist
Original CodeLuma 3D render: a clipboard with a checklist.

Start With One User Journey, Not One Product

Before you score a single feature, write down the one path a user has to walk to get value from your product. Not three paths. One. For a booking app, that might be: create an account, find a provider, pick a time, pay, get a confirmation. Everything that supports that exact path is a candidate for must-have. Everything else, no matter how useful, is by definition supporting a different journey and belongs in a later release. This single decision does more scope-cutting work than any scoring exercise that follows it, because it gives you a fixed target to score against instead of a vague sense of "important."

The Scoring Method: Four Questions Per Feature

For every feature in your backlog, ask the same four questions and score each one from 1 (no) to 3 (yes, completely):

  • Does it block the core journey? If a user cannot finish the one path you defined without it, score it high.
  • Is there no workaround for launch? If you could handle it manually, by email, or with a spreadsheet for the first few weeks, score it low.
  • Does it protect money, safety, or trust? Payment accuracy, basic security, and data correctness score high even if they're invisible to users.
  • Would cutting it break a promise you already made? A signed contract or a public commitment scores high; an internal wish does not.

Add the four scores together for a total out of twelve. Features that land at nine or above are strong must-have candidates. Anything under six is almost always safe to defer. The middle ground is where real conversation happens, and that's fine, that's what the method is for.

How To Run The Scoring Session

Get the backlog into one list, in one document, visible to everyone who has a stake in the decision. Have each person score independently first, without discussion, so one loud voice doesn't anchor the room. Then compare scores feature by feature. Big disagreements are more useful than agreement, because they usually mean two people are picturing two different user journeys. Timebox the whole exercise, ideally to an hour or two. A scoring session that drags on for a week usually means the core journey wasn't actually agreed on at the start, so it's worth stepping back and re-confirming that before scoring more features.

Illustrative categories to sort a backlog
Illustrative categories to sort a backlog

What "Must-Have" Actually Means

Must-have doesn't mean valuable, popular, or requested by your biggest prospect. It means the specific journey you defined literally does not work without it. A polished onboarding flow is valuable. Whether it's must-have depends entirely on whether a plain, unpolished version would still let a first user complete the journey. This distinction is where most MVP scopes quietly balloon back up to full-product size, because "valuable" describes almost every feature on the list, while "the journey breaks without it" describes very few. If you're working with a technical partner on this, it's worth having them in the scoring session, since custom software development teams can often tell you in minutes whether a feature is a genuinely small addition or a much bigger build than it looks from the outside.

Where Later Features Go (Not The Trash)

The features that don't make the cut don't disappear, they move to a parked list with the score they earned and the reasoning behind it. This matters for two reasons. First, it keeps the conversation from repeating itself every time someone remembers a good idea they had three weeks ago. Second, it gives you a ready-made starting point for the next release, scored and ranked instead of scattered across old messages. Ongoing maintenance and support plans exist partly for this reason: a healthy MVP isn't a finished product, it's the first step of a list you already agreed on, revisited on a real schedule instead of whenever someone gets anxious about competitors.

An open notebook and pen
Original CodeLuma 3D render: an open notebook and pen.

A Simple Checklist Before You Cut

Run the list past these checks before you finalize anything:

  • Is the core user journey written down in one sentence everyone agrees on?
  • Has every feature been scored against the same four questions, not gut feel?
  • Are security, backups, and basic error handling included even though they're invisible?
  • Does the must-have list still let a real user complete the journey end to end?
  • Is the later list documented somewhere permanent, with scores attached?
  • Has at least one person argued for cutting something you personally like?

If you can't check every box, the cut isn't done yet, it's just started.

Common Mistakes Teams Make When Scoping

A few patterns show up again and again. Scoring by whoever's in the room that day, rather than against the four questions, quietly reintroduces politics into a process meant to remove it. Cutting the unglamorous engineering work, like input validation or basic error states, because it isn't visible on a mockup, which then shows up later as bugs instead of backlog items. Treating "later" as "never," so the parked list rots and nobody trusts it, which pushes people to fight harder to get things into v1 because they don't believe they'll get a second chance. And building for a scale or feature set you don't have users for yet, which is a separate conversation worth having on its own; if that's a live concern for your team, it's covered in more depth in our piece on architecture choices for scale.

When To Revisit The Cut List

The right time to reopen the parked list is after you have real usage data from the launched journey, not before. That might be a few weeks in, it might be longer, and it depends entirely on your product and audience, so resist the urge to put a fixed date on it before you've seen how people actually use what you built. When you do revisit it, re-score with the same four questions rather than starting from scratch. Usage data will usually move a few items up the list and confirm that most of the rest genuinely can wait.

Wrap-Up

Cutting scope isn't about wanting less, it's about sequencing correctly. A backlog scored against one clear user journey and four honest questions turns an emotional argument into a visible, defensible list, and gives you a real answer the next time someone asks why a feature didn't make the first release: because the journey worked without it, and it's already on the list for what comes next.


Put this into practice with CodeLuma

CodeLuma runs feature-scoring exercises like this one as part of our discovery process, so your first release is scoped around what your users actually need to complete one job, not what feels safest to build. We help you turn the "later" list into a real, prioritized roadmap instead of a graveyard of good ideas.

Start a conversation. Tell us about your project and we will reply with practical next steps, or browse all CodeLuma services. CodeLuma Development Inc. is a Canadian company that works with teams in Windsor, Essex, London, Toronto, Mississauga and across Ontario, throughout Canada and remotely.

Keep reading

Share this article: Facebook · LinkedIn · X · Email

← All articles

Ready to put this into practice?

Talk to a Canadian full-stack team that builds complex, connected systems for clients across Canada and worldwide.

Start a project