ProjekinAja. Founder's Playbook Stage 1 · Signal or Noise Lesson 1.2
● Stage 1 · Lesson 1.2

The Assumption Stack

Every startup is a bundle of unproven beliefs stacked on top of each other — mapping them explicitly is the first act of intellectual honesty.

⏱ ~20 min read 🗂 Framework ⚙ Interactive tool

🎯 By the end you'll understand

The full taxonomy of startup assumptions — customer, problem, solution, channel, and revenue — and why each layer has a distinct failure mode. You'll understand the stack metaphor: a bottom assumption that fails brings down everything above it. You'll learn to rank assumptions by consequence-if-wrong and evidence quality, producing a risk-priority matrix that tells you exactly what to test first. And you'll understand the most common form of premature building: founders who test solution assumptions while leaving customer and problem assumptions unexamined.

KEY INSIGHTYou are not building a product — you are testing a tower of beliefs

A startup that has not mapped its assumptions has not chosen what to test — it has chosen to be surprised. Every sprint of unexamined building is a bet that every layer of the stack is solid. Most are not.

You have an idea. The idea is actually not one belief — it is at least a dozen, stacked on top of each other. Someone has this problem. It is painful enough to pay to solve. Your particular mechanism addresses it. The customer can find you through a channel you can afford. They will pay a price that makes the unit economics work. Each of those beliefs is an assumption, not a fact. The stack metaphor captures what happens when you skip the mapping step: if the bottom assumption collapses, everything built on top of it collapses too.

🔑 The core discipline

Before you design a feature, write a pricing page, or plan a sales motion, enumerate every assumption your startup depends on. Categorize each by type. Rate each by how consequential it would be if wrong. Rate each by how much actual evidence you have. Then sort. The output is not a plan — it is a risk-priority queue: the ordered list of what the evidence demands you go test next, regardless of what you feel most excited about building.

CORE CONCEPTThe five layers of the assumption stack

Every startup assumption belongs to one of five categories. The categories are not arbitrary — they map to distinct failure modes and require different validation methods. Getting the category right changes how you test.

1

Customer assumptions — who is the buyer, and are they real?

These are assumptions about the identity of the person with the problem: their role, their industry, their situation, their decision-making authority, and how they buy. Examples: "Tier-1 automotive ops managers are the decision-maker for inspection tooling." "Mid-market manufacturers (200–2,000 employees) are the reachable segment." These are the deepest layer of the stack. If you are wrong about who the customer is, every other assumption was tested against the wrong person. Customer assumptions are the ones founders most often skip — because the founder already believes they know who the customer is, because the customer is sometimes themselves.

2

Problem assumptions — is the pain real, severe, and underserved?

These are assumptions about the nature and intensity of the pain your identified customer actually experiences. Not: "manufacturers have quality problems" (that is vague enough to be unfalsifiable). But: "Tier-1 automotive ops managers experience unplanned downtime events that cost $180K–$400K each and occur at a frequency they currently cannot predict." Problem assumptions require specificity to be testable. The common failure mode: founders test problem assumptions in the form of "do you agree this is a problem?" — which nearly always produces agreement — instead of "describe the last time this happened and what it cost you."

3

Solution assumptions — will your mechanism actually solve it?

These are assumptions that your specific approach — the product, the technology, the UX, the workflow — actually solves the customer's problem at a price they will pay. Note the ordering: this is layer 3, not layer 1. Most founders start here. They have an elegant technical solution, and they build the solution, then look for a customer. The stack metaphor reveals why this sequence destroys value: if your customer assumption is wrong (the buyer is not the ops manager, it is the plant engineering director), then even a perfectly working solution fails because it was designed for the wrong person's workflow. Solution assumptions are the ones founders most over-invest in testing — because building is comfortable and discovery is uncomfortable.

4

Channel assumptions — can you reach them, at what cost?

These are assumptions about how you will get the product in front of the customer: which channels exist, what it costs to acquire a customer through each one, and whether those economics are compatible with your price point. An early-stage founder testing a B2B solution targeting plant floor ops managers at large automotive suppliers faces a specific channel challenge: these people are not searchable via Google Ads, do not respond to cold email at scale, and are often gatekept by procurement. Channel assumptions often go untested until the product is built — at which point the CAC is discovered to be 5× the assumed LTV. Channel assumptions should be estimated (not proven) in Stage 1 and validated properly in Stage 4.

5

Revenue assumptions — will the unit economics actually work?

These are assumptions about price, contract size, payment terms, renewal rates, and the resulting unit economics: will LTV exceed CAC by a margin large enough to build a business? Revenue assumptions are the top of the stack — but that does not make them low-risk. A startup can validate customer, problem, solution, and channel assumptions correctly, then discover that the price the market will bear is not compatible with the cost to serve. Revenue assumptions are best tested through pricing conversations and willingness-to-pay signals in discovery, not after the product is built. Asking "what would you pay for something like this?" is weak evidence; asking "here is a pricing page — walk me through how you would evaluate this" is stronger.

1 · CUSTOMER Who is the buyer? Role, segment, decision authority Foundation 2 · PROBLEM Is the pain real, severe, frequent, and underserved? 3 · SOLUTION Does your mechanism solve it in a form they'll adopt? 4 · CHANNEL Can you reach them at a CAC the unit economics can support? 5 · REVENUE Will price × retention × volume exceed cost to acquire + serve? failure cascades up
The assumption stack. The layers are ordered by dependency: every layer above rests on every layer below. A customer assumption that is wrong invalidates not just your customer research — it invalidates the problem, solution, channel, and revenue work built on top of it.

HOW IT WORKSWhy the stack collapses from the bottom

The stack metaphor is not a visual convenience — it captures a real dependency structure. Each upper layer assumes the lower layer is solid. Channel assumptions assume you know who you are trying to reach (customer). Revenue assumptions assume the solution is one the customer will adopt (solution). When a lower assumption fails, the failure is not contained to that layer — it propagates upward and invalidates everything built on top.

Failed assumption What collapses above it Concrete example of the cascade
Customer Problem, Solution, Channel, Revenue — everything You built for the ops manager. The actual buyer is the plant engineering director, who has a completely different problem hierarchy, different budget process, and does not respond to the channels you chose. Product, go-to-market, and pricing all require redesign.
Problem Solution, Channel, Revenue You correctly identified the ops manager as buyer. But the problem you built for — lagging inspection reports — is ranked 14th on their actual priority list. The solution works; no one has budget urgency for it. Revenue expectations collapse.
Solution Channel, Revenue (partially) Problem and customer are correct. But the solution form — an edge hardware device — fails IT security review at every plant. Customers would buy a cloud-only solution instead. You built the wrong mechanism.
Channel Revenue (unit economics) Customer, problem, and solution all validated. But reaching ops managers at Tier-1 automotive suppliers requires a field sales team with $180K+ OTE reps. At a $30K ACV, the math is fatal.
Revenue Business model (not the product) Everything above works. But customers will pay $8K/year, not $30K. LTV/CAC ratio is 1.2×. The startup is not a business — it needs a pricing redesign or a cost structure overhaul.

The table reveals the asymmetry: a customer assumption failure is catastrophic — it invalidates four layers of work. A revenue assumption failure is expensive but often correctable — it may require a pricing redesign without invalidating the product. This asymmetry is the entire reason to test bottom-up, not top-down. Founders who test solution assumptions first (because building is satisfying) are implicitly betting that all four lower layers are solid. The stack makes the bet visible.

💡 The bottom-up testing discipline

Before you design any feature, ask: "Have I validated the customer assumption well enough that I know my problem research was conducted with the right person?" Before you build any solution, ask: "Have I validated the problem assumption well enough that I know the pain is real, severe, and current — not theoretical?" Working bottom-up feels slow. It is the fastest path to a business, because it surfaces invalidating evidence before you have built six months of product on top of it.

SEE ITAssumption Stack Builder — map, rank, and prioritize your startup's bets

⚙ Interactive · Assumption Stack Builder

Below are 12 assumptions relevant to a startup like Forge — or your own. For each, select the consequence if wrong (1 = minor setback, 5 = company-ending) and the current evidence quality (1 = pure speculation, 5 = strong behavioral proof). The widget computes a risk score = consequence × (6 − evidence), auto-sorts the stack into a risk-priority matrix, and highlights the top 3 must-test-first assumptions. It also shows the collapse cascade if the bottom customer assumption is wrong.

Assumption Consequence if wrong Evidence quality Risk score
Adjust the controls above — the matrix updates automatically.

Notice what happens when you lower the evidence score on assumption #1 (the customer identity) while keeping consequence at 5: it rockets to the top of the risk matrix. That is not an accident — it reflects that every other row in the table was researched with the assumption that you know who the buyer is. The widget makes concrete what founders resist admitting: untested customer assumptions are the single highest-risk item in the stack, nearly always.

Also notice the "consequence if wrong" dimension. Some assumptions have a high consequence but moderate evidence (the risk score is still high — a priority). Others have low evidence but also low consequence (worth noting, not an emergency). The risk score is not "how uncertain are you?" — it is "how uncertain times how badly wrong can this go?"

FORGEMapping Forge's assumption stack at the start of Stage 1

Forge enters Stage 1 with a working computer vision model and a theory of the business. Let's apply the five-layer taxonomy to map every assumption the theory depends on — before a single structured interview is conducted.

C

Customer assumptions (untested)

C1: The relevant buyer is the Operations Manager (or VP Operations) at a Tier-1 automotive supplier, with 200–5,000 employees. C2: This person has meaningful budget authority (or can get budget approved) for a $30K–$50K ACV solution without a six-month procurement cycle. C3: Tier-1 automotive is the right segment — not Tier-2, not aerospace, not food manufacturing, not electronics. Evidence on all three: one informal conversation with a Tier-2 (not Tier-1) supplier contact, and lab observation at a research facility (not a production plant). Risk: very high on all three.

P

Problem assumptions (partially supported by secondary research)

P1: Unplanned downtime at Tier-1 automotive plants costs $180K–$400K per event (sourced from industry association reports — directionally real, but the specific figure for this customer segment needs primary confirmation). P2: Current inspection is primarily manual, lagging, and a documented cause of quality escapes — not a minor nuisance but a top-5 operational concern. P3: The problem is frequent enough (more than a few times per year) to justify ongoing investment rather than a one-time fix. P1 has moderate secondary evidence; P2 and P3 are essentially unvalidated.

S

Solution assumptions (strongest evidence — but built on unvalidated layers)

S1: A computer vision edge device (not cloud, not a consulting engagement) is the form factor the customer would adopt. S2: Ops managers will accept deployment of a new hardware device on an active production line. S3: The model's accuracy (97.3% in lab conditions) degrades acceptably in real production environments. S3 has the most technical evidence — but it was generated in a lab, not a production line. S1 and S2 have no primary evidence.

Ch

Channel assumptions (entirely theoretical)

Ch1: Ops managers at Tier-1 automotive plants are reachable via conference-based outreach, LinkedIn, and referral from industry contacts. Ch2: A founder-led direct sales motion will work — no channel partners or VAR intermediaries required at this stage. Ch3: The sales cycle for a $30K ACV tool will be under 90 days. Zero evidence on any of these. Channel assumptions are the most frequently ignored at this stage — and Ch3 (sales cycle) is often the most expensive assumption to be wrong about.

R

Revenue assumptions (theoretical)

R1: Customers will pay $30K–$50K ACV for the software subscription, separate from hardware. R2: Gross margin is achievable above 70% once hardware costs are excluded. R3: Net revenue retention will exceed 100% (expansion within accounts). No primary evidence. R1 especially: the $30K–$50K ACV is not derived from customer willingness-to-pay research — it is derived from cost structure and intuition about what sounds "enterprise" enough.

🔑 The Forge Stage 1 mandate

With this map, the priority order is clear. The Stage 1 discovery program must test C1–C3 first (who is actually the buyer and decision-maker?), P1–P3 second (is the pain as severe and frequent as assumed?), and probe S1–S2 in discovery (would ops managers accept a hardware device on the line?). The milestone for Stage 1 — 20 structured discovery interviews with manufacturing operations managers — is specifically designed to generate evidence against C1, C2, P1, P2, P3, S1, and S2 in that priority order. The interviews are not designed to test the CV model. The model's performance is already known. What is not known is whether the person, the pain, and the solution form are correctly assumed.

WEAKNESSThe premature builder trap — the most common form of assumption skipping

The failure mode the brief describes — founders who test solution assumptions while leaving customer and problem assumptions unexamined — is so pervasive it deserves its own section. It has a specific shape: the founder has a working technical artifact (a prototype, a model, a demo), and uses that artifact as the primary tool of "validation." They show the demo, get reactions, iterate on the demo. The demo gets better. The customer conversations feel productive. The founder reports "strong validation." What actually happened: they received feedback on the solution, not evidence about the problem or the customer.

Premature Builder starts at solution, works upward 3 · Solution (tested: demo iterations) 2 · Problem (assumed, not tested) 1 · Customer (assumed, not tested) product built; customer assumption wrong Disciplined Founder starts at customer, works upward 1 · Customer (validated first) 2 · Problem (validated second) 3 · Solution (now safe to test) ✓ each layer earned before the next
The premature builder inverts the testing order. By the time the customer assumption is discovered to be wrong, six months of product and go-to-market work has been built on a false foundation. The disciplined founder earns each layer before building on top of it.

Why does this pattern persist? Because testing solution assumptions is immediately satisfying — you get real-time reactions, you can iterate visibly, and "user testing" feels like validation even when it is not discovery. Testing customer assumptions is uncomfortable: it requires cold outreach, conversations that do not include any pitch, and the patience to hear that the problem you assumed is not the one they actually care about. The asymmetry of effort produces a systematic bias toward premature building.

There is also a funding incentive that worsens this: demo-driven fundraising rewards founders who have a polished solution artifact, not a rigorously validated problem hypothesis. Investors who fund based on demo quality inadvertently select for premature builders. The discipline required is to explicitly resist that pull — especially early.

WEAKNESSWhere this bites

✗ Treating assumption mapping as a one-time exercise

Founders who map their assumption stack at the beginning of Stage 1 and never update it are using a static tool for a dynamic problem. Every interview, every piece of market intelligence, every failed experiment changes the risk profile of assumptions. The stack is a living document, not a founding ritual. A customer assumption that you had at 80% confidence in month 1 and validated to 90% by month 3 might drop back to 60% when you enter a new segment in month 8. The map needs to reflect the current state of the evidence, not the founding state.

✗ Ranking all assumptions as "high consequence" — the inflation trap

When everything is urgent, nothing is prioritized. Founders who rate every assumption at consequence 5 have avoided the discomfort of deciding what matters most. The risk matrix only works if the consequence scores genuinely vary. Some assumptions — like the exact pricing tier — are high uncertainty but correctable without rebuilding the product. Others — like the identity of the buyer — are catastrophic if wrong. If your consequence scores cluster at 4–5, the scores are reflecting anxiety, not analysis. Force yourself to score at least 3 assumptions as consequence 2 or below.

✗ Conflating "we talked to customers" with "we tested this assumption"

Customer conversations are not assumption tests unless they were designed to test a specific assumption with a specific falsification criterion. A discovery call where you asked open-ended questions and the customer seemed engaged may have generated zero evidence about any specific assumption. For each assumption, you need to know: what question (or behavior) in which type of conversation would move the evidence score from 1 to 3? If you cannot answer that question for a given assumption, you do not yet know how to test it — and "doing more discovery" will not help until you do.

KEY INSIGHTHow this connects

  • The Founder's Epistemology (1.1) — the previous lesson introduced the cognitive traps (confirmation bias, false consensus, planning fallacy) that make assumption mapping necessary. The three traps explain why unmapped assumptions stay untested: you cannot confirm-bias your way into testing a customer assumption you have already decided you know the answer to.
  • ICP — The Behavioral Portrait (1.3) — assumption mapping surfaces the customer assumption as the highest-risk item in the stack. Lesson 1.3 turns that abstract customer assumption into a precise, testable ICP definition: exactly which person, in which situation, with which behavior patterns qualifies as your customer hypothesis.
  • The Discovery Interview (1.4) — the assumption stack is the input to interview design. For each high-risk assumption, you need a specific question type that generates evidence against it. The discovery interview protocol in 1.4 maps question types to assumption categories.
  • The Validation Verdict (1.9) — at the end of Stage 1, the verdict is not "did we learn a lot?" — it is "which assumptions moved, by how much, and does the risk matrix now support a go decision?" The stack you map here becomes the scorecard in 1.9.

The assumption stack is not just a Stage 1 tool. Every major decision in Stage 2 (what to build first), Stage 3 (how to price), Stage 4 (which channels to pursue), and Stage 5 (what retention tells you about product-market fit) is a bet that certain assumptions are solid enough to build on. The stack is the explicit ledger for those bets. Founders who keep it updated make better decisions — not because they have more information, but because they can see clearly where their confidence is earned and where it is still borrowed.

GLOSSARYKey terms introduced

Assumption stack
The full set of beliefs a startup depends on for its theory of the business, organized into five categories (customer, problem, solution, channel, revenue) ordered by dependency. A lower layer failing invalidates all work built on top of it.
Customer assumption
A belief about the identity of the buyer: their role, segment, decision-making authority, and buying process. The foundation layer of the stack — if wrong, all other validated assumptions may be invalid because they were tested with the wrong person.
Problem assumption
A belief about the nature, severity, frequency, and current inadequate treatment of a pain your identified customer experiences. Must be specific and falsifiable to be testable. "Companies have quality problems" is not a problem assumption — it is a category observation.
Solution assumption
A belief that your specific mechanism — product, form factor, workflow, technology — actually addresses the problem in a way the customer will adopt. Layer 3 of the stack, despite being what most technical founders test first.
Risk score
A composite measure of assumption risk, computed as: consequence if wrong × (6 − evidence quality). High consequence and low evidence produce a high risk score — the top priority for testing. Low consequence or strong evidence reduces the score.
Premature building
The pattern of investing in product development before customer and problem assumptions are sufficiently validated. Technically satisfying but epistemologically risky — it bets that the bottom two layers of the stack are solid without testing them.
Bottom-up testing
The discipline of testing assumption layers in the order of their dependency: customer first, then problem, then solution, then channel and revenue. The inverse of how most technical founders naturally want to work, but the approach that surfaces invalidating evidence at the lowest cost.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1A founder validates that ops managers at automotive plants experience expensive unplanned downtime events. They then build a predictive maintenance dashboard and launch it. Six months later, they discover the actual buyer is the plant engineering director, not the ops manager, and the two roles have different software budgets and workflows. Which assumption failed, and why did validating the problem assumption not protect them?›

A customer assumption failed — specifically, the belief that the ops manager is the buyer. Validating the problem assumption (ops managers experience expensive downtime) did not protect them because problem validation only confirms that the identified person has the pain — it does not validate that this person is the economic buyer, the end user, or the decision-maker for solutions. In the stack model, customer and problem assumptions are distinct layers. The founder correctly identified that ops managers have the problem, but incorrectly assumed ops managers would be the buyer. The engineering director — the actual buyer — may also have the problem, but has different selection criteria, different IT requirements, different procurement processes, and different willingness-to-pay thresholds. The product built for an ops manager workflow needs redesign for an engineering director workflow. This is the classic premature-building outcome: a real problem, correctly documented, in the wrong customer layer.

2Why does the risk score formula weight consequence and evidence asymmetrically, rather than just using average uncertainty?›

Because the cost of being wrong is not uniform across assumptions. An assumption that, if wrong, merely requires a pricing page update (low consequence) is fundamentally different from an assumption that, if wrong, invalidates the entire customer segment (high consequence) — even if both have the same level of uncertainty. Pure uncertainty measures treat all unknowns equally; the risk score formula makes explicit that you should invest disproportionate testing effort in high-consequence unknowns. The formula consequence × (6 − evidence) also captures the fact that a high-consequence assumption with strong evidence (consequence = 5, evidence = 5 → score = 5) is less urgent than a moderate-consequence assumption with no evidence (consequence = 3, evidence = 1 → score = 15). The goal is not to eliminate uncertainty — it is to eliminate uncertainty where it would hurt most.

3Forge's solution assumptions (S1–S3) have the most technical evidence of any layer in the stack. Why are they still high-risk items in the matrix?›

Because the technical evidence (the CV model's 97.3% accuracy in lab conditions) was generated under conditions — controlled lighting, known defect types, curated test sets — that may not replicate in production environments. More importantly, the solution assumptions include S1 (customers would adopt an edge device form factor, not a cloud solution or consulting engagement) and S2 (ops managers would allow new hardware on an active production line), both of which have no primary evidence at all. They are not technical questions — they are adoption and organizational questions. S3 (lab accuracy transfers to production) is a technical question, but it requires testing in real production conditions, which has not occurred. The distinction is between "our model works in our lab" (tested) and "our solution, in the form we have built it, will be adopted by the customer in their environment" (untested). The latter is the actual solution assumption — and it remains high-risk regardless of the technical quality of the underlying model.

4A founder maps their assumption stack and finds 14 assumptions, all rated consequence 4–5. What should they do, and why is the current scoring a problem?›

They should force a re-ranking that produces genuine variation. The current scoring is problematic for two reasons. First, it makes the matrix useless as a prioritization tool — if everything is equally urgent, nothing gets scheduled first. Second, it almost certainly reflects anxiety rather than analysis. In any real startup, some assumptions are company-ending if wrong (wrong customer identity), and others are correctable in a sprint (wrong onboarding flow). The reranking process should use a forced comparison: for each pair of assumptions, ask "if only one of these were wrong, which recovery would be harder?" Run this systematically until a genuine rank order emerges. The practical output: identify the 3–4 assumptions that are truly company-ending at this stage, and the 4–5 that are important but correctable. Focus all Stage 1 energy on the former. Note that consequence also changes over time: an assumption that is company-ending at pre-revenue becomes less catastrophic once there is a paying customer base to defend.

Next: translating your customer assumption into a precise, testable behavioral portrait →