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

Building the MVP — Speed Over Polish

Production-quality code in an unvalidated MVP is the enemy of learning — here is how to build fast without accumulating debt that will haunt you.

⏱ ~22 min read ⚙ Interactive widget 🏗 Technical discipline

🎯 By the end you'll understand

Why production-quality code is actively harmful at the MVP stage, how to apply the reversibility heuristic to distinguish shortcuts that are fine from architectural decisions that will haunt you, how to build fast while keeping debt explicit and bounded, what causes the "permanent MVP" failure mode (the prototype that outlives the runway), and how to score your own architectural decisions on reversibility before you make them.

KEY INSIGHTThe MVP is not a small product — it is a structured bet

Every hour spent polishing an unvalidated MVP is a double loss: you spent the time, and you made the product harder to throw away when the hypothesis turns out to be wrong.

You have just scoped the MVP to its irreducible minimum (Lesson 2.3) and validated the prototype with real users before writing production code (Lesson 2.4). Now you have to build. The question is not "how do I build this well?" The question is "how do I build this fast enough that I can learn from it before I run out of runway — and smart enough that I don't create a debt bomb that kills the company when it scales?"

🔑 The core tension

Speed and quality are in genuine tension at the MVP stage. The resolution is not to find a compromise — it is to be deliberately selective. Most architectural decisions in an MVP are completely reversible at low cost. A small number are not. The discipline is identifying which is which, going fast on the reversible ones, and applying genuine rigor only to the irreversible ones. Treating every decision with equal scrutiny is how you build a beautiful, validated-quality codebase that you run out of money to ship.

CORE CONCEPTThe four technical disciplines of the MVP build

Building an MVP is not the same as building sloppily. It is building with specific, intentional constraints. Four disciplines define the difference:

1

Use existing infrastructure wherever it exists

Every time you build infrastructure from scratch that you could have assembled from existing components, you are spending runway on things that do not test your hypothesis. Forge does not need a custom model training pipeline for the MVP — it needs inference on a pre-trained backbone fine-tuned on a small labeled dataset, running on commodity hardware. You are not testing whether you can build a training pipeline. You are testing whether manufacturers will pay for accurate defect detection delivered on their line. Use what exists. Build custom only where custom is the hypothesis being tested.

2

Minimize abstraction layers until you know what abstracts

Abstraction layers exist to manage complexity that has materialized, not complexity you anticipate. In an MVP codebase, a three-layer architecture with a clean ORM, a service layer, and a presentation layer is often solving a problem you don't yet have at the cost of flexibility you desperately need. A flat structure with explicit, readable procedural code is easier to understand, easier to change, and easier to throw away. The right time to add an abstraction is when the pain it solves is real and present, not when you imagine it might be needed in a future you haven't reached.

3

Avoid premature optimization — every form of it

Premature optimization is not just about performance. It includes: writing generic solutions to specific problems (generalized event handling when you have two event types), designing for scale before you have the load (connection pooling when you have 20 concurrent users), and building configurability before you understand the configuration space (a rule engine when you have two rules). Every one of these is technically defensible. Every one of them costs time and flexibility. The MVP optimization rule is simple: optimize for the one variable that matters right now, which is time to validated learning. Everything else is secondary until the hypothesis is confirmed.

4

Document every shortcut explicitly and visibly

The MVP is not a production system and should not be pretending to be one. Every place you took a shortcut — hardcoded a value instead of building a configuration system, skipped input validation, used synchronous processing where async is needed at scale, stored data in a flat file instead of a database — document it with a comment or a TODO that explains: (a) what the shortcut is, (b) why it was chosen, (c) what the trigger condition for addressing it is. "TODO: replace hardcoded API key with env config before first external user" is infinitely better than a silent time bomb. Documentation is the only thing that converts technical debt from a surprise into a managed backlog.

MVP Decision Build fast (reversible shortcuts OK) Learning fast Rebuild with conviction Funded v2 Build polished (full abstraction, premature optimization) Learning late Runway ≈ 0 Runway consumed →
Two build paths to the same learning. The polished path arrives at learning — if it arrives — with too little runway to act on what it learned. The fast-but-deliberate path arrives early and rebuilds with conviction funded by evidence.
💡 The "would a competent engineer understand this in 5 minutes" test

Every MVP shortcut should pass one test: if a competent engineer who has never seen the codebase reads this section, would they understand what it does, why it was done this way, and what would need to change before it goes to production? If the answer is no, the shortcut is not documented — it is a trap. The discipline is not cleanliness for its own sake. It is legibility that allows fast iteration without undocumented surprises.

CORE CONCEPTThe reversibility heuristic — the only decisions worth agonizing over

The most reliable framework for allocating architectural attention in an MVP is reversibility. The question is not "is this decision good?" The question is "how painful is it to undo this decision after 6 months of code has been written on top of it?"

Decision type Examples Reversibility Implication for MVP
Data model / schema How you represent a "defect event", your tenant/org model, event vs. entity storage Hard — migrations compound Spend 2–4 hours designing this before touching a database. Get it approximately right.
External API contracts The shape of the API your dashboard calls, the event format from the edge device Hard — clients build on top Design the interface even if the implementation is a stub. Breaking contract changes are expensive.
Auth / identity model Single-tenant vs. multi-tenant, role system, API key vs. OAuth Hard — security refactors are total rewrites Decide early. Changing from single- to multi-tenant mid-product is catastrophic.
Core algorithm / model Which backbone for CV, inference format (ONNX vs. TFLite), hardware target Medium — expensive but isolated Choose the simplest option that meets the requirement. Document why. Plan to revisit.
Infrastructure choices Cloud provider, container orchestration, edge device OS Medium — migration is possible but painful Go with what you know fastest. Avoid deep vendor lock-in at MVP stage.
UI framework React vs. Vue vs. vanilla; component library choice Easy — UI rewrites are common Just pick one. Speed and existing team familiarity dominate.
Internal code structure File organization, naming conventions, whether to use a specific pattern Easy — refactor freely Whatever makes you move fastest. No design patterns until the code is 500+ lines.
Config / env management How you handle environment variables, secrets, feature flags Easy — replace in a day Hardcode in a constant file. Document. Replace before second external user.

The table above is a heuristic, not a law. The reversibility of any specific decision depends on how much other code will depend on it. A data model is hard to reverse because migrations require coordinating code changes, data transforms, and downtime. An internal naming convention is easy to reverse because it is contained to a single codebase under your control. The key question: "how many things downstream will I have to change if I undo this?"

📐 The reversibility scoring model

Score each decision on two dimensions: (1) Blast radius — how many files, systems, or external parties would need to change if you reversed this decision? (2) Migration cost — once you have data or clients depending on this, how expensive is the migration? High blast radius + high migration cost = hard to reverse. Low blast radius + cheap migration = fast to reverse. The widget below makes this concrete for Forge's specific architectural decisions.

Blast radius (how many things depend on this) Migration cost Low High Low High Easy to reverse Go fast, no ceremony Hard to reverse Agonize before committing Document your reasoning Easy to reverse Go fast, no ceremony Medium — monitor Note trade-offs explicitly UI framework Code structure Data model Auth/identity Infra/cloud
The reversibility matrix. Only decisions in the top-right quadrant (high blast radius, high migration cost) deserve serious up-front attention. Everything else — go fast and document the shortcuts.

SEE ITTechnical Decision Reversibility Matrix — score your MVP architectural choices

⚙ Interactive · Reversibility Matrix for Forge's MVP

Add up to 8 architectural decisions you need to make for Forge's edge-device + dashboard MVP. The widget scores each on blast radius and migration cost, identifies hard-to-reverse decisions, and — critically — requires you to document your reasoning for each hard-to-reverse decision before allowing you to proceed. This mirrors the real engineering discipline: you cannot skip the reasoning step for the decisions that will hurt you most.

Forge context: Three paid pilot contracts at $8K each. Edge device (NVIDIA Jetson Orin) plus React dashboard MVP. First activation data needed within 30 days of deployment. You are a team of 2 engineers with 6 months of runway.

📝 Quick-add presets — click to add a common Forge MVP decision
Reversibility summary
0
Hard to reverse
0
Medium
0
Easy to reverse
Complete the reasoning box for every hard-to-reverse decision before proceeding. These are the decisions most likely to constrain your architecture permanently — you need a documented rationale.
All hard-to-reverse decisions are documented. You have applied the reversibility heuristic correctly. Build fast on everything else — those shortcuts are safe to take.

Notice what this exercise reveals. Most of the anxiety in early technical decisions is spent on things that are actually easy to reverse — which framework to use, how to organize files, what to name things. Those decisions feel consequential because they are the most visible technical choices. The genuinely hard-to-reverse decisions are structural and often invisible until they become painful: the data model you have 500K rows of, the auth model you have three customers built on top of, the API contract that three external integrations depend on.

The forced documentation requirement for hard-to-reverse decisions is not bureaucracy. It is a discipline that produces two concrete benefits: it forces you to articulate the reasoning while it is fresh (so future engineers know why, not just what), and it forces you to ask whether there is a simpler option that is equally correct but easier to reverse. Often there is.

FORGEApplying the reversibility heuristic to Forge's specific MVP decisions

Forge's MVP is an edge vision sensor (NVIDIA Jetson Orin) running a fine-tuned EfficientDet backbone, sending structured defect events to a cloud dashboard accessible by the plant's quality team. Three pilot sites, 30-day activation target. Here is how the reversibility heuristic applies to each major decision:

A

Defect event schema — hard to reverse, must design first

The event schema ({timestamp, device_id, line_id, defect_type, confidence, image_ref, severity}) is the backbone of everything downstream: the dashboard query patterns, the alert logic, the export format for customers, and eventually the billing model (by event volume). Changing this schema once pilots have produced 50K events requires a data migration, a code change in four places, and coordination with pilot customers. Forge should spend 3–4 hours on this before writing a single line of database code.

B

Auth model — hard to reverse, single-tenant is the right MVP choice

Forge has three pilot customers. Multi-tenancy adds weeks of complexity and is not needed until there are more than one customer's data in a shared database. The right MVP choice is single-tenant (one database per customer, or a flat tenant_id column with no isolation enforcement). Document this explicitly: "Single-tenant model, no row-level security — must add multi-tenant isolation before onboarding 5th customer or before any customer requests it for compliance." This is a hard-to-reverse decision where the right answer (start simple) is clear, but the documentation of the switch trigger prevents the "permanent MVP" trap.

C

Inference backend — medium reversibility, use what you know

ONNX Runtime on the Jetson Orin is the fastest path to a working inference pipeline. TFLite has better mobile optimization but Forge is not deploying to mobile. The Jetson ecosystem has strong ONNX support. This decision is medium-reversibility: changing backends later is a contained, isolated refactor that does not touch the API contract or the data model. Use ONNX. Document: "ONNX Runtime inference — revisit if latency benchmarks exceed 100ms per frame on the production line after pilot 1 activation."

D

Dashboard UI framework — easy to reverse, choose fastest

React is what both Forge engineers know. There is no architectural argument against React for a dashboard showing charts and tables. This decision is easy to reverse — a UI rewrite is painful but contained and does not affect the data model, API, or edge device. Use React. Do not spend an hour evaluating Vue or SvelteKit. This is not a decision the reversibility heuristic asks you to agonize over.

🧪 Forge's documented shortcut register — the real discipline

Every shortcut in the MVP build should appear in a file called SHORTCUTS.md at the root of the repo. Forge's first version at pilot launch:

ShortcutWhat was skippedTrigger to fix
Hardcoded alert thresholds per defect typePer-customer configuration systemBefore pilot 2 onboarding
Synchronous event ingestion, no queueAsync queue (Redis/SQS)If event volume exceeds 1K/hour per device
No input validation on dashboard APIFull schema validation + error responsesBefore any external API consumer
Single-tenant, no row-level securityMulti-tenant isolationBefore 5th customer OR compliance request
Model weights hardcoded to one defect taxonomyConfigurable defect type registryBefore pilot customer with different product type

Notice that each shortcut has a specific, observable trigger condition — not "when we scale" but "before X happens." That specificity is what converts debt from a vague threat into a manageable backlog.

WEAKNESSThe permanent MVP — the failure mode that ends companies slowly

The reversibility heuristic protects you from agonizing over easy decisions. But there is a second failure mode that it does not fully address: the MVP that never gets rebuilt.

The permanent MVP happens in a specific sequence. You build an MVP fast and with good discipline — the shortcuts are documented, the hard decisions were made with care. The MVP works. Customers start using it. Revenue starts coming in. Engineering time gets consumed by customer requests, integrations, and bug fixes. The undocumented shortcuts become "legacy code" before anyone addresses them. The documented shortcuts stay in SHORTCUTS.md but the trigger conditions never quite materialize urgently enough to displace feature work. The codebase calcifies. New engineers take longer to onboard because the architecture is hard to understand. Velocity drops. Hiring becomes harder because the codebase is not something good engineers want to work in. The company eventually faces a forced rewrite — but now it is funded by customers who expect uptime, not the runway-cheap environment of the early MVP.

✗ The "it's working so why touch it" trap

The most dangerous signal is when the MVP "works" in production with real customers. This creates a strong disincentive to touch the codebase: it might break something, customers are happy, and there is always more feature work. The technical debt does not announce itself. It accumulates silently. By the time it becomes acute — a new engineer takes 3 weeks to understand a 2,000-line file, a security audit finds the absent input validation, a customer requests multi-tenancy — the cost of the rebuild is an order of magnitude larger than it would have been at month 3.

The solution is not to avoid technical debt entirely — that path leads to the polished-codebase-that-ran-out-of-runway failure mode described above. The solution is to treat debt retirement as a scheduled activity, not a reactive one. When the pilot converts to a paying annual contract, that is a trigger: schedule a 2-week architecture review before onboarding the next customer. When you hire a third engineer, that is a trigger: run a codebase audit before they start writing code. The shortcuts register only works if there is a process for reviewing it that is tied to observable milestones, not abstract good intentions.

Time (months post-MVP launch) Tech debt Rebuild required Pilot 1 → debt review Hire 3rd eng → audit Managed (milestone-triggered reviews) Unmanaged (reactive only)
Technical debt is not inherently fatal — but only if you retire it on a schedule tied to observable milestones, not abstract good intentions. Unmanaged debt crosses the rebuild threshold, typically right when you can least afford it.

WEAKNESSWhere this bites

✗ Treating the reversibility heuristic as permission to be careless

The reversibility framework tells you which decisions deserve extra scrutiny. It does not tell you to be careless about the easy ones. "Easy to reverse" means the refactor is bounded and contained — it does not mean you write deliberately bad code that will need full replacement. The discipline is: easy-to-reverse decisions get less ceremony, not zero standards. Readable, documented, explicit code is always correct even when the decision is trivially reversible. The heuristic controls the level of upfront design, not the code quality floor.

✗ Writing SHORTCUTS.md and never reading it again

The shortcuts register is only valuable if it is a living document tied to a review process. Writing it and filing it is the startup equivalent of writing a risk register and putting it in a drawer. Every SHORTCUTS.md entry needs a trigger condition that is specific and observable, and the review process needs to be tied to an actual calendar event or milestone gate — not to someone remembering to check. If the register has entries that are more than 3 months old without a conscious "not yet" decision, the register is theater.

✗ Confusing "going fast" with "not thinking"

The fastest MVP is not the one where you start writing code immediately. It is the one where you spend 30–60 minutes mapping the hard-to-reverse decisions before you write a line. The data model design, the API contract, the auth model — these are the places where 1 hour of up-front thinking saves 2 weeks of later refactoring. Velocity at the MVP stage is about minimizing rework, not maximizing keystrokes per hour. The reversibility matrix exercise is not overhead — it is the fastest path to a codebase that can still be changed when the learning from the first pilot forces you to change it.

KEY INSIGHTHow this connects

  • 2.3 · Scoping the MVP — Ruthless Subtraction — Lesson 2.3 defines what to build. This lesson defines how to build it. The two must be read together: the scope defines what decisions you need to make; the reversibility heuristic defines how much time to spend on each of them.
  • 2.4 · Prototype Strategies — Before You Write Production Code — Lesson 2.4 argues for validating assumptions before writing production code. This lesson takes over once that validation is done: now you know what to build with higher confidence, so you build it fast — but the reversibility heuristic applies just as much here as it would have before the prototype phase.
  • 2.6 · Testing the MVP — What Good Feedback Looks Like — Once the MVP is built using the discipline from this lesson, you need a feedback framework to distinguish signal from noise. Lesson 2.6 covers how to collect and interpret that feedback without falling back into the confirmation bias patterns from Stage 1.

The permanent MVP failure mode described in this lesson is one of the most common causes of Series A companies failing to reach Series B. The MVP worked, customers paid, the codebase never got rebuilt, velocity collapsed, the team spent all their time on maintenance, and the product stagnated at exactly the moment competitive intensity required acceleration. The technical discipline in this lesson is a prerequisite for the operational discipline in Stage 4 (building a repeatable sales motion) and Stage 5 (measuring growth and retention). You cannot instrument and iterate on a calcified codebase.

GLOSSARYKey terms introduced

Reversibility heuristic
A framework for allocating architectural attention in an MVP build: decisions that are hard to reverse (high blast radius, high migration cost) deserve up-front design rigor; decisions that are easy to reverse do not. The heuristic converts a vague "build fast vs. build well" tradeoff into a specific, decision-by-decision protocol.
Blast radius
The number of files, systems, or external parties that would need to change if a given architectural decision were reversed. High blast radius decisions — data models, API contracts, auth models — are hard to reverse because the refactor is not contained to a single file or module.
Migration cost
The cost, in time and risk, of moving from one architectural choice to another once live data and real users depend on it. A UI framework swap is cheap. A database schema migration with 500K rows of production data is expensive and risky. Migration cost is the second dimension of the reversibility matrix.
Shortcuts register (SHORTCUTS.md)
A living document that lists every deliberate technical shortcut in the MVP codebase, paired with the reason it was taken and a specific, observable trigger condition for retiring it. Converts technical debt from a surprise into a managed, reviewable backlog.
Premature optimization
Building for a requirement or scale that does not yet exist. In MVP context this includes: writing generic solutions to specific problems, building configurability before you understand the configuration space, and designing for scale before you have the load. Each form costs time and flexibility without producing learning.
Permanent MVP
The failure mode in which a prototype-quality codebase enters production, customers build dependence on it, debt retirement gets perpetually displaced by feature work, and the architecture calcifies before a deliberate rebuild can occur. Typically becomes acute at Series A scale, when velocity requirements collide with the inherited architecture.
Milestone-triggered debt review
A scheduled review of the shortcuts register tied to a specific, observable milestone (pilot converts to annual contract, third engineer hired, fifth customer onboarded) rather than a calendar interval or abstract good intention. The specificity is what makes it actionable rather than aspirational.
Abstraction layer
A component of a software system that hides the complexity of an underlying implementation. Abstraction layers are appropriate when the complexity they hide is real and present, not anticipated. In MVP codebases, premature abstraction reduces readability and flexibility without managing complexity that has yet to materialize.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1A technical founder argues that skipping input validation on the dashboard API is not a real shortcut because "we only have three customers who all trust us." Why is this reasoning incomplete, and what is the correct way to handle this decision?›

The argument conflates security risk with relationship trust, and ignores the blast-radius problem. Input validation is not primarily about customer intent — it is about protecting the system from accidental malformed inputs, integration errors, and future states (new customers, third-party integrations) that the current "three trusted customers" framing doesn't anticipate. More specifically: the reversibility heuristic does not classify input validation as a hard-to-reverse architectural decision (it is contained, the refactor is low blast-radius), but that is not the same as saying it should never exist. The correct handling is: (1) document it in SHORTCUTS.md as a deliberate skip, (2) assign a specific trigger ("add before any external API consumer or before onboarding customer 5"), and (3) be honest that this is a security shortcut, not a design choice. The reasoning is incomplete because it treats a risk management question as a trust question.

2Why is the data model considered a "hard to reverse" decision even in a very small MVP with minimal data?›

Because the data model's difficulty of reversal is not determined by the current data volume — it is determined by how much other code will be written on top of it before you change it. Even at 0 rows, if you build 3 months of query logic, a dashboard, an alert system, and an export function all pointing at a specific schema, the migration cost when you want to change that schema is the combined cost of updating all those systems plus migrating any data that does exist. In practice, changing a data model with 500K rows is painful; changing it with 50 rows but 5,000 lines of application code written against it is also painful. The blast radius — the amount of code that references the schema — accumulates quickly regardless of data volume. This is why 3–4 hours of up-front schema design at the MVP stage is high-ROI time: it sets the blast radius before it expands.

3Describe the "permanent MVP" failure mode and explain why it tends to become acute at a specific stage of company growth rather than immediately.›

The permanent MVP is a prototype-quality codebase that enters production, attracts customers, and then never gets rebuilt because the debt retirement keeps getting displaced by feature work and customer requests. It becomes acute at a specific stage — typically around Series A or when the team grows past 5–6 engineers — for three compounding reasons: (1) Velocity collapse: new engineers take much longer to onboard to an undocumented, shortcut-heavy codebase, so productivity per engineer drops as headcount rises. (2) Architecture rigidity: the hard-to-reverse decisions made carelessly during the MVP (often without the reversibility discipline) have now calcified under 18 months of feature code. Changing them requires coordinating a rewrite across a large codebase rather than a small one. (3) Customer lock-in: customers have now built workflows around the existing behavior, including behaviors that were unintentional shortcuts. It is not acute immediately because at MVP scale, the shortcuts work, the team is small enough to hold context implicitly, and the "ship feature or retire debt" tradeoff always favors features when customers are waiting. The debt only becomes visible when the team's ability to move fast is visibly degraded — which is exactly when competitive pressure demands acceleration.

4A founder says: "I wrote all my shortcuts in SHORTCUTS.md, so the technical debt is managed." What is missing from this claim, and what would make it true?›

Documentation without a review process is a filing system, not a management system. Three things are missing: (1) Specific trigger conditions — each shortcut needs an observable trigger ("before onboarding customer 5" or "if event volume exceeds 1K/hour") rather than a vague one ("when we scale" or "eventually"). Vague triggers are never actionable. (2) A review process tied to milestones — the register needs to be reviewed at defined checkpoints (pilot to annual contract conversion, 3rd engineer hire, next fundraise), not just written and filed. Without a review trigger, entries stay in the register indefinitely. (3) Conscious "not yet" decisions — every quarter, a founder should look at each open shortcut and make an explicit decision: "trigger condition not yet met" (write it down) or "this trigger has been met; we need to schedule the fix." The difference between debt managed and debt accumulated is not documentation — it is decision-making frequency. The claim becomes true when there is a regular cadence where each shortcut's trigger condition is evaluated and acted on.

Next: how to collect and interpret real feedback once your MVP is in the field →