Use Cases
UPG at scale, worked all the way through
The spec defines what the graph is. A use case shows what it does when a real organisation leans on it. Each one takes a single shape of product work at scale, runs it end to end against a concrete example, and hands off to the reference. The portfolio and competitive cases share one company (Stripe), so they compose into a single picture; the rest stand on their own.
Each covers one region of the lifecycle or a cross-cutting capability, with more added as the pattern earns them. Every one is self-contained, so start anywhere.
One organisation, two independent axes, a shared registry that catches drift, typed cross-product edges, and a metric and OKR cascade that keeps leaf work legible at the top.
The cascade from vision down to a measurable key result, anchored on the outcome, so every objective names the change it chases and every feature names the outcome it serves.
Competitors as graphs the team watches but does not grade, their moves as dated signals typed back into the work, feature parity as a traversal, and one shared classification of the whole field.
The persona as one typed anchor the whole product links to, with the jobs it pursues and the needs those jobs surface, so every region describes the same person.
The whole span typed, from the need a feature addresses and the key result it drives down through epics and stories to the task an engineer picks up, so scope and priority become traversals.
The business model, growth engine, and marketing motion as one region anchored on the value proposition, so the offer, funnel, and message reference the same customers and metrics.
The journey as an ordered sequence of steps mapped to the canonical persona, feeding a design system of linked components, so design connects to the product instead of running parallel to it.
The measurement plane from data source to dashboard, with a north-star metric that decomposes into the inputs that move it and is validated by data-quality rules.
A metric modelled at every level: its formula and designation, the tree it decomposes into, the outcomes it measures, its provenance and quality, and the measurement type every region shares.
The system anchored on the service: the API contract, schema, deployment, and the feature it powers all hang off one live node that traces back to the user need.
The incident typed so it breaches an SLO, affects a feature, triggers a postmortem, and traces to a root cause linked to its prevention, so the break-learn-prevent loop becomes queryable.
A specification registered once as a canonical entity, so every product that implements, exposes, or conforms to it links to one shared node instead of redefining it per product.
One typed, shared graph every agent reads and writes over MCP, so AI output accumulates across sessions and tools instead of being re-derived each time.
The product knowledge already kept in Markdown, Notion, Linear, and GitHub, imported rather than retyped: adapters propose typed nodes with a mapping confidence, and a human reviews before anything commits.
The entities held once and projected through an Opportunity Solution Tree, a Business Model Canvas, or RICE, so a framework is a lens over the graph with nothing to keep in sync.
Every rung of the climb typed, from a verbatim quote up to an opportunity, so a roadmap decision always traces back to the evidence that seeded it.
Every use case is built the same way, so each new one is cheaper than the last and they all read as one system.
- One concrete example
- A real organisation carried all the way through, so the abstraction is always anchored to something concrete.
- Coded visuals
- Each beat of the story gets a diagram drawn from the same design language as the reference docs, not a stock illustration.
- A handoff to the reference
- A use case shows the shape; it always points to the spec and the model docs for the exhaustive detail.