Use Case Foundry — User Guide

This guide is for practitioners running AI opportunity discovery: innovation leads, transformation teams, consultants, product leaders, and domain experts who need a repeatable, evidence-backed process — not another brainstorm.

For field-by-field builder instructions, see the [Builder guide](/builder-guide). For methodology and implementation notes, start at [Resources](/resources).

How to use this guide

• If you are new, read in order: What it does → Getting started → Discovery program.
• If you are actively running sessions, jump to Building the evidence map,

Analyze vs Generate, and Troubleshooting.

• Keep the [Builder guide](/builder-guide) open beside this guide for field-level help.

What Use Case Foundry does

Use Case Foundry is an AI Opportunity Discovery Engine. You build a structured model of a company — offerings, processes, data, skills, pains, constraints — and the engine systematically generates and ranks AI use cases that *that company in particular* is positioned to win.

The output is not a long generic list. It is a short, ranked portfolio with:

• Transparent scoring on Impact · Feasibility · Moat · Quality
• Explicit prerequisites (e.g. instrument data before automating)
• A sequenced plan: quick wins plus one strategic bet
• Optional decision-ready dossiers for sponsors

Most AI ideation fails because it is generic. Use Case Foundry shifts discovery from open-ended brainstorming to an evidence-based system where every recommendation traces back to facts you captured — and gaps you still need to close.

What good looks like

By the time you are ready to Generate, you should usually see:

• High-severity gaps mostly closed in Improve the model
• At least one high-impact pain linked to each priority workflow
• Accessible data marked for key high-volume processes
• Clear prerequisites and sequencing (not a flat idea list)

Who this is for

You do not need to understand the engine internals. You do need to treat discovery as a program over days, not a form you finish in one sitting.

Core concepts

Three layers

1. Mapping — Turn what you know about a company into a structured evidence graph

(nodes: offerings, segments, processes, skills, assets, projects, pains, constraints; edges: serves, uses, reuses, bottlenecked_by).

1. Generation — 37 operator patterns fire deterministically on graph facts to produce

candidate use cases (Automate, Augment, Abstraction Transfer, Compliance Copilot, …).

1. Prioritization — Candidates rank on Impact × Feasibility × Moat, with a

quality gate that demotes generic ideas. A Target Selector picks quick wins and one strategic bet, respecting prerequisites.

Hybrid engine

• Deterministic triggers decide *when* a use case should exist and compute base scores.
• LLM reasoning (only on Generate) writes *how* it should be executed for this company.
• Analyze uses no LLM — instant feedback as you build the model.

This separation matters: you can iterate on the evidence map all day without API cost, and you always know which scores came from rules vs model output.

The evidence graph is the product

Facts live in nodes; value lives on edges:

• Offering → serves → Segment — who buys what; unlocks Segment Expansion
• Process → uses → Data asset — grounds Automate/Augment feasibility
• Process → bottlenecked_by → Skill — where expert judgment gates throughput
• Offering → reuses → Project — proven capability you productize
• Pains attached to nodes — the strongest signal on the impact axis

An incomplete graph is expected at first. Dormant operators are a roadmap, not a failing grade.

Ranking axes

Every candidate carries four badges:

Candidates also show dependency lines: do first (prerequisites), unlocks (what they enable), overlaps with (related efforts on the same subgraph).

Tilt ranking with risk appetite (averse / balanced / aggressive) or the feasibility/moat slider — averse favors quick wins; aggressive favors defensible bets.

Getting started

Run the app

```bash pip install -r requirements.txt python -m engine.server --open # marketing site at /, app at /app ```

Hosted deployments serve the same UI. LLM keys are server-side environment variables only. Deployment setup is typically handled by your technical owner.

The three-step journey

The app organizes work into three steps:

You do not need every field before getting value. The evidence preview updates as you type (debounced Analyze, no LLM).

Your first session (30–60 minutes)

1. Open `/app` and dismiss the welcome screen (or load an example from it).
2. In Step 1 · Source, load Meridian Fab or Beacon Pay and skim how sections connect.
3. Move to Step 2 · Evidence — change one offering component or add a pain — watch operators react.
4. Click Analyze in Step 3 · Review — read operator coverage, top candidates, and Improve the model.
5. Do not Generate yet. Note the top 3 high-severity gaps.

That session teaches the loop. Real discovery continues across days and contributors.

The discovery program

Honest company models are multi-person, multi-day work. The product is designed for that.

Recommended cadence

The interview loop

Interviews are first-class — they turn assumptions into grounded facts:

``` auto-map → generate interview agenda → conduct interviews → extract/update evidence graph → analyze → fix gaps → repeat ```

Every Analyze returns an Interview Sprint panel:

• Agenda — ask first: highest-leverage questions from current gaps
• Gap checklist: severity, why it matters, questions to ask
• Status per gap: Open → Captured → Done (tracks multi-day progress)
• Open in builder: jumps to the section that closes the gap
• Conduct interview: opens Map from evidence for that gap

Use Copy agenda as Markdown to take questions into a call, Slack, or email. After applying evidence proposals, the model re-Analyzes automatically.

Consultant interview guide

Consultants often need to extract critical evidence from partial memory and cross-functional context. Use the dedicated [Consultant interview guide](/consultant-interview-guide) for:

• Leading/searching prompts by graph section
• Memory-retrieval question funnels
• Edge-completion checklists
• Session templates and anti-patterns

Continuity and saving

Important: if auth is not enabled and you have not exported YAML, treat the browser as your only copy. When signed in, saved models are private to your account.

Adaptation layers

The company graph is the truth. Adaptation layers change how it is elicited, ranked, and framed — they never overwrite facts you captured.

Set these in Step 1 · Source under Interview focus and Lenses.

Archetype

Shapes section order and empty-state guidance:

Also sets default resource level (capacity to build and run AI).

Department pack

Scopes a session to one function: finance, operations, customer support, HR, sales, marketing, healthcare ops, supply chain, compliance, software/engineering, …

Use this when different contributors own different parts of the company. Each person sees relevant section hints and pain prompts without the full org at once.

Data maturity pack

Adjusts expectations for data readiness: spreadsheet/manual ops through to ML-native. Influences gap questions and feasibility framing — does not invent data you do not have.

SME profile (e.g. India SME)

Market overlay for operating realities: spreadsheet-first data, owner-led approval, lean IT, short ROI horizons. Supplies defaults and framing.

Peer cohort

Reference archetype profiles (not real clients) that suggest which gaps to close first while your graph is thin. Modes: off, auto-match, or manual pick. Never copies another company's graph — only nudges gap ordering and ranking early on.

Strategy lens (mandate)

Near-term and strategic mandates re-rank candidates: cost, productivity, innovation, risk, customer experience, … Plus budget direction (fund quick wins vs bets).

Affects Analyze ranking and Generate framing.

Persona lens

Shapes Generate output only (not Analyze scoring): founder, transformation lead, functional VP, agency partner, … Same candidates, different dossier emphasis.

Building the evidence map

The guided builder elicits facts that fire operators. The operator coverage panel shows what is ready (green) vs what facts would unlock dormant patterns (grey, with unlock hints).

Recommended fill order

Work top to bottom, prioritizing facts that unlock the most operators:

Section order may reorder based on archetype. Hover any ⓘ icon for field help.

Detailed section cheat sheet: [Builder guide](/builder-guide)

Pain & value interview

Structured prompts above the raw pains form — e.g. "Where is time wasted?", "Which workflows delay revenue?" — seed graded pains attached to nodes you select. Better pain inputs raise impact and quality measurability.

YAML tab (power users)

The YAML tab remains for direct editing, git workflows, and round-tripping with the builder. Loading an example or auto-mapping populates the builder; edges the builder does not manage are preserved on round-trip.

Switching back from YAML without saving does not re-parse unsaved edits.

Auto-map: draft, not done

Auto-map drafts a starting model from:

• Website URLs (optional same-domain crawl)
• Pasted notes
• Uploaded files (`.txt`, `.md`, `.html`, `.pdf`, `.csv`, `.xlsx`, …)

It typically captures roughly half to two-thirds of a useful model from public material. It rarely includes linked pains, accessible data flags, bottleneck skills, or project abstractions.

Do not rely on auto-map alone. After import:

1. Run Analyze
2. Close top gaps in Improve the model
3. Add internal evidence auto-map missed
4. Re-Analyze until high-severity gaps close

Use Merge into current model when extending an existing draft with new sources. Review review notes after import — inferred fields are flagged for human edit.

Identifiers in pasted notes and uploads are redacted server-side before any LLM call. See [Trust and evidence boundary](/trust).

Map from evidence (private discovery)

When facts live in internal systems (CRM, ERP, ticketing, spreadsheets), users may not want to upload raw records. Map from evidence closes gaps without full data sharing.

Privacy tiers

Raw evidence is not persisted. Only human-approved graph patches merge into the model.

Workflow

1. Run Analyze → open Improve the model
2. Pick a high-severity gap → Map from evidence
3. Choose privacy tier; enter observations
4. Review graph patch proposals → apply selected changes
5. Re-Analyze and repeat

For stricter boundaries (VPC-only LLM), ask your technical owner to run the private-runtime deployment profile.

Analyze vs Generate

When to Analyze: constantly — as you edit, after every evidence apply, between interview sessions. It is free and instant.

When to Generate: when high-severity gaps are closed and you need sponsor-ready wording. Generate usually takes a few minutes and requires LLM configuration.

Without LLM configured, Auto-map and Generate return ready-to-run prompts you can execute elsewhere.

Reading the results

Operator coverage

Shows N/37 firing. Green = operator matched graph facts. Grey = dormant, with unlock hint (e.g. "Add a project and write its reusable abstraction").

Aim for green operators that match the company's actual leverage — not every box ticked.

Candidate buckets

The review board groups candidates deterministically:

Generate output artifacts

Each generated use case may include:

• why_this_company — defensibility tied to graph facts
• first_experiment — smallest shippable pilot
• required_evidence — what to validate before scaling
• what_would_make_us_drop_this — kill criteria

With Opportunity dossiers enabled, selected quick wins and the strategic bet package into Markdown one-pagers you can copy to slides or memos.

Target Selector plan

The final plan surfaces:

• Quick wins — fund momentum (high impact + feasibility)
• One strategic bet — highest moat that is plausibly feasible
• Sequencing note — prerequisites honored; overlaps flagged

Quick wins and the strategic bet are never collapsed into one recommendation.

Roles in a multi-person program

Assign one department per session. Diagnostics = the sprint backlog — do not ask contributors to complete the whole form before they see value.

More workflow detail: [Consultant interview guide](/consultant-interview-guide)

Authentication and saved models

When the server has `AUTH_SECRET` set:

• Sign in / register to use Analyze, Generate, Auto-map, and saved models
• Saved models persist across devices, private to your account
• Marketing pages and the [Builder guide](/builder-guide) remain public

When auth is disabled (typical local dev), all features work without login but models live in browser storage only.

Privacy and data handling

• Pasted notes, uploads, and evidence snippets are redacted before LLM calls
• Raw uploads are never persisted on the server
• Public website crawl content is treated as public (not redacted)
• Only human-approved graph facts enter the company model

Full policy: [Trust and evidence boundary](/trust)

Troubleshooting

Example companies

The app ships contrasting examples you can load to learn the model:

Load one, change two fields, and watch the evidence preview react before modeling your own company.

Further reading

Quick reference card

```

1. Source → example | auto-map | saved model
2. Evidence → add facts → operators green → pains linked
3. Review → Analyze (free) → close top 3 gaps → repeat
4. Generate → when gaps closed → optional critique + dossiers
5. Save → server or YAML between sessions

```

Loop: `add facts → analyze → interview → evidence → analyze → … → generate`

Remember: dormant operators = roadmap. Generic candidates = thin evidence. Defensible bets appear when the graph reflects how the business actually operates.