building-sales-team

Original source / Raw SKILL.md

---
name: "building-sales-team"
description: "Build an early sales team and operating cadence (readiness gate, hiring plan, role scorecards, interview loop, onboarding/ramp). Use for first AE/SDR hires, seed→Series A sales team build, and product-led sales pilot. Category: Sales & GTM."
---

# Building Sales Team

## Scope

**Covers**
- Deciding **when** to hire sales vs continue founder-led selling
- Designing the **first sales team** (pilot AE/SDR/hybrid) and hiring sequence
- Hiring for **repeatability** (avoid “one heroic rep” dependency)
- Setting a minimal **operating cadence** (ramp plan, metrics, coaching loop)
- Technical / product-heavy selling: “sales that can pass for PMs”

**When to use**
- “We’re ready to hire our first AE / SDR—help me design the plan.”
- “Should we hire sales now or wait until the motion is repeatable?”
- “Create role scorecards + an interview loop for early sales hires.”
- “We’re starting product-led sales—how do we run a small pilot team?”
- “Build an onboarding + 30/60/90 ramp plan for the first reps.”

**When NOT to use**
- You need to get first customers / validate ICP from scratch (use `founder-sales` first)
- You’re scaling a mature sales org (territories, forecasting, multi-layer management)
- You need legal/HR advice, compensation plan legal review, or employment compliance guidance
- You want generic hiring advice without a defined sales motion and measurable readiness gates

## Inputs

**Minimum required**
- Company stage (pre-seed/seed/Series A+) and current GTM motion (PLG, outbound, enterprise, inbound)
- Current funnel baseline: last ~50–100 “at-bats” if available (first meetings → closed-won), win rate, typical ACV, cycle length
- ICP + product complexity (how technical is the sell; who must be convinced)
- Current resources: founder time, CS/support involvement, marketing demand, budget/headcount constraints
- Timeline + success definition (e.g., “2 reps ramped to $X pipeline/month in 90 days”)

**Missing-info strategy**
- Ask up to 5 questions from [references/INTAKE.md](references/INTAKE.md).
- If data is missing, proceed with explicit assumptions and deliver **two options**: (A) “Hire now (pilot)” vs (B) “Wait + founder-led milestones to hit first”.

## Outputs (deliverables)

Produce a **Sales Team Build Pack** in Markdown (in-chat; or as files if requested):

1) **Context snapshot** (stage, motion, ICP, constraints, targets)
2) **Readiness gate** (hire-now vs wait) with measurable criteria
3) **Team design + hiring sequence** (who to hire first/second; when; why)
4) **Role scorecards** (AE/SDR/hybrid) + evaluation criteria (incl. product depth bar)
5) **Interview loop + practical exercises** + scoring sheet
6) **Onboarding + 30/60/90 ramp plan** + coaching/metrics cadence
7) **Risks / Open questions / Next steps** (always included)

Templates: [references/TEMPLATES.md](references/TEMPLATES.md)

## Workflow (7 steps)

### 1) Intake + stage gating (should we hire now?)
- **Inputs:** User context; [references/INTAKE.md](references/INTAKE.md); any funnel history.
- **Actions:** Identify the GTM motion and whether the founder has achieved a repeatable baseline. Look for: (a) organic demand/hand-raisers (if PLG), and/or (b) a repeatable win rate from first meeting → close (target range often ~15–25% over ~50–100 at-bats). Decide: **Hire now** vs **Wait**.
- **Outputs:** Context snapshot + readiness gate decision + assumptions/unknowns.
- **Checks:** The decision is tied to measurable evidence (or clearly labeled assumptions).

### 2) Define the “repeatable motion” you’re hiring into
- **Inputs:** ICP, use case, pricing/packaging, current discovery/demo flow.
- **Actions:** Write a 1-page “sales motion spec”: qualification, first meeting agenda, demo/pilot criteria, pricing guardrails, common objections, and what counts as an “at-bat”. Clarify founder vs rep responsibilities for the next 60–90 days.
- **Outputs:** Sales motion spec + handoff boundaries.
- **Checks:** A new rep could run the next 10 deals with this spec without inventing the process.

### 3) Choose the initial team topology (pilot-first) + sequence hires
- **Inputs:** Motion spec; readiness decision; budget; pipeline sources.
- **Actions:** Select the simplest starting shape:
  - PLG/hand-raisers: attach yourself to a **pilot AE and/or SDR** and run it as a learning pod (not quota theater).
  - Outbound: consider an SDR+AE sequence (or a hybrid rep) depending on deal complexity.
  - In very early stages: use **founder/CS/support** to close a subset of deals until the motion is proven.
  Build a hiring sequence that enables A/B testing: if feasible, **hire two reps** close together to avoid “one data point” dependence.
- **Outputs:** Team design + hiring plan table (roles, timing, success criteria, risks).
- **Checks:** The plan creates comparability (two reps or comparable cohorts) and protects learning time.

### 4) Write role scorecards (hire for product depth + learning ability)
- **Inputs:** Motion spec; team design; customer/technical context.
- **Actions:** Draft scorecards for each role (AE/SDR/hybrid). For technical products, set a “PM-like” bar: reps should demonstrate product intuition, curiosity, and the ability to earn engineer trust. Translate insights into “must-have signals” + “red flags”.
- **Outputs:** Role scorecards + evaluation rubric.
- **Checks:** Scorecards are specific enough that two interviewers would rate candidates similarly.

### 5) Build an interview loop with practical tests
- **Inputs:** Scorecards; [references/TEMPLATES.md](references/TEMPLATES.md) (interview kit).
- **Actions:** Define stages, interviewers, and exercises (e.g., mock discovery, objection handling, written follow-up email, product deep-dive, “explain to 10 engineers” test). Add structured scoring and a debrief protocol to reduce gut-feel hiring.
- **Outputs:** Interview plan + question bank + score sheet.
- **Checks:** Every interview maps to a scorecard signal; pass/fail criteria are explicit.

### 6) Create onboarding + ramp plan (and a simple management system)
- **Inputs:** Motion spec; expected pipeline sources; enablement assets (or create minimal ones).
- **Actions:** Build a 30/60/90 plan: training, shadowing, call reviews, pipeline targets, activity guardrails, and demo/pilot readiness. Define weekly cadence (pipeline review, call coaching, experiment review). Preserve the “A/B test humans” approach by tracking rep-to-rep differences and diagnosing process vs person.
- **Outputs:** Onboarding plan + ramp targets + coaching cadence + metrics list.
- **Checks:** Ramp targets are measurable; coaching loop is scheduled; “definition of done” exists for each phase.

### 7) Quality gate + finalize
- **Inputs:** Draft pack.
- **Actions:** Run [references/CHECKLISTS.md](references/CHECKLISTS.md) and score with [references/RUBRIC.md](references/RUBRIC.md). Add **Risks / Open questions / Next steps** and identify what would change the hire/wait decision.
- **Outputs:** Final Sales Team Build Pack.
- **Checks:** A stakeholder can approve the plan and start hiring this week (or confidently defer with clear milestones).

## Quality gate (required)
- Use [references/CHECKLISTS.md](references/CHECKLISTS.md) and [references/RUBRIC.md](references/RUBRIC.md).
- Always include: **Risks**, **Open questions**, **Next steps**.

## Examples

**Example 1 (first AE hires):**  
“Use `building-sales-team`. We’re seed-stage B2B SaaS. Founder has closed 12 customers; last 60 first meetings → 14 closed-won (~23%). ACV $12k. We want to hire our first AEs. Output: a Sales Team Build Pack with readiness gate, hire-two plan, role scorecards, and interview loop.”

**Example 2 (PLG → PLS pilot):**  
“Use `building-sales-team`. We have steady inbound hand-raisers from our product. We want a pilot AE/SDR pod to close mid-market upgrades. Output: team topology, hiring sequence, and a 30/60/90 ramp with coaching cadence.”

**Boundary example:**  
“We have no repeatable sales motion or ICP yet—hire a VP Sales to ‘figure it out’.”  
Response: recommend founder-led discovery/validation first (use `founder-sales`), define readiness milestones, and return to this skill once a motion can be written down and measured.


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### references/INTAKE.md

```markdown
# Intake (Building Sales Team)

Ask **up to 5 questions at a time**. If answers aren’t available, proceed with explicit assumptions and label unknowns.

## Minimum intake (pick the best 5)
1) **Stage + goal:** What stage are you (seed/Series A+), and what does “success” look like in the next 90 days? (pipeline, bookings, revenue, learning milestones)
2) **Sales motion:** PLG/inbound/outbound/enterprise? Who is the buyer vs user? Typical ACV and sales cycle?
3) **Repeatability evidence:** Over the last ~50–100 “at-bats”, what was your win rate from first meeting → closed-won (and why do you win/lose)?
4) **Demand source:** Where do opportunities come from today (founder outbound, product hand-raisers, partners, marketing)? What’s the volume/quality?
5) **Product complexity:** How technical is the sell? Who must be convinced (engineers, security, finance, execs)?

## Team constraints (as needed)
- Budget + headcount: can you hire **two reps** close together or only one?
- Do you have CS/support that can help close early deals or run onboarding?
- Any must-have geo/time zone/language constraints?
- Timeline: when must the first hire start? What’s the hiring market reality?

## Hiring preferences (optional)
- Which roles are you considering first: AE, SDR, hybrid, sales engineer, CS-as-closer?
- Do you want a player/coach (first sales leader) or individual contributors first?
- What’s non-negotiable in candidate profile (industry, technical fluency, founder-like, etc.)?

## If the user can’t answer
Proceed with:
- A stated assumption for motion + ICP
- A **readiness gate** with measurable milestones (what to measure next)
- Two options:
  - **Option A:** Hire now (pilot) with conservative scope + learning cadence
  - **Option B:** Wait and keep founder-led selling until milestones are hit
- A minimal hiring plan (sequence + scorecards + interview loop) that can start immediately


```

### references/TEMPLATES.md

```markdown
# Templates — Building Sales Team

Copy/paste the sections you need. The default deliverable is a single “Sales Team Build Pack” document that contains each template filled in.

## 1) Context snapshot (brief)
```md
# Sales Team Build Pack — <Company/Product>

## Context snapshot
- Stage: <pre-seed/seed/Series A+>
- GTM motion: <PLG/inbound/outbound/enterprise>
- ICP: <buyer/user + firmographics>
- Product complexity: <low/medium/high; who needs to be convinced>
- Pricing/ACV: <...>
- Sales cycle: <...>
- Current resources: <founder time, CS/support, marketing demand, tooling>
- Constraints: <budget/headcount/timeline/geo>
- 90-day target: <pipeline/bookings/revenue/learning milestones>

## Assumptions & unknowns
- <assumption 1>
- <unknown 1 + how we’ll resolve it>
```

## 2) Readiness gate (hire now vs wait)
```md
## Readiness gate

### Current baseline (best available)
- At-bats measured as: <definition>
- Last 60–90 days:
  - First meetings: <#>
  - Closed-won: <#>
  - Closed-lost: <#>
  - Win rate (first meeting → closed-won): <#%>
  - Typical ACV: <$>
  - Typical cycle length: <days/weeks>
- Top win reasons: <1–3 bullets>
- Top loss reasons: <1–3 bullets>

### Decision
Choose one:
- ✅ **Hire now (pilot)** because: <evidence>  
  We will measure in 30 days: <metrics>
- ⛔ **Wait** because: <evidence>  
  Milestones to hit before hiring: <3–5 measurable milestones>

### Notes (anti-pitfalls)
- Avoid hiring as a substitute for figuring out ICP/messaging.
- If wins are mostly relationships/favors, treat baseline as low-confidence.
```

## 3) Sales motion spec (1-pager)
```md
## Sales motion spec (what we’re hiring into)

### ICP + qualification
- In-scope: <...>
- Out-of-scope: <...>
- Must-have trigger events: <...>

### First meeting (discovery-first)
- Objective: <...>
- Agenda: <...>
- Qualification signals: <...>

### Demo / pilot / trial criteria
- When we demo: <...>
- When we propose a pilot: <...>
- Pilot success criteria (30 days): <...>

### Pricing/packaging guardrails
- Default offer: <...>
- Concessions allowed: <...>
- Concessions not allowed: <...>

### Sales stages + “at-bat” definition
- Stage 0: <...> (exit criteria)
- Stage 1: <...>
- Stage 2: <...>

### Objections + best current responses
- <objection> → <response>

### Responsibilities (next 60–90 days)
- Founder owns: <...>
- Rep owns: <...>
- CS/support owns: <...>
```

## 4) Team design + hiring sequence plan
```md
## Team design + hiring sequence

### Starting topology (pick one)
- PLG/hand-raisers pilot pod: <AE + SDR or hybrid> attached to founder
- Outbound sequence: <SDR → AE> (or hybrid first)
- Technical-heavy coverage plan: <founder/PM/SE coverage until dedicated SE>

### Hiring sequence (why this order)
| Role | Timing | Why now | Success criteria (30/60/90) | Key risks | Notes |
|---|---:|---|---|---|---|
| <Role 1> | <date> | <...> | <...> | <...> | <...> |
| <Role 2> | <date> | <...> | <...> | <...> | <...> |

### “A/B test humans” plan (recommended)
- If feasible, hire **two reps** close together to avoid “one data point.”
- Define what “comparable” means: segment, lead source, territory, enablement, time.
- Decide what you’ll compare: conversion rates, sales cycle, deal size, qualification accuracy.
```

## 5) Role scorecard (repeat per role)
```md
## Role scorecard — <AE / SDR / Hybrid>

### Mission
<What this role exists to accomplish in the next 90 days>

### Outcomes (30/60/90)
- 30: <...>
- 60: <...>
- 90: <...>

### Must-have signals
- <signal> (how we’ll test it)
- <signal>

### Red flags
- <anti-signal>

### Product depth bar (for technical products)
- Can explain product like a PM (crisp, non-hand-wavy)
- Asks “engineer-grade” questions without posturing
- Builds trust with technical stakeholders quickly

### Practical tests (map to interview loop)
- Mock discovery: <...>
- Product deep-dive: <...>
- Written follow-up: <...>
```

## 6) Interview loop + score sheet
```md
## Interview loop — <Role>

### Stages
1) Recruiter screen (30 min)
2) Hiring manager interview (45 min)
3) Mock discovery (45 min)
4) Product deep-dive / “PM-like” interview (45 min)
5) Written follow-up (async, 30–60 min)
6) References (2 calls)

### Scorecard dimensions (1–5)
- Domain learning speed
- Diagnostic discovery (asks great questions)
- Product depth and credibility (esp. with engineers)
- Objection handling + next-step discipline
- Writing clarity (follow-up, recap, MAP mindset)
- Coachability (incorporates feedback)

### Debrief protocol
- Each interviewer submits scores + evidence before discussion.
- Decide with scorecard evidence; record “why yes / why no” for calibration.
```

## 7) Onboarding + 30/60/90 ramp plan
```md
## Onboarding + ramp plan — <Role>

### Pre-start (week 0)
- Access + tooling: <CRM, email, call recording, product env>
- Read/skim: motion spec, ICP sheet, pricing guardrails, case studies

### First 2 weeks (foundation)
- Shadowing plan: <calls to shadow + notes expectations>
- Product training: <modules>
- Discovery practice: <role plays + coaching>
- “Definition of done”: rep can run discovery and produce a crisp recap + next steps

### 30/60/90 targets (measurable)
- 30: activity + skill milestones (not only quota)
- 60: qualified pipeline created + pilots started
- 90: closed-won targets (or validated learning targets if still early)

### Coaching cadence (weekly)
- Pipeline review: <day/time>
- Call review: <day/time>
- Experiment review: <day/time> (what we tried, what we learned, what changes)

### Metrics to track
- First meeting → next step conversion
- Pilot/trial start rate
- Win rate (stage-by-stage)
- Cycle length
- Deal quality (ICP fit, churn risk signals)
```

## 8) Risks / open questions / next steps (required)
```md
## Risks
- <risk> (mitigation)

## Open questions
- <question> (how we’ll answer it)

## Next steps (this week)
1) <...>
2) <...>
```


```

### references/CHECKLISTS.md

```markdown
# Checklists — Building Sales Team

Use these checklists before finalizing the Sales Team Build Pack.

## A) Readiness gate (hire now vs wait)
- [ ] The current motion is stated (PLG/inbound/outbound/enterprise) and the ICP is explicit.
- [ ] Baseline funnel numbers are included (or clearly marked as unknown).
- [ ] A clear **hire-now vs wait** decision is made and tied to measurable criteria.
- [ ] If hiring now, the scope is sized as a **pilot** with learning time protected (not quota theater).
- [ ] If waiting, milestones are specific (e.g., # at-bats, win rate range, stable ICP, hand-raiser volume).

## B) Motion spec quality (teachability)
- [ ] “At-bat” is defined and stages have exit criteria.
- [ ] First meeting objective + agenda exists (diagnostic, not feature dump).
- [ ] Demo/pilot/trial criteria are explicit.
- [ ] Pricing/packaging guardrails are included (what can/can’t be offered).
- [ ] Founder vs rep vs CS/support responsibilities are clear for 60–90 days.

## C) Team design + hiring sequence
- [ ] The initial team topology matches the motion (PLG vs outbound vs enterprise).
- [ ] Hiring sequence is justified (why this role first, what bottleneck it resolves).
- [ ] If feasible, there is an “**A/B test humans**” plan (two reps or comparable cohorts).
- [ ] The plan avoids premature specialization (hybrid/pod first where appropriate).
- [ ] There is a plan for technical coverage (SE/founder/PM support) if needed.

## D) Hiring criteria (product depth + learning)
- [ ] Role scorecards define outcomes (30/60/90), must-have signals, and red flags.
- [ ] For technical products, the bar includes “PM-like” product thinking and engineer credibility.
- [ ] Signals are testable (each maps to an interview exercise or evidence source).

## E) Interview loop robustness
- [ ] Interview stages cover the full scorecard (discovery, product depth, writing, coachability).
- [ ] Practical exercises exist (mock discovery, product deep-dive, written follow-up).
- [ ] Scoring is structured (1–5) with evidence, and debrief protocol reduces gut-feel bias.

## F) Onboarding + management system
- [ ] A 30/60/90 ramp plan is present with measurable targets.
- [ ] Weekly cadence is defined (pipeline review, call coaching, experiment review).
- [ ] Metrics include both leading indicators and conversion/quality measures.
- [ ] There is an explicit plan to diagnose **process vs person** (learning loop + comparability).

## G) Final sections (required)
- [ ] Risks are listed with mitigations.
- [ ] Open questions are listed with how they’ll be answered.
- [ ] Next steps are executable within one week.


```

### references/RUBRIC.md

```markdown
# Rubric — Building Sales Team (Sales Team Build Pack)

Score each category **1–5**. Target: **≥ 24/35** with no category below **3**.

## 1) Readiness gate clarity
**1:** No hire/wait decision; vague rationale.  
**3:** Decision made with some metrics/assumptions; milestones exist.  
**5:** Decision is evidence-based, milestones are measurable, and the plan protects learning.

## 2) Sales motion spec (teachability)
**1:** “Sell the product” hand-waving; no stage definitions.  
**3:** Motion spec exists but has gaps (stages, pricing guardrails, responsibilities).  
**5:** Motion is written down with stage exit criteria, demo/pilot rules, and clear handoffs.

## 3) Team design + sequencing
**1:** Org chart without rationale; premature specialization.  
**3:** Reasonable sequence with some motion fit; limited comparability.  
**5:** Topology matches motion, sequencing is justified, and comparability/A-B baseline is planned.

## 4) Role scorecards (signals + tests)
**1:** Generic traits; not testable.  
**3:** Signals exist, some mapped to tests; technical depth bar is partial.  
**5:** Clear outcomes + must-have signals/red flags; every signal has a test; “PM-like” bar is explicit where needed.

## 5) Interview loop quality
**1:** Unstructured interviews; no practical exercises; no debrief protocol.  
**3:** Some structure and exercises; scoring inconsistently applied.  
**5:** Practical tests + structured scoring + evidence-based debrief; reference checks validate key signals.

## 6) Onboarding + ramp + cadence
**1:** “Shadow and figure it out”; no metrics.  
**3:** 30/60/90 exists with basic cadence; metrics incomplete.  
**5:** Ramp is measurable, cadence is scheduled, and there is a learning loop to diagnose process vs person.

## 7) Execution readiness (risks + next steps)
**1:** No risks/questions/next steps.  
**3:** Risks and next steps exist but are generic.  
**5:** Risks are mitigated, open questions have owners/answers, and next steps are executable this week.


```