Assumption Audit

Surface the things a plan quietly takes for granted, write them down where everyone can see them, and rank them by blast radius — then go test the dangerous ones before reality does.

When to use

• Before committing significant time, money, or reputation to a plan.
• An estimate or forecast feels confident but you can't say why.
• A plan depends on things outside your control (a partner, a market, a tool, a user behavior).
• A post-mortem found a failure that "no one saw coming" — it was an unexamined assumption.
• The user wants a prioritized de-risking list, not a vague "it might not work."

When NOT to use

• Pure execution of an already-validated plan where assumptions were checked recently.
• When the assumptions are cheap to be wrong about and trivially reversible.
• Analysis-paralysis situations where the user needs to act, not enumerate more risks.

The method

1. Restate the plan/belief/estimate plainly. Get the claim in one or two sentences so the assumptions have something to hang off.
2. Hunt assumptions in every category. Go category by category so you don't miss whole classes:
   • Factual — "X is true" (data, market size, a number you didn't measure).
   • Behavioral — "people/users/the team will do Y."
   • Causal — "if we do A, B will follow."
   • Resource — "we'll have the time/money/skill/access."
   • Stability — "the world won't change underneath us" (prices, rules, dependencies).
   • Definitional — "we all mean the same thing by this word/goal."
3. Make the implicit explicit. Rewrite each as a flat declarative sentence: "We are assuming that ___." If you can't say it cleanly, you don't understand it yet.
4. Find the load-bearing ones. Mark which assumptions the whole plan depends on — remove the assumption and the plan collapses. These are structural; the rest are cosmetic.
5. Score each on two axes: Impact if wrong (cosmetic → fatal) and Confidence it's true (proven → pure guess). The danger zone is high impact + low confidence.
6. Rank by risk and sort the action. Order by impact-if-wrong × uncertainty. For the top ones, define the cheapest possible test that would prove or kill the assumption (an experiment, a phone call, a small spend, a lookup).
7. Decide per assumption: test it now, build a fallback for it, or knowingly accept the risk. The goal is that no fatal assumption is left both untested and unacknowledged.

What good looks like

• A clean list of explicit "We are assuming that ___" statements.
• The 2-3 load-bearing, low-confidence assumptions clearly flagged as the real risk.
• Each top assumption paired with a cheap, concrete test — not "we should validate this" but "call three customers and ask X."
• Confidence levels stated honestly, including admitting "this is a guess."
• The user knows exactly what to verify first thing tomorrow.

Anti-patterns

• Listing only the comfortable assumptions you already know are true — the dangerous ones are the ones you don't want to look at.
• Flat lists with no ranking — 20 unranked assumptions is noise.
• Stopping at naming without proposing a test or fallback.
• Fake confidence: scoring a wild guess as "high confidence" because admitting uncertainty is uncomfortable.
• Auditing trivia while skipping the one belief the whole plan rests on.

Example

Plan: "We'll hit Q4 revenue by converting 5% of free users to paid after launching the new tier." Audit surfaces: (Behavioral) we assume free users want a paid tier at all — confidence: low, impact: fatal → load-bearing. (Factual) we assume the 5% conversion rate — based on a blog post, not our data — confidence: low, impact: high. (Resource) we assume the tier ships by October — confidence: medium. (Stability) we assume no competitor launches a free equivalent — confidence: low, impact: high. Ranked, the danger zone is "free users want to pay" + "5% rate." Cheapest tests: put a fake "Upgrade" button in the app and measure click-through this week (tests willingness for ~$0), and pull conversion benchmarks from a comparable product instead of trusting the blog. Everything else can wait or get a fallback.