Sales Engineering

Phase 15 · Document 07 · Startup Playbook Prev: 06 — Moat and Defensibility · Up: Phase 15 Index

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

A great product with no path to customers is a hobby. Sales engineering is how a technical founder turns a working product into revenue — and for AI products it's a distinct skill because the buyer's central fear is that you're "just a ChatGPT wrapper" and their central question is "will this actually work on our data, reliably, securely?" Technical founders often underestimate or disdain sales, which is a fatal mistake: in B2B, the technical sale (the POC that proves it works on the customer's real data) is frequently what closes the deal, and it's precisely the part a technical founder is best positioned to run. This doc covers the AI-specific sales motion — POC → pilot → enterprise, demos that convert, handling the "vs ChatGPT" objection, and navigating champions vs economic buyers — so you can sell what you built.

2. Core Concept

Plain-English primer: prove it works on their problem, then on their data

For B2B AI products, selling is de-risking the buyer's decision. The buyer has been burned by demos that wow but fail on real data, and they fear committing budget to an "AI wrapper" that the model vendor will obviate. Your job is to prove, step by step, that the product solves their specific problem on their real data, reliably and securely — converting skepticism into confidence. The technical founder's superpower here is the POC: you can stand up a proof on the customer's actual data and show the outcome (04 demo skills apply directly).

the AI B2B sale = DE-RISK the buyer's decision:
   demo (their problem) → POC (THEIR real data, measured) → pilot (real usage, success criteria) → enterprise (procurement/security [08]) → contract
   at each step: prove it WORKS, is TRUSTWORTHY, and is SECURE — converting "is this a wrapper?" skepticism into confidence.

The motion: POC → pilot → enterprise

• POC (Proof of Concept) — a short, scoped proof that the product works on the customer's real data and real problem, with agreed success criteria defined upfront. The technical founder runs this. The deadly trap is the endless unpaid POC with no exit criteria — define "if it achieves X, we move to a paid pilot" before starting.
• Pilot — a paid, time-boxed real deployment with a subset of users and measurable success criteria (e.g., "cut review time 50%," "resolve 80% of tickets"). The pilot proves value in production and produces the case study/reference.
• Enterprise rollout — full deployment, which triggers procurement, security review, and legal (08) — often the longest, most bureaucratic stage, gated on SOC 2/DPA/residency (Phase 14).

The discipline: each stage has explicit, measurable exit criteria so deals progress instead of stalling, and you don't pour months into a free POC that never converts.

The demo that converts (your highest-leverage skill)

The demo (04) is the tip of the spear. A converting AI demo:

• Starts on the customer's painful "before" (their 3-hour task), in their language/context.
• Shows the "after" on their (or realistic) data — the job done, fast.
• Builds trust, not just wonder — show citations, the human-approval step, accuracy so it's believable, not "magic" the buyer distrusts (03).
• Ends on the quantified outcome (time/cost saved) and a clear next step (scoped POC). The best demo uses the buyer's own example — nothing converts like seeing it work on their problem.

Handling "isn't this just a ChatGPT wrapper?"

This objection will come; have a crisp, honest answer rooted in your moat (06):

• "ChatGPT is a general tool; we own the end-to-end workflow for your job — ingestion, your data, validation, the integration, the audit trail" (03).
• "We're built on your proprietary data/feedback loop and integrated into your systems in ways a general chatbot isn't" (06).
• "We handle the trust, security, and compliance your use case requires — citations, approvals, SOC 2, data residency" (Phase 14).
• "The model is an input we ride for free as it improves; the product is everything around it." Never get defensive — the objection is an opening to articulate your defensibility.

Champion vs economic buyer (the two people you must win)

In B2B, the buyer ≠ user (02), and there are usually two key roles:

• Champion — the internal advocate (often a user/manager who feels the pain) who wants your product and sells it internally for you. You arm the champion with the demo, the ROI numbers, and answers to objections.
• Economic buyer — who controls the budget (a VP/exec). They care about ROI, risk, and strategic fit, not features. You must give the champion what they need to win the economic buyer. Also map blockers (security, legal, IT, 08) who can't say yes but can say no. Multi-threading (relationships with several stakeholders) de-risks the deal.

Selling value (ROI), not features

The economic buyer buys outcomes: "this saves 10 analyst-hours/week" or "resolves 80% of tickets, cutting support cost $X." Translate features into ROI in the customer's terms — and tie pricing to that value (05). For AI specifically, quantify the trust/accuracy (your eval results, Phase 12) because "how reliable is it?" is the buyer's real worry. A measured "94% accuracy with citations and a human-approval step" beats "it's powered by GPT."

The GTM motion fits the customer

Match the sales motion to the customer (00):

• PLG (self-serve) — individuals/small teams adopt via a free tier and upgrade; light-touch sales.
• Sales-led — compliance-sensitive enterprise; POC→pilot→procurement; the motion in this doc.
• OSS-led — developers adopt the open source, you monetize hosting/enterprise (06 distribution moat).
• Partner-led — distribute via incumbents' marketplaces. Sales engineering (POC/pilot) dominates the sales-led motion that most vertical/enterprise AI products require.

3. Mental Model

   AI B2B SALE = DE-RISK the buyer's decision. their fear: "ChatGPT wrapper that won't work on OUR data." your job: prove WORKS + TRUSTWORTHY + SECURE on their problem/data.
   technical founder's superpower = the POC on the customer's REAL data.

   MOTION (each stage = explicit measurable EXIT CRITERIA, or deals stall):
     DEMO (their problem, their data) → POC (their real data + agreed success criteria; AVOID endless unpaid POC) → PILOT (PAID, time-boxed, measurable success) → ENTERPRISE (procurement/security/legal [08]) → contract
   DEMO THAT CONVERTS: painful BEFORE (their language) → AFTER on THEIR data → TRUST not magic (citations/approval/accuracy [03]) → quantified outcome + next step (scoped POC)

   "JUST A CHATGPT WRAPPER?" → answer from your MOAT [06]: we own the WORKFLOW + your DATA/integration + TRUST/compliance [14]; model is an input we ride free. never defensive — it's an opening.
   PEOPLE: CHAMPION (internal advocate — arm them w/ demo+ROI+objection answers) + ECONOMIC BUYER (budget — cares ROI/risk/fit) + BLOCKERS (security/legal/IT [08] — can't say yes, can say no). multi-thread.
   SELL VALUE not features: ROI in customer terms (hours/$ saved) + QUANTIFIED trust/accuracy (eval results [12]) > "powered by GPT". tie price to value [05].
   GTM matches customer [00]: PLG (self-serve) · SALES-LED (enterprise — this motion) · OSS-LED (dev→monetize) · PARTNER-LED.

Mnemonic: selling AI is de-risking the buyer — prove it works on their real data with agreed success criteria, demo trust not magic, answer "just a wrapper?" from your moat, arm the champion to win the economic buyer, and sell quantified ROI and reliability, not "powered by GPT." Each deal stage needs explicit exit criteria.

4. Hitchhiker's Guide

What to look for first: can you prove it works on the customer's real data with agreed success criteria (a scoped POC → paid pilot), and who is the champion and who is the economic buyer? Those drive the deal.

What to ignore at first: building a big sales org and complex CRM ops. As a technical founder, you run the early technical sale (POC/pilot) — that's the highest-leverage and what you're best at.

What misleads beginners:

• Disdaining sales. A great product without a sales motion dies — the technical sale closes B2B AI deals.
• Endless free POCs. No exit criteria = months wasted — define "achieve X → paid pilot" upfront.
• Demos that are all magic. Buyers distrust magic — show trust (citations/approval/accuracy) (03).
• Getting defensive on "wrapper?". It's an opening to state your moat (06).
• Selling features to the economic buyer. They buy ROI/risk/fit — translate to outcomes (05).
• Single-threading. Relying on one contact is fragile — multi-thread (champion + buyer + blockers, 08).

How experts reason: they treat the sale as de-risking, run a scoped POC on real data with agreed success criteria → paid pilot → enterprise (each with exit criteria), demo the before→after→trust→outcome story on the buyer's own example, answer "just a wrapper?" confidently from the moat, arm the champion to win the economic buyer, sell quantified ROI and reliability (eval results), and multi-thread through blockers. They match the GTM motion to the customer.

What matters in production (of sales): deals progressing through stages with measurable exit criteria; POCs converting to paid pilots; pilots producing references; a confident wrapper-objection answer; and ROI/reliability quantified for the economic buyer.

How to debug/verify: is every POC scoped with success criteria and a paid-pilot exit? Can you state your "just a wrapper?" answer in two sentences? Do you know the champion and economic buyer by name? Are you selling outcomes (hours/$ saved) or features? Are deals stalling for lack of exit criteria or single-threading?

Questions to ask: can I prove it on their real data? what are the POC/pilot success criteria and exits? who's the champion / economic buyer / blockers? what's my wrapper-objection answer (moat)? am I selling ROI + reliability? does the GTM motion fit this customer?

What silently kills deals: disdaining sales, endless free POCs, magic-not-trust demos, a weak wrapper answer, feature-selling to budget-holders, and single-threading.

5. Warmup Readings

6. Deep Readings and External References

7. Key Terms

8. Important Facts

• The AI B2B sale is de-risking the buyer — proving the product works, is trustworthy, and is secure on their real data/problem; the buyer fears a "wrapper that won't work on our data."
• The technical founder's superpower is the POC on the customer's real data — the technical sale frequently closes the deal.
• The motion is POC → pilot → enterprise, each with explicit measurable exit criteria — avoid the endless unpaid POC; define "achieve X → paid pilot" upfront.
• A converting demo shows before→after on their data→trust (citations/approval/accuracy)→outcome+next step — not magic (03/04).
• Answer "just a ChatGPT wrapper?" from your moat — workflow + data/integration + trust/compliance; the model is an input you ride free (06).
• Win both the champion (arm them) and the economic buyer (sell ROI/risk/fit), and address blockers (security/legal/IT, 08); multi-thread.
• Sell quantified value (ROI) and reliability (eval results), not features — "94% accuracy with citations + approval" beats "powered by GPT" (Phase 12/05).
• Match the GTM motion (PLG / sales-led / OSS-led / partner-led) to the customer (00); sales-led dominates enterprise/vertical AI.

9. Observations from Real Systems

• Founder-led technical sales close the first enterprise AI deals — the founder running the POC on the buyer's data is repeatedly the difference, especially in skeptical verticals.
• The "is this just a wrapper?" objection is universal — the companies that win answer it confidently from a real moat; the ones that get defensive lose (06).
• Endless free POCs are a known deal-killer — without exit criteria they consume months; disciplined teams gate POC→paid-pilot upfront.
• Quantified reliability sells AI — buyers burned by hallucination demand accuracy numbers, citations, and human-approval; eval results become sales collateral (Phase 12).
• Enterprise deals stall in security/procurement — the SOC 2/DPA/residency stage (08) is the long pole; sales-savvy teams prepare it in parallel with the pilot.

10. Common Misconceptions

11. Engineering Decision Framework

SALES ENGINEERING (de-risk the buyer's decision):
 1. DEMO: before(their language)→after on THEIR data→TRUST(citations/approval/accuracy [03])→outcome+next step. Use their own example.
 2. POC: scoped, on their REAL data, with AGREED success criteria + an EXIT ("achieve X → paid pilot"). Founder runs it. No endless free POC.
 3. PILOT: PAID, time-boxed, measurable success criteria → produces the reference/case study.
 4. ENTERPRISE: procurement + security review + legal [08] (SOC2/DPA/residency [14]) — prep in PARALLEL; it's the long pole.
 5. PEOPLE: identify + ARM the CHAMPION; sell ROI/risk/fit to the ECONOMIC BUYER; address BLOCKERS (security/legal/IT). MULTI-THREAD.
 6. PITCH: quantified VALUE (hours/$ saved) + RELIABILITY (eval results [12]); tie price to value [05]. Answer "wrapper?" from the MOAT [06].
 7. MOTION: match PLG/sales-led/OSS-led/partner-led to the customer [00]. Sales-led for enterprise/vertical.

12. Hands-On Lab

Goal

Build the sales kit for your product: a converting demo script, a scoped POC plan with success criteria, a "just a wrapper?" answer, and a champion/economic-buyer map.

Prerequisites

• Your product/MVP (04), moat (06), and ICP (02).

Steps

1. Demo script: write the before→after(their data)→trust(citations/approval/accuracy)→outcome+next-step flow for your ICP; use a realistic buyer example (03/04).
2. POC plan: define a scoped POC on the customer's real data, with agreed success criteria and an exit ("if it achieves X, we move to a paid pilot"). Avoid open-endedness.
3. Pilot plan: define the paid, time-boxed pilot and its measurable success criteria (the reference-maker).
4. "Wrapper?" answer: write the two-sentence response rooted in your moat (06) and trust/compliance (Phase 14).
5. Stakeholder map: identify the champion, economic buyer, and blockers for a target account; note what each needs (champion: demo+ROI; buyer: ROI/risk; blockers: security, 08).
6. ROI pitch: translate your features into quantified outcomes (hours/$ saved) + reliability (eval results, Phase 12).

Expected output

A sales kit: a converting demo script, a scoped POC + paid-pilot plan with exit/success criteria, a confident wrapper-objection answer, a champion/buyer/blocker map, and an ROI/reliability pitch — ready to run a real founder-led sale.

Debugging tips

• If the POC has no exit criteria, it'll run forever — add them.
• If your demo is all wonder and no trust, serious buyers will stall — add citations/approval/accuracy.

Extension task

Run the demo with a real prospect (or a stand-in) and capture objections; refine the wrapper answer and ROI numbers from their reactions (01).

Production extension

Wire the enterprise-readiness prep (08) to run in parallel with pilots; turn pilot results into case studies; feed eval results (Phase 12) into sales collateral.

What to measure

Demo-to-POC and POC-to-paid-pilot conversion, pilot success-criteria attainment, deal-stage progression, strength of the wrapper answer, multi-threading coverage.

Deliverables

• A converting demo script (before→after→trust→outcome).
• A scoped POC + paid-pilot plan with exit/success criteria.
• A "just a wrapper?" answer + a champion/buyer/blocker map + an ROI/reliability pitch.

13. Verification Questions

Basic

1. Why is the AI B2B sale fundamentally about de-risking the buyer?
2. What are the stages of the POC → enterprise motion, and why does each need exit criteria?
3. Why is the technical founder uniquely suited to run the POC?

Applied 4. What makes an AI demo convert (vs merely impress)? 5. How do you answer "isn't this just a ChatGPT wrapper?"

Debugging 6. Your POC has run for three months with no decision. What went wrong? 7. The champion loves it but the deal won't close. What are you missing?

System design 8. Design the full sales motion (demo → POC → pilot → enterprise) for a vertical AI product.

Startup / product 9. How do you sell ROI and reliability to an economic buyer rather than features?

14. Takeaways

1. Selling AI is de-risking the buyer — prove it works, is trustworthy, and is secure on their real data; the technical founder's POC is the superpower.
2. Run POC → pilot → enterprise with explicit, measurable exit criteria — avoid the endless unpaid POC.
3. Demos convert by showing trust, not magic — before→after on their data→citations/approval/accuracy→outcome (03).
4. Answer "just a wrapper?" from your moat and win both the champion and the economic buyer (ROI/risk), multi-threading through blockers (06/08).
5. Sell quantified value and reliability, not features — eval results and ROI beat "powered by GPT" (Phase 12/05).

15. Artifact Checklist

• A converting demo script (before→after→trust→outcome+next step).
• A scoped POC plan with agreed success criteria + a paid-pilot exit.
• A paid-pilot plan with measurable success criteria.
• A "just a wrapper?" answer rooted in the moat.
• A champion / economic-buyer / blocker map + an ROI/reliability pitch.

Up: Phase 15 Index · Next: 08 — Enterprise Readiness