Startup Opportunity Map

Phase 15 · Document 00 · Startup Playbook Up: Phase 15 Index · Next: 01 — Product Discovery

Table of Contents

1. Why This Matters
2. Core Concept
3. Mental Model
4. Hitchhiker's Guide
5. Warmup Readings
6. Deep Readings and External References
7. Key Terms
8. Important Facts
9. Observations from Real Systems
10. Common Misconceptions
11. Engineering Decision Framework
12. Hands-On Lab
13. Verification Questions
14. Takeaways
15. Artifact Checklist

1. Why This Matters

This phase turns the entire curriculum — model selection (Phase 5), serving (Phase 7), gateways (Phase 8), RAG (Phase 9), agents (Phase 10), eval (Phase 12), fine-tuning (Phase 13), security/governance (Phase 14) — into building a real product on top of LLM infrastructure. And the first, highest-leverage decision is where to play: most failed AI startups didn't fail at engineering — they built something technically impressive in a market with no defensible position, where the foundation-model vendor or an incumbent would inevitably absorb the feature. The opportunity map is the founder's strategic frame: which layer of the stack you build in, which category of product, and — for each — who the customer is, what the moat is, and how hard it is to win. Get this wrong and no amount of good engineering saves you; get it right and the rest of this phase (discovery → MVP → unit economics → moat → sales → enterprise → fundraising) executes on a sound foundation.

2. Core Concept

Plain-English primer: pick a layer and a category before you write code

The LLM market is one of the largest greenfield opportunities in software history, but it is not uniformly winnable. Think of it as a stack of layers, each with very different startup economics:

LAYER 1 — INFRASTRUCTURE (GPU clouds, training/serving infra): capital-intensive, winners entrenched (NVIDIA, AWS, CoreWeave, Together…). ✗ rarely a startup play
LAYER 2 — FOUNDATION MODELS (OpenAI, Anthropic, Google, Meta, Mistral…): $100M+ capital. ✗ not a startup play without unique data/domain
LAYER 3 — DEVELOPER TOOLING (gateways, eval, observability, RAG/agent frameworks, fine-tuning): tractable; OSS→SaaS proven. ~ competitive but winnable
LAYER 4 — VERTICAL/APPLICATION (domain-specific copilots, agents, automation): ★ best risk/reward for most startups — domain depth + LLM = defensible

The cardinal strategic truth: the foundation-model layer commoditizes everything directly above it. A thin "wrapper" around an API has no defense — the model vendor improves, adds your feature, or a hundred competitors clone you in a weekend. Defensibility comes from what the model doesn't have: your domain data, your workflow integration, your customer relationships, your system of record (06). So most founders should build in Layer 4 (own a narrow vertical workflow deeply) or a defensible niche of Layer 3.

The startup categories

The spec's twelve categories, grouped by layer:

• Layer 3 (tooling/infra): LLM gateways · internal AI platforms · evaluation/observability tooling · security/governance tooling · local/private AI tools.
• Layer 4 (applications): RAG products · AI coding tools · vertical AI agents · document automation · voice/audio agents · workflow automation · industry-specific copilots.

The per-category analysis (the heart of the map)

For every candidate, score the same ten dimensions — this is the discipline that separates a real opportunity from a demo:

1. Customer — who pays (and is it the same as who uses it?).
2. Pain — how acute (vitamin vs painkiller)? Is it expensive knowledge work?
3. Existing alternatives — status quo (manual, incumbents, the foundation model itself).
4. Technical moat — what's hard to replicate technically (rarely the model; often the system, evals, integrations) (06).
5. Data moat — proprietary data / a compounding feedback loop the vendor can't get (06).
6. Distribution channel — how you reach customers (PLG, OSS-led, sales-led, partner-led).
7. MVP scope — the smallest thing that delivers value (04).
8. Pricing model — seat / usage / value-based / outcome (05).
9. Risks — incumbency, commoditization, regulation, model-dependence.
10. Startup difficulty — capital, GTM, technical, and regulatory difficulty combined.

A worked example (compressed)

(Each row deserves the full ten-dimension treatment in your own map — this is the lab.)

The "can OpenAI just build this?" filter

Every AI startup faces this question — investors will ask it (09), and it's the right filter. The answer that survives: you own something the foundation-model vendor structurally cannot — proprietary domain data, deep workflow/system-of-record integration, regulatory/trust positioning, or distribution they don't have (06). If your only answer is "we prompt better," you don't have a company. Build where the model is an input, not the product.

Business models and GTM (set early, detailed later)

• Pricing models: per-seat SaaS · usage/API · value-based · outcome/revenue-share — chosen to fit the category and to price to margin, not to compete (05).
• GTM motions: OSS→enterprise (dev tools), PLG (individual-first tools), sales-led (compliance-sensitive verticals), partner-led (augmenting incumbents) (07). The motion must match the category and customer.

Where this phase goes next

The map tells you where; the rest of the phase executes: discover the real pain (01), select the market/ICP (02), design an AI-native product (not a wrapper) (03), scope the MVP (04), model the unit economics (05), build the moat (06), sell it (07), make it enterprise-ready (08), and fund it (09).

3. Mental Model

   THE STACK (very different startup economics per layer):
     L1 INFRASTRUCTURE (GPU/serving) — capital-heavy, entrenched ✗   L2 FOUNDATION MODELS — $100M+ ✗
     L3 DEV TOOLING (gateway/eval/observability/RAG/FT) — OSS→SaaS, winnable ~   L4 VERTICAL APPS (domain copilots/agents/automation) — ★ best risk/reward
   ★ CARDINAL TRUTH: the foundation-model layer COMMODITIZES whatever sits thinly above it. A wrapper has no defense.
     → build where the MODEL IS AN INPUT, not the product. Defense = what the model DOESN'T have (data/workflow/relationships/system-of-record [06]).

   CATEGORIES: L3 = gateways · internal AI platforms · eval/observability · security/governance · local/private
               L4 = RAG products · AI coding · vertical agents · doc automation · voice/audio · workflow automation · industry copilots

   PER-CATEGORY (score all 10): customer · PAIN(painkiller?) · alternatives · TECHNICAL moat · DATA moat · distribution · MVP scope · PRICING · risks · DIFFICULTY

   "CAN OPENAI BUILD THIS?" FILTER: survive it with proprietary data / workflow+system-of-record / trust+regulation / distribution. "we prompt better" = no company.
   PRICING: seat · usage · value · outcome — price to MARGIN not to compete [05].  GTM: OSS→ent · PLG · sales-led · partner-led [07] — match category+customer.
   NEXT: discover[01]→market[02]→AI-native design[03]→MVP[04]→unit econ[05]→moat[06]→sales[07]→enterprise[08]→fund[09]

Mnemonic: pick your layer (Layer 4 vertical apps or a defensible Layer 3 niche — never a thin wrapper), score every candidate on the same ten dimensions, and only build where you own something the foundation model structurally can't. The model is an input; your domain, data, and integration are the product.

4. Hitchhiker's Guide

What to look for first: which layer (default to Layer 4 vertical or a defensible Layer 3 niche) and does the candidate survive "can OpenAI build this?" — i.e., is there a real data/workflow/trust/distribution moat? Those two decide whether there's a company at all.

What to ignore at first: Layers 1–2 (infra/foundation models) unless you have $100M+ or unique data, and thin wrappers of any kind. Also ignore TAM fantasies — depth in a narrow beachhead beats a huge undefendable market (02).

What misleads beginners:

• Competing on model quality. Foundation models improve monthly — you'll lose. Win on integration, workflow, data, trust (06).
• "Wrap an API" products. No moat; commoditized instantly — build where the model is an input.
• Picking by personal excitement, not pain. Score the ten dimensions honestly; a vitamin won't sell (01).
• Ignoring distribution. A great product with no GTM motion dies — the motion must match the category (07).
• Underestimating regulated verticals. They're hard but defensible (trust/compliance is a moat, Phase 14).

How experts reason: they default to Layer 4 (or a defensible Layer 3 niche), score every candidate on the ten dimensions, apply the "can OpenAI build this?" filter ruthlessly, favor acute pain in expensive knowledge work with a proprietary-data or workflow moat, match a GTM motion to the customer, and price to margin (05). They treat the foundation model as a commoditizing input and build their defense elsewhere.

What matters in production: that the chosen category has a real, acute customer pain; a moat the model vendor can't replicate; a viable distribution motion; and unit economics that work at the planned price.

How to debug/verify: for your candidate, answer all ten dimensions in one page — if "moat" is weak or "can OpenAI build this?" has no good answer, re-pick. Pressure-test pain with real users (01).

Questions to ask: which layer? is it a wrapper (if so, stop)? who's the customer and how acute is the pain? what's the data/workflow/trust/distribution moat? does it survive "can OpenAI build this?"? what GTM motion and pricing fit? how hard (capital/GTM/tech/regulatory)?

What silently kills the company: thin-wrapper commoditization, competing on model quality, a vitamin (not a painkiller) market, no distribution motion, and no answer to "can OpenAI build this?"

5. Warmup Readings

6. Deep Readings and External References

7. Key Terms

8. Important Facts

• The market is a stack of layers with very different economics — Infra/Foundation (L1/L2) are rarely startup plays; Dev Tooling (L3) is winnable; Vertical Apps (L4) are the best risk/reward.
• The foundation-model layer commoditizes whatever sits thinly above it — a wrapper has no defense; build where the model is an input.
• Defensibility comes from what the model doesn't have — proprietary data, workflow/system-of-record integration, trust/regulation, distribution (06).
• Score every candidate on ten dimensions — customer, pain, alternatives, technical moat, data moat, distribution, MVP scope, pricing, risks, difficulty.
• The "can OpenAI build this?" filter is the right test — survive it or re-pick; "we prompt better" is not a company (09).
• Don't compete on model quality — it improves monthly; win on integration/workflow/data/trust.
• Price to margin, not to compete (05); match the GTM motion to the category/customer (07).
• Acute pain in expensive knowledge work (legal/health/finance/support/dev) is the highest-leverage target — often regulated (hard but defensible, Phase 14).

9. Observations from Real Systems

• The biggest LLM-startup outcomes are vertical/application-layer (Cursor in coding, Harvey in legal, Abridge in healthcare, Sierra in support) — domain depth + workflow + trust, not model-building.
• OSS→SaaS is the proven Layer-3 path (LiteLLM, Langfuse, Chroma, Qdrant) — community distribution then enterprise monetization (07).
• Thin wrappers got commoditized — countless "ChatGPT for X" demos died when the model vendor shipped the feature or the market filled with clones; the survivors owned data/workflow (06).
• Regulated verticals are slow but sticky — legal/health/finance buyers gate on compliance (SOC 2, DPA, residency, Phase 14), which becomes a moat once cleared.
• Investors lead with the defensibility question — "what stops OpenAI/an incumbent?" decides AI fundraising as much as traction (09).

10. Common Misconceptions

11. Engineering Decision Framework

WHERE TO PLAY (the opportunity map):
 1. LAYER: default to L4 (vertical app) or a defensible L3 niche (tooling). Avoid L1/L2 (capital) and thin wrappers (no moat).
 2. CANDIDATE LIST: pick categories (L3: gateway/eval/observability/security/local · L4: RAG/coding/vertical-agent/doc-automation/voice/workflow/copilot).
 3. SCORE each on 10 DIMENSIONS: customer · pain(painkiller?) · alternatives · technical moat · DATA moat · distribution · MVP scope · pricing · risks · difficulty.
 4. FILTER: "can OpenAI/an incumbent build this?" — must have a data/workflow/trust/distribution answer [06]. If not → re-pick.
 5. FIT: choose a GTM motion (OSS→ent/PLG/sales/partner) and pricing (seat/usage/value/outcome) that match the category+customer [07/05].
 6. PROCEED: discovery [01] → market [02] → AI-native design [03] → MVP [04] → unit econ [05] → moat [06] → sales [07] → enterprise [08] → fund [09].

12. Hands-On Lab

Goal

Build a one-page opportunity map: shortlist 3 candidate categories, score each on the ten dimensions, apply the "can OpenAI build this?" filter, and pick one to carry through the rest of Phase 15.

Prerequisites

• Your domain interests/skills, and the category list from §2.

Steps

1. Shortlist: pick 3 candidate categories (mix L3 and L4) you could plausibly build.
2. Score the ten dimensions for each: customer, pain (painkiller vs vitamin), alternatives, technical moat, data moat, distribution, MVP scope, pricing, risks, difficulty.
3. Apply the filter: for each, write the one-sentence answer to "what stops OpenAI/an incumbent?" — if there isn't one, mark it dead.
4. Pick the motion + pricing: assign a GTM motion and a pricing model to each survivor (07/05).
5. Choose one: select the best risk/reward candidate to carry into 01–09; justify in 3 sentences.
6. Sanity check: is it a wrapper? competing on model quality? a vitamin? If yes to any, reconsider.

Expected output

A one-page opportunity map (3 candidates × 10 dimensions), a defensibility answer per candidate, and one chosen category with a justified GTM + pricing — the strategic foundation for the rest of the phase.

Debugging tips

• If every candidate's moat is "better prompts," widen your search to data/workflow/trust plays.
• If pain is "nice to have," it won't sell — find acute, expensive pain.

Extension task

Map where each candidate sits relative to the foundation-model roadmap — what could the vendor ship next that kills it? (Phase 4)

Production extension

Carry the chosen category into a full product-discovery sprint (01) and market selection (02).

What to measure

Pain acuteness, moat strength, defensibility-filter pass/fail, distribution viability, difficulty — and the gap between your favorite idea and the best-scored one.

Deliverables

• A one-page opportunity map (3 candidates × 10 dimensions).
• A defensibility answer ("can OpenAI build this?") per candidate.
• One chosen category with GTM + pricing + a 3-sentence justification.

13. Verification Questions

Basic

1. What are the four layers of the LLM stack and their startup economics?
2. Why does the foundation-model layer commoditize thin wrappers?
3. What are the ten dimensions for scoring a category?

Applied 4. Why is Layer 4 (vertical apps) the best risk/reward for most founders? 5. What kinds of answers survive the "can OpenAI build this?" filter?

Debugging 6. Your idea's only moat is "we prompt better." What do you do? 7. A category has huge TAM but no defensibility. Build it or not?

System design 8. Map a vertical-agent opportunity (e.g., legal or healthcare) across all ten dimensions.

Startup / product 9. How do you choose a GTM motion and pricing model for a chosen category?

14. Takeaways

1. Pick your layer first — default to Layer 4 vertical apps or a defensible Layer 3 niche; avoid infra/foundation (capital) and thin wrappers (no moat).
2. The foundation-model layer commoditizes what sits thinly above it — build where the model is an input, not the product.
3. Score every candidate on ten dimensions and apply the "can OpenAI build this?" filter — defensibility comes from data/workflow/trust/distribution (06).
4. Don't compete on model quality; price to margin; match the GTM motion to the customer (05/07).
5. The map tells you where; the rest of the phase executes — discovery → MVP → unit economics → moat → sales → enterprise → fundraising.

15. Artifact Checklist

• A one-page opportunity map (3 candidates × 10 dimensions).
• A layer choice (L3 niche or L4 vertical) with rationale.
• A defensibility answer ("can OpenAI build this?") per candidate.
• A GTM motion + pricing model per survivor.
• One chosen category carried into 01–09.

Up: Phase 15 Index · Next: 01 — Product Discovery