Ship Revenue · A POV in action
Every revenue process should be
version-controlled, testable code.
Ship Revenue is the framework. This site is what it looks like when you build it.
Ten loops across the full revenue lifecycle. Six live in production today, processing real CRM data end-to-end. The rest are designed and in queue.
The thesis
The GTM system is a product.
RevOps is the product team.
Most revenue systems are still spreadsheets, tribal knowledge, and exception handling in DMs — with chatbots glued on. Decisions get made, but nobody tracks whether they were good. Routing logic lives in one person's head. A scoring weight change takes two weeks and three meetings.
That model works when humans are the only processors. It breaks when the bottleneck shifts from capacity to context. The fix isn't more headcount or a smarter chatbot — it's architecture. Treat every revenue process as a versioned, testable, observable unit. Compose them through clean interfaces. Govern by authorship, not approval queues.
That's the framework. This site is one operator's instantiation of it.
The framework
Ten loops. Four chains.
The full revenue lifecycle.
A revenue loop is a self-contained, composable execution unit covering one stage of the lifecycle. Each loop carries the same six components — config, logic, inputs, outputs, metrics, feedback. Loops chain together: the output of one becomes the input of the next.
Six loops live in production (Design, Deploy, Qualify, Route, Engage, Pursue). Generate has Signal Scanner running. Onboard, Expand, and Coach are designed.
Planning — architecture of the revenue org
Design Live
Capacity, headcount, productivity, territories, comp. Scenarios are complete, sharable plans — promote one and the rest of the system reads from it.
Deploy Live
Materializes Design's scenarios in systems of work: territory hierarchy, user assignments, account-to-territory matching with an AI agent fallback for ambiguous geography.
Demand — every lead
Generate Partial
Demand creation. Signal Scanner is live — a rolling AI scan of target accounts for buying signals (funding, hiring, leadership moves, tech changes, product launches). Campaigns, ABM, content, paid, and partner programs are planned.
Qualify Live
Enrich, score against a versioned model, grade A/B/C/D, write back to the CRM. Every weight is config.
Route Live
Territory-aware rules engine, first-match wins. Falls back to an AI agent for ambiguous geography. Resolves to user, pool, or queue.
Acquisition — every opportunity
Engage Live
An AI agent researches the prospect, composes a personalized email sequence, scores it against a quality rubric. Reps review via natural-language commands.
Pursue Live
Picks a deal play, creates milestone tasks, monitors deal health, nudges stale deals, surfaces risk. The full opportunity lifecycle.
Retention — every account
Onboard Designed
Implementation kickoff, training, adoption milestones, health monitoring during ramp. Ends when the customer reaches first value. Most revenue systems run this informally; consumption pricing makes it operationally critical.
Expand Designed
Renewal management, upsell and cross-sell plays, expansion pipeline. Same scoring rigor as new-lead Qualify, applied to expansion.
Cross-cutting
Coach Designed
Aggregate call intelligence, activity patterns, and deal outcomes into coaching signals per rep. Surfaces patterns a manager can't see from sampling. Doesn't replace the manager — gives them better situational awareness.
In flight
What a chain looks like when a lead arrives
The Demand and Acquisition chains run end-to-end on real CRM leads. Here's the path a single lead takes from creation to personalized outbound:
CRM trigger fires
A new lead lands in the CRM. Eleven fields (email, company, title, industry, country, state, employee count, ...) ship to the Qualify webhook.
Qualify: enrich and score
Third-party enrichment fills gaps — industry, headcount, tech stack, funding, social profiles. A config-driven scoring engine evaluates ten factors across fit and intent. Score and grade written back to the CRM.
# illustrative scoring output
company_size: 20 industry: 15 email: 15 seniority: 12
tech_stack: 7 company_type: 5 linkedin: 5 source: 25
geography: 15 has_email: 10
Score: 129/135 Grade: A Config: v3.1.0
Route: assign to owner
The rules engine walks priorities — continuity, vertical, size, source, territory, fallback. Falls back to an AI agent for ambiguous geography. Lead owner updated in the CRM.
Engage: AI-composed outreach
An agent researches the prospect company — industry context, pain points, competitive landscape. Composes a personalized 3-4 email sequence. Quality-scored against a seven-criteria rubric. Stored for rep review.
Pursue: deal plays and deal health
When the lead converts to an opportunity, Pursue picks a deal play, creates milestone tasks with staggered due dates, monitors velocity, flags risk, and nudges stale deals. The full opportunity lifecycle in one loop.
Every decision is logged with reasoning
Each scoring factor, routing rule match, agent inference, and play selection writes a reasoning trail. Auditable by default. The system learns from outcomes — not from a black box.
The Agentic RevStack
Code executes. Agents reason and generate. Humans govern.
Running every decision through an agent is slow and expensive. Running everything through static rules can't produce research, prose, or semantic judgment. The split is deliberate: code where determinism is possible, agents for the cognitive work code can't do, humans above both.
Code executes
Scoring math, rule evaluation, territory matching by billing fields, CRM sync, nudge thresholds, workflow orchestration. Fast, cheap, auditable. Vast majority of the volume.
AI coding tools let revenue engineers convert process gaps into deterministic code at a rate that wasn't feasible before.
Agents reason and generate
Prospect research and email composition, rolling signal scans of target accounts, fuzzy territory matching from enrichment data, classification of unstructured notes, call-transcript summarization. Reasoning, inference, generation — the work code can't do.
Every decision carries a confidence score. Sub-threshold matches auto-escalate to humans.
Humans govern
Specs for new loops, thresholds and policy, low-confidence escalations, the true exceptions, audit of the reasoning trail. Governance is authorship — not approval queues.
Thresholds are config. Ops tunes them without a release.
Three roles, one system
Revenue Engineering, Revenue Operations, the Field
Each team interacts with the system differently. Engineers build it. Ops tunes it. The field works in their CRM. Nobody needs a new tool to learn.
Builds and extends the infrastructure
Workflow logic, CRM integrations, enrichment pipeline, scoring engine, database schemas. Ships via version control. Debugs in the workflow engine UI.
Owns: how loops work | Never touches: scoring weights, routing rules, play definitions
Tunes behavior via config and AI skills
Scoring weights, routing rules, play definitions, grade thresholds, buying signals — all versioned. Edits via natural-language commands (“increase VP seniority to 14 points”). Previews impact before deploying. Monitors health via live dashboards.
Owns: how loops behave | Never touches: workflow code, database schemas, integrations
CRM-native with AI-powered self-serve
Scores, grades, enrichment data, and tasks appear on every CRM record automatically. Overrides and escalations flow through the CRM with built-in approvals and audit trail. AI gives reps instant answers: “What's my pipeline health?” “Why was this lead scored A?”
Sees: scores, reasoning, tasks, overrides | Never sees: config, workflows, infrastructure
Before / After the framework
What changes
| Before | After | |
|---|---|---|
| Processes | Spreadsheets, tribal knowledge | Version-controlled config |
| Decisions | Invisible, untracked | Every decision logged with reasoning |
| Changes | Email chains, meetings, hope | Branch → simulate → deploy |
| Reporting | Pull data, build slides | Ask in plain language, grounded in CRM + loop data |
| Scaling | More reps = more ops headcount | System handles volume, team handles complexity |
| AI | Chatbot on the side | Embedded in every loop. Agents handle edge cases |
Read along.
The framework is at Ship Revenue. The architecture is here. Both update as the system grows.