ProjekinAja. Founder's Playbook Stage 2 · Build The Right Thing Lesson 2.3
● Stage 2 · Lesson 2.3

Scoping the MVP — Ruthless Subtraction

Every feature added to an MVP before validation is a bet made without evidence — and most of those bets lose.

⏱ ~20 min read 🔪 Scope management ⚙ RICE prioritization

🎯 By the end you'll understand

What the core loop is and why everything outside it is scope creep until validated; how to apply RICE prioritization adapted for MVP scoping where Confidence measures whether a feature tests a real assumption; how to identify learning debt before you incur it; the specific failure mode of the six-month MVP that started as a two-week experiment; and how Forge's v1 scope was ruthlessly cut to the minimum that could test the defect-detection assumption before anything else was built.

KEY INSIGHTThe MVP is a test, not a product

An MVP is the minimum set of actions that generates the data needed to confirm or kill your most critical assumption. Every feature that does not serve that test is waste — expensive, time-consuming, assumption-introducing waste.

Here is a thought experiment. You have validated the problem. You know tier-1 auto parts manufacturers experience quality escapes from manual inspection, you know the cost is real and documented, and you know at least some of them are willing to pay for an automated solution. Now you sit down to scope version one of Forge. The list you write will determine whether you ship in six weeks or six months — and whether the version you ship can actually teach you anything.

🔑 The question every feature must answer

Before adding any feature to the MVP, ask: does this feature generate evidence that tests a currently unvalidated assumption? If the answer is no, the feature is not contributing to your learning objective — it is contributing to the build timeline and the complexity budget. An MVP that "seems professional" but tests nothing is not an MVP. It is a demo with a launch announcement.

CORE CONCEPTThe core loop — the irreducible sequence

The core loop is the minimum sequence of actions a customer must take to get the outcome that validates your hypothesis. Everything else — reporting, user management, integrations, export, mobile, customization — is outside the core loop. It might eventually be necessary. It is not necessary now, before you know whether the core outcome is real.

For Forge, the hypothesis is: edge vision devices detect surface defects in real-time at line speed, and when manufacturers see this working on their line, they recognize it as meaningfully better than their current process and will pay for it. That is the hypothesis. The core loop is therefore:

1

Camera captures frames at line speed

The edge device physically installs over a production line section, acquires frames in real time, and the model runs inference without lagging behind the line. Everything depends on this step — if the latency requirement is not met, the rest of the loop does not matter.

2

Model flags a defect and records a timestamp + image crop

The inference result is persisted: defect type, confidence score, line position, timestamp, and a cropped image. This is the minimum record that makes the event auditable. Without it, the ops manager cannot verify the system caught something — or missed something.

3

Ops manager reviews flagged events in a dashboard

A simple dashboard showing a list of flagged events, each with the crop and basic metadata. The ops manager can click into an event and say "yes, that is a real defect" or "false positive." This is the only interaction with the dashboard that the hypothesis requires.

4

Activation data confirms detection improvement

After 30 days, the pilot data shows: number of defects caught, false positive rate, comparison to the baseline escape rate measured before installation. This data is the validation signal. Without it, the pilot is a demo, not a test.

That is the core loop: install → detect → review → measure. Everything else that could go into Forge v1 — anomaly trend charts, email digests, shift-level summaries, multi-site views, API access for the customer's ERP, configurable alert thresholds, user roles with permissions, mobile app, exportable PDF reports — is outside the core loop. It is scope creep until the core loop is validated.

INSTALL DETECT REVIEW MEASURE Multi-site view ERP integration Role permissions PDF exports Email digest Mobile app Trend charts Alert thresholds CORE LOOP ← scope creep (until validated)
The Forge v1 core loop. Everything inside the circle is the MVP. Everything outside is scope creep until the loop is validated — no matter how obviously useful it looks.
💡 How to identify the core loop

Ask: if this feature disappeared, would the customer be unable to experience the core value? If yes — it is in the loop. If no — it is outside the loop, and adding it before validation is incurring learning debt. The loop should be expressible in four to six steps. If it takes ten steps to describe, you have not found the core loop yet; you have described a product.

HOW IT WORKSRICE adapted for MVP scoping

RICE is a prioritization framework originally developed at Intercom for product roadmap decisions. It ranks features by: Reach (how many customers or use-cases does it affect), Impact (how significantly does it move the metric that matters), Confidence (how sure are you the estimate is right), and Effort (how much it costs to build, in person-weeks). The formula is:

📐 RICE Score

RICE = (Reach × Impact × Confidence) ÷ Effort

Higher is better. A feature with a RICE score of 40 takes priority over one with a score of 12.

For MVP scoping, standard RICE needs one important modification: Confidence should reflect the probability that this feature tests an unvalidated assumption, not just the probability that your estimate is accurate. In the standard framework, Confidence is about estimate certainty. In MVP scoping, it is about learning value. The question becomes: how confident are you that building this feature will generate evidence that advances or kills your most critical open hypothesis?

Dimension Standard RICE MVP RICE (this lesson)
Reach Users affected per period Fraction of pilot users who encounter this during the core loop (0–1)
Impact Effect on a metric (1–3 scale) How critical is the assumption this tests? (1=nice-to-know, 3=kill/pivot if wrong)
Confidence Certainty in your estimate (pct) Probability this feature actually tests the assumption, not just supports comfort (pct)
Effort Person-weeks to build Build days (more granular for an MVP timescale)

The key insight from the modified Confidence term: many features founders add to MVPs feel like they are testing an assumption, but they are actually making the product more comfortable to demo or more impressive to look at. A slick dashboard skin does not test whether the detection model is accurate. A configurable alert threshold does not test whether ops managers will change their workflow. A role-based permission system does not test whether the product is worth paying for. These features have low MVP Confidence even if they feel important — because the learning value is near zero.

⚠ Learning debt vs. regular technical debt

Technical debt is features built quickly that will need to be cleaned up later. Learning debt is features built before you know whether they matter — features that were added to an MVP before the core assumption was validated. Learning debt is worse than technical debt: you can refactor code, but you cannot un-spend the time or reclaim the opportunity cost of learning later. A feature built before it was validated is learning debt even if the code is perfect.

SEE ITFeature Cutter — scope your Forge v1

⚙ Interactive · Feature Cutter for Forge v1

Below are 12 features planned for Forge v1. For each, rate: (1) whether it tests a core assumption (Yes/No), (2) estimated build effort in days, and (3) customer criticality (1 = nice to have, 5 = cannot use without it). The widget applies MVP RICE to score every feature, builds a core-loop shortlist, flags learning debt, and shows how total build time shrinks as non-essential features are cut. The goal is to see how few features are required to validate the hypothesis.

CORE LOOP  Tests an assumption · high score LEARNING DEBT  High effort, low learning value CUT  Post-validation only
Feature Tests assumption? Build effort (days) Criticality (1–5)

The most common insight from this exercise: founders who score their features honestly discover that 3–5 features account for the entire learning objective, and the other 7–15 are either comfort features, investor-demo features, or "while we're at it" additions. The core loop for Forge v1 — real-time detection, event logging, and a review screen — takes roughly 18–25 build-days with a focused two-person team. The full feature list founders typically write takes 80–120 build-days and produces no additional learning.

FORGEScoping Forge v1 — what actually made the cut

At the end of Stage 1, Forge has three signed pilot contracts at $8,000 each and one manufacturing site ready for deployment. The milestone for Stage 2 is: edge device plus dashboard MVP deployed, first activation data collected, evidence that customers who complete onboarding see measurable defect-detection improvement within 30 days. Here is how the v1 scope was decided.

IN

Edge inference pipeline — real-time defect detection at 30fps

The entire hypothesis rests on this. If the model cannot run at line speed on the edge device without dropping frames, there is no product. This is not negotiable — it is the core technical assumption, and the only way to test it is to build it and run it on an actual production line. Estimated effort: 9 days. MVP RICE score: very high (tests the most critical assumption, affects all pilot users, directly validates the hypothesis).

IN

Event log with image crops and timestamps

Without a persistent record, there is no evidence to review, and the ops manager cannot audit what the system saw. This is the minimum viable data layer for the review step of the core loop. Estimated effort: 4 days. No event log, no validation — it stays.

IN

Ops manager review screen — list of flagged events with accept/reject

This is the activation step: the ops manager sees the detections, decides if they are real defects, and the system accumulates confirmation rate data. It needs to show the image crop, defect type, timestamp, and line position. Nothing more. Estimated effort: 5 days. This is the only dashboard feature that is in scope for v1.

IN

30-day activation summary report — auto-generated at pilot end

At 30 days, Forge needs to produce a single-page summary: defects caught, false positive rate, comparison to the pre-installation baseline. This is the data Forge uses to verify the milestone. It can be a simple generated PDF or a static page — it does not need a reporting engine. Estimated effort: 3 days.

OUT

Everything else — cut until post-validation

Configurable alert thresholds, email digests, shift-level rollups, user roles and permissions, ERP integration, mobile app, multi-site view, trend charts, anomaly severity scoring, API access, export to CSV — all of this was listed in the original v1 scope proposal. All of it was cut. None of it tests an assumption that is currently unvalidated. After the pilot data shows the core loop works, the team can prioritize these based on actual pilot feedback — not pre-validation intuition.

🔑 The Forge v1 number

The final Forge v1 scope: 21 build-days for a two-person team (1 ML engineer on inference pipeline + device integration, 1 full-stack engineer on event log + review screen + summary report). That is a four-week build cycle with a one-week buffer, not a six-month project. The original unscoped list was 94 days. The ruthless subtraction saved 73 days and preserved the pilot timeline across all three signed contracts.

IN PRACTICELearning debt — the cost of building before validating

Learning debt accumulates every time you build a feature before you know whether it matters. Unlike technical debt, which is about code quality, learning debt is about sequencing: you spent time on something that could not have taught you anything useful at the stage you were in. The debt compounds in two ways.

First, time cost. Every day spent building a non-core feature is a day not spent running your pilot, collecting activation data, or discovering that the core loop needs redesign. In a pilot context, time compression matters: you have pilot contracts with a specific timeline, and every week of delay before activation data comes in is a week of uncertainty that could affect the pilot renewal conversation.

Second, anchoring cost. Features that exist create expectations — in the team, in investors, and in customers. Once you ship an alert threshold configuration screen, customers start asking why the threshold options are limited. Once you ship a shift-level rollup, they ask why the rollup does not break down by operator. You have created a product surface area that now needs to be maintained and expanded, regardless of whether the core loop works. This is the opposite of an MVP — you have anchored yourself to a scope before you know what the scope should be.

Wk 0 Wk 4 Wk 8 Wk 12 Wk 16 Wk 20 Build core loop (4w) Pilot running Activation data ✓ Scoped MVP Building all 24 features (16w) — no learning Pilot starts (wk 16) Unscoped "v1" 12 weeks of learning debt
The scoped MVP gets pilot data 12 weeks earlier than the unscoped build. Those 12 weeks are the compounding interest on learning debt — spent building features that could not teach anything before the core loop was validated.

The compounding effect becomes visible when you consider what happens during the 12-week gap. The scoped MVP team, now running a live pilot, discovers in week 6 that ops managers are reviewing events by shift, not by defect type — meaning the entire event-list UI needs to be reorganized. They make that change in two days. The unscoped team, still building features for week 8, has already built a defect-type grouping into their event log architecture. Changing it now costs three days of refactoring and a migration. The learning came too late to be cheap.

WEAKNESSWhere this bites

✗ The "while we're at it" accumulation trap

The most common failure mode is not the founder who deliberately builds a bloated v1 — it is the founder who agrees to scope cuts in principle but keeps saying "while we're at it" during development. While we're building the event log, let's add filtering. While we're building the review screen, let's add a severity label. While we're integrating the edge device, let's add remote configuration. Each "while we're at it" sounds like a small marginal cost. Across a four-week build, they collectively add three to five weeks and every one of them is outside the core loop. The antidote is the core loop as a written specification — anything not on it requires a deliberate decision to add, not a default inclusion.

✗ Mistaking investor-demo requirements for customer requirements

Founders frequently add features to the MVP not because they test an assumption, but because the product will look more impressive in a demo to investors. This is a category error with serious consequences. Investors are not your pilot customers — they do not experience the product, they observe it. Adding a trend chart because it makes the dashboard look more complete to an investor but does not help the ops manager is a decision that serves your fundraising narrative at the expense of your validation timeline. If the core loop data is strong, investors do not need a polished UI. If the core loop data is weak, no UI polish will save you.

✗ The confidence trap — confusing feature confidence with assumption coverage

RICE Confidence in the MVP context measures whether a feature tests a real assumption. A feature can have high implementation confidence (you know exactly how to build it, the estimate is solid, the code is clear) but near-zero learning confidence (it does not test anything you do not already know). Founders often conflate these. "I'm very confident this feature will take 3 days and work correctly" is not the same as "I'm confident this feature will teach me something critical." The second is the only confidence that matters for MVP scoping. Features with low learning confidence should be cut even if they are technically easy and practically useful.

KEY INSIGHTHow this connects

  • 2.1 — From Problem to Solution: The Gap Between Insight and Product — that lesson showed why a validated problem does not uniquely determine the solution. The core loop concept in this lesson is the operational answer: you do not need to solve the whole problem in v1, you need to close the highest-criticality assumption gap. The core loop is the minimum solution surface that touches the critical assumption.
  • 2.2 — What MVP Actually Means — that lesson defined the MVP as a learning tool, not a stripped-down product. This lesson operationalizes that definition: the Feature Cutter applies RICE to determine which features actually belong in an MVP and which are pre-validation waste. "Minimum" in MVP is not about quality — it is about learning scope.
  • 2.4 — Prototype Strategies: Before You Write Production Code — next lesson asks whether the core loop even needs production code yet, or whether a prototype can validate the assumption faster. The scoping work done here determines which prototype strategy to choose: once you know what the core loop is, you can decide whether to test it with a Wizard of Oz, a concierge, or actual code.

The ruthless subtraction principle introduced here is not a one-time act — it recurs at every stage. In Stage 3, you will scope a pricing experiment rather than a full pricing strategy. In Stage 4, you will scope a sales playbook rather than a full go-to-market motion. The question "what is the minimum needed to test this specific assumption" is the foundational habit of a founder who learns faster than they spend.

GLOSSARYKey terms introduced

Core loop
The minimum sequence of actions a customer must take to experience the outcome that validates the core hypothesis. Everything outside the core loop is scope creep until the loop is validated. The core loop should be expressible in four to six steps.
Learning debt
Features built before the relevant assumption is validated. Unlike technical debt (code that needs to be cleaned up), learning debt is time spent on features that could not generate useful learning at the stage they were built. It compounds through anchoring and opportunity cost.
MVP RICE
RICE prioritization (Reach × Impact × Confidence ÷ Effort) adapted for MVP scoping, where Confidence reflects the probability that a feature tests an unvalidated assumption — its learning value — rather than just estimate certainty.
Learning confidence
The probability that building a feature will generate evidence that advances or kills a critical open hypothesis. Distinct from implementation confidence (certainty about build time and technical approach). Only learning confidence matters for MVP scoping decisions.
Scope creep (pre-validation)
Feature additions to an MVP before the core loop is validated. Pre-validation scope creep is qualitatively different from post-launch scope creep: it delays the moment you get real evidence and increases the amount of code written before you know what the product should actually be.
"While we're at it" trap
The pattern of marginal feature additions that each seem low-cost but collectively multiply MVP scope. Each addition sounds like a small extension of work already underway; together they transform a four-week build into a twelve-week build with no additional learning value.
Activation data
Behavioral evidence collected from a live pilot or early deployment that confirms (or denies) whether customers are completing the core loop and experiencing the hypothesized outcome. Distinct from stated feedback — activation data is what users actually do, not what they say they would do.
RICE score
Reach × Impact × Confidence ÷ Effort. A dimensionless prioritization number; higher is better. Used to rank features objectively by their expected return on build investment. In MVP scoping, Confidence is redefined to measure learning value per feature.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1A founder says "I already built a configurable alert threshold feature because customers will definitely need it." Using the core loop concept, explain whether this belongs in the v1 MVP and why.›

The question to ask is: does configurable alert thresholds appear in the core loop? The core loop for Forge v1 is: install → detect → review → measure. Configurable thresholds are not part of any of these four steps — the detection model runs with its trained confidence threshold, the ops manager can still review flagged events without configuring thresholds, and the 30-day activation report does not depend on threshold configuration. Therefore, this feature is outside the core loop, and the claim "customers will definitely need it" is an unvalidated assumption. The right sequencing is: deploy the core loop with a fixed threshold, collect pilot data on the false positive rate, and if that rate causes problems in actual use, add configurable thresholds in the next iteration. Adding it before the pilot generates learning debt — the assumption "customers need configurable thresholds" has not been tested, and the feature costs build time that delays the pilot.

2Explain learning debt in your own words. How is it different from technical debt, and why does it compound?›

Technical debt is code that works but was written quickly and will need to be refactored — the debt is in code quality. Learning debt is features built before you know whether they matter — the debt is in sequencing. You built something that could not have taught you anything useful at that stage, because the underlying assumption had not been tested. It compounds in two ways: first, as direct time cost — every day spent on a non-core feature is a day not spent getting pilot data, which could have told you what to build next. Second, as anchoring cost — once you ship a feature, it creates expectations in customers and the team, adding maintenance burden and constraining future redesigns. Technical debt makes the next sprint harder. Learning debt makes the next decision worse, because it constrains what you can change based on what you learn.

3In MVP RICE, Confidence is redefined to measure learning value rather than estimate certainty. Why does this matter, and what error does it prevent?›

Standard RICE Confidence asks: "How sure am I that my Reach and Impact estimates are right?" That is about estimate quality. MVP RICE Confidence asks: "How sure am I that this feature tests a real open assumption?" That is about learning purpose. The error it prevents is the high-confidence feature that teaches nothing. A perfectly estimated, technically clear feature with 95% implementation confidence can still have 5% learning confidence — meaning you are nearly certain it will be built correctly and nearly certain it will not teach you anything you do not already know. Without the learning-confidence framing, founders systematically prioritize features they feel confident about (technically well-understood) over features that test uncertain assumptions (which are uncomfortable to build precisely because they might fail). The modification forces the question: are we building this because it advances learning, or because it feels safe to build?

4Forge's original v1 scope list included multi-site view, ERP integration, and PDF export. These are all real customer needs. Why were they cut, and what is the correct process for adding them back?›

They were cut because none of them test any currently open assumption. The core hypothesis — that real-time edge detection improves defect catch rates and that customers will recognize this and value it — can be validated with a single site, with no ERP integration, and with a simple generated summary instead of a formatted PDF. Multi-site view, ERP integration, and PDF export are all features that presuppose the core hypothesis is already true: you would only need multi-site view if one site is already working; ERP integration is only worth building if the detection data is trusted enough to flow into systems of record; PDF export is a reporting feature that presupposes there is a reporting audience. The correct process for adding them back: run the pilot, collect activation data, confirm the core loop validates, and then interview pilot customers about what they would need for expansion, integration, and reporting. The resulting feature list will be prioritized by actual evidence — "three of our pilot customers asked specifically about ERP integration for their QA records workflow" — not by pre-validation intuition. Every one of these features is worth building eventually; none of them belongs in a scope that has not yet proven the core loop works.

Next: prototype strategies — testing the core loop before writing production code →