claude-skill

QBR prep with Salesforce + Gong + Claude

Difficulty

intermediate

Setup time

45min

For

revops · csm

RevOps

Stack

A Claude Skill that takes a customer account and a quarter and produces a 70%-done QBR draft: usage trends keyed to the success plan, top wins of the quarter sourced from Salesforce and Gong, an open-risks table, success-plan progress, and a ranked list of expansion paths. CSMs go from a blank Google Slides template to slot-mapped Markdown the team’s deck-assembly script can inject in five minutes. The artifact bundle ships the SKILL.md plus three reference files the CSM team adapts once and reuses across every account.

When to use

You are a CSM (or a RevOps lead supporting CSMs) prepping a QBR deck draft for a single named account, and you want a populated starting point you can edit rather than a blank template. The skill is designed for the workflow where four data streams have to come together — Salesforce account history, Salesforce cases from the quarter, Gong call themes from the last 90 days, and the active success-plan doc — and where the deck has to land in the team’s voice with named placeholder slots filled.

It works well when usage data is reasonably clean, success plans are kept current, and the QBR template has stable named slots the deck-assembly script can split content back into. It produces the most useful output for accounts with at least three Gong calls in the quarter and a success plan refreshed within the last 60 days. For everything else, the skill flags the gap explicitly rather than producing a confidently-wrong draft.

When NOT to use

Do not use this skill to auto-publish a QBR deck without CSM review. The skill is a draft engine. Every deck still gets a human pass before the customer sees it. Do not point it at a customer-facing deck where the named account team has not approved the framing — the AE/CSM-of-record owns the narrative; the skill seeds it.

Do not use it for accounts with under 30 days of usage data, no logged Gong calls in the quarter, or a success plan that has not been touched in over 60 days. The skill is built to flag and refuse rather than pad with generalities, but only if you respect the refusal — overriding the gap warnings produces decks that read fine and mislead the customer.

Do not use it for renewal forecasting or churn prediction. The relevant rubric is in the churn-risk-summarizer skill, which is calibrated for retention scoring; this skill is calibrated for deck content and will mislead you if you read its risk table as a churn signal.

Do not use it for non-customer reviews (board updates, internal QBRs, deal reviews). The slot map and tone-match passes assume an external audience.

Setup

Roughly 45 minutes the first time, mostly spent mapping your QBR template’s named slots to the skill’s expected slot vocabulary.

Install the Skill. Drop the bundle from apps/web/public/artifacts/qbr-prep-skill/ into ~/.claude/skills/qbr-prep/. The Skill defines a single command, prep_qbr(account_id, quarter), plus internal helpers for Salesforce, Gong, parsing the success plan, and the three-pass Claude pipeline.
Wire credentials. Set SFDC_TOKEN (read access on Account, Opportunity, Case), GONG_API_KEY (read access on calls and transcripts), and either GOOGLE_SLIDES_TOKEN or a path to a local PPTX template. Set USAGE_WAREHOUSE_VIEW to the BigQuery view or CSV path the team uses; the skill validates the column header against the schema in references/1-qbr-template-slots.md and refuses to populate the usage trend if columns drift.
Adapt the template files. Open references/1-qbr-template-slots.md and replace the slot manifest with the actual named placeholders in your team’s deck. Open references/2-success-plan-format.md and either adopt the schema verbatim across the CSM team or replace it with your team’s existing format — whichever path you pick, the skill needs a stable shape to parse against. Replace the worked example in references/3-sample-output.md with three to five anonymized prior QBRs from your CSM team so the tone-match pass has real material to mimic.
Map the success-plan storage. Pick one of Notion, Salesforce custom object, or Gainsight CTA, and stick to it. The skill’s success_plan_ref resolver assumes a single canonical storage location per account. Mixed storage is the most common cause of “the skill says my plan is missing when it is not.”
Run for one account. prep_qbr(account_id="0014x...XYZ", quarter="Q1-2026", last_qbr_path="...", success_plan_ref="..."). The skill writes one Markdown file with one fenced block per slot plus a separate one-page exec summary. Pipe the slot file through the team’s deck-assembly script (or paste manually for the first run).

What the skill actually does

The skill pulls four data streams in parallel because they hit independent systems and the bottleneck is API latency, not Claude tokens. Salesforce account history covers ARR trajectory, expansions or contractions, and renewal date. Salesforce cases cover ticket volume vs prior quarter, severity mix, and median time-to-resolve. Gong covers call themes, executive quotes, and competitor mentions from the last 90 days. The success-plan doc covers the goals the slide content has to report against. If any stream returns empty or errors, the skill records unavailable for that stream rather than synthesizing — the output template explicitly accommodates missing streams.

It then runs three Claude passes. Pass one is synthesis: Claude reads all four streams plus the previous QBR and produces an internal scratchpad of wins, losses, themes, and a usage-trend summary keyed to success-plan goals. Doing this as a dedicated pass matters because the next two passes need a single coherent picture; doing synthesis-and-slides in one pass produces uneven slide content because Claude over-weights whichever stream it read last.

Pass two takes the synthesis scratchpad plus the success plan and produces the open-risks table (red/yellow/green with a one-line mitigation per risk) and ranked expansion paths (signal: usage, persona, contract; confidence: high, medium, low). Risks and expansion get their own pass because they are the parts a CSM most often edits, so they get focused token budget and explicit reasoning.

Pass three is tone-match and slot mapping. Claude reads three voice-sample QBRs from the same CSM (or falls back to the sample in references/3-sample-output.md) and rewrites the synthesis plus risks plus expansion content into the team’s voice — neutral, data-led, no superlatives. Then it maps the rewritten content to the named slots from references/1-qbr-template-slots.md. Per-template slot mapping at the end means swapping templates does not require rerunning the upstream passes; the skill regenerates only the mapping step.

The output is a single Markdown file with one fenced block per slot, plus a one-page exec summary as a separate file. CSMs always edit before sending. The skill is a draft engine, not a publisher.

Cost reality

A full run costs roughly 25,000 to 40,000 input tokens and 4,000 to 7,000 output tokens on Claude Sonnet — call it 8 to 15 cents per QBR at current Sonnet pricing. The biggest input variable is Gong transcript volume: an account with twenty 60-minute calls in the quarter will land near the upper end; an account with three 30-minute calls lands near the lower end. The three-pass design adds modest overhead (each pass shares prefix context) but is worth it because the output is reliably edit-ready rather than rewrite-ready.

Wall-clock time is roughly two to four minutes per account, dominated by the Salesforce SOQL pull and the Gong transcript fetch in step one. The Claude passes run sequentially after the parallel pull and add maybe 60 to 90 seconds total.

A CSM prepping a QBR from scratch typically spends 90 to 180 minutes per account — pulling data, reading prior calls, structuring the narrative, drafting slide text. The skill takes that to 25 to 45 minutes (the editing pass), so the saving is roughly an hour per QBR. A CSM book of 30 accounts at one QBR per quarter is 30 hours saved per quarter per CSM.

Success metric

Track time from “deck opened” to “deck sent for internal review” per QBR. The skill should pull the median under 60 minutes inside the first quarter of use. Also track the number of QBRs flagged with SUCCESS_PLAN_STALE, GONG_COVERAGE_LOW, or TONE_REVIEW_NEEDED markers — those are leading indicators of upstream hygiene problems (success plans not being maintained, Gong coverage gaps, missing voice samples) that the skill surfaces by design. A healthy month sees those flags trending down.

A second metric worth watching: the proportion of generated content that survives the CSM edit pass. Aim for 70% or higher. Lower than that and the upstream data sources need work — usually success plans, sometimes Gong coverage. Higher than 90% and the CSM is probably under-editing; the skill is a draft, not a finished deck.

vs alternatives

vs Gainsight QBR templates. Gainsight ships standard QBR templates with auto-populated fields (health score, NPS, key metrics) and is the obvious default if you already pay for Gainsight. The trade-off: Gainsight templates are structured around health-scoring and CTA management, not around slide content. They surface fields; they do not write narrative. This skill writes the narrative. Use Gainsight for the operational scaffolding and this skill for the deck content; they are complementary, not competing. If you do not already pay for Gainsight, this skill plus Salesforce plus Gong covers most of the QBR use case at a fraction of the cost.

vs custom slide automation (e.g. a Python script that pulls Salesforce and pushes into Google Slides via the API). A homegrown script is faster for the literal data-into-slide step but produces sterile decks because it cannot synthesize Gong themes, write a usage-trend narrative, or rank expansion paths. You end up with a deck where every slide is a chart and a label, and the CSM still writes all the prose. This skill produces the prose. If you have a working slide-assembly script, point it at the slot-mapped Markdown this skill emits — that is the intended integration.

vs manual CSM-written prep. Manual prep produces the highest-quality QBRs because the CSM has context the skill cannot recover (the prior call where the champion vented about budget, the side conversation about the competitor pitch). The trade-off is the 90 to 180 minutes per account. Use manual prep for top-tier accounts and the skill for the long tail. The skill’s output is also a useful starting point even for top-tier accounts — the CSM edits more aggressively but starts further along.

Watch-outs

Usage-data drift. The usage warehouse view occasionally gets columns renamed or metrics redefined upstream by data engineering. The trend summary is then silently wrong. Guard: the skill validates the usage CSV header against references/1-qbr-template-slots.md and refuses to populate the usage trend slot if columns are missing or renamed. The deck-assembly script then renders the slide blank rather than misleading content.
Success-plan staleness. Success plans that have not been touched in 60-plus days produce confident-sounding but stale success_plan_progress slots. Guard: the skill checks the success-plan doc’s last_updated field; if older than 60 days, it prepends a SUCCESS_PLAN_STALE flag to that slot so the CSM has to acknowledge it before the slide is approved.
Tone mismatch with the customer. The default tone is the CSM team’s voice — that may not match how this specific customer is used to being talked to. An enterprise customer expects more formal phrasing than a startup. Guard: when voice_samples are passed, the tone-match pass weights customer-facing artifacts (prior QBRs the customer received) over internal docs. If no voice samples exist, the skill emits content in neutral register and flags TONE_REVIEW_NEEDED on the exec summary.
Gong coverage gaps. If fewer than three Gong calls were logged in the quarter, the themes section is thin and over-weights whichever calls did log. Guard: the skill counts Gong calls during the parallel pull; under three, the top_wins slot is generated from Salesforce signal only and prefixed with GONG_COVERAGE_LOW so the CSM knows to add color manually before the deck goes out.
Diffing to the wrong prior QBR. If last_qbr_path points at a deck from a different account or quarter, the “commitments then vs reality now” framing breaks silently. Guard: the synthesis pass extracts the account name and quarter label from the prior QBR’s title slide and halts if either does not match the inputs.

Stack

Salesforce — account, opportunity, and case history (SOQL via REST API)
Gong — call themes, executive quotes, competitor mentions (Gong API, last 90 days)
Claude — three-pass synthesis: synthesis, risks + expansion, tone-match + slot mapping (Sonnet recommended for cost; Opus only if voice match matters more than budget)
Notion / Salesforce custom object / Gainsight — success-plan storage (pick one)
Google Slides or PowerPoint — the deck template the slot-mapped Markdown injects into via your team’s deck-assembly script

Edit this page on GitHub

Files in this artifact

Download all (.zip)

---
name: qbr-prep
description: Generate a 70%-done QBR draft for a single customer account. Pulls Salesforce account history, Salesforce cases, Gong call themes from the last 90 days, and the success-plan doc, then runs three Claude passes (synthesis, risk + expansion, tone-match) to populate slot-mapped slide content for the team's QBR template.
---

# QBR prep

## When to invoke

When a CSM is opening a fresh QBR deck for a named account and wants a populated draft to edit, not a blank template. Take an account ID, the previous QBR's contents, the current quarter's usage data, and the active success-plan doc as inputs and produce slot-mapped slide content plus a one-page exec summary.

Do NOT invoke this skill for:

- Auto-publishing a QBR deck without CSM review. The skill is a draft engine, not a publisher.
- Customer-facing decks that have not been approved by the named account team. Every QBR goes through the AE/CSM-of-record before the customer sees it.
- Accounts with fewer than 30 days of usage data or no logged Gong calls in the quarter. The skill flags this and refuses rather than padding with generalities.
- Renewal forecasting or churn prediction. Use the churn-risk-summarizer skill for that — its rubric is calibrated for retention scoring, not deck content.

## Inputs

- Required: `account_id` — the Salesforce 18-character account ID
- Required: `quarter` — the QBR quarter label (e.g. `Q1-2026`)
- Required: `last_qbr_path` — local path or Google Drive URL to the previous QBR deck (the skill diffs commitments-then vs reality-now)
- Required: `success_plan_ref` — Notion page ID, Salesforce custom object ID, or Gainsight CTA reference for the active success plan
- Optional: `usage_data_path` — CSV or BigQuery table reference for product usage events. Defaults to the team's standard usage warehouse view if unset.
- Optional: `template_id` — slide template key from `references/qbr-template-slots.md`. Defaults to `standard-quarterly`.
- Optional: `voice_samples` — array of paths to 3 prior QBRs from the same CSM (used by the tone-match pass)

## Reference files

Always read these from `references/` before generating slide content. Without them, the skill's output is generic and the slot mapping will not match the team's actual deck.

- `references/qbr-template-slots.md` — the named placeholder slots in the team's QBR template, with the data shape each slot expects
- `references/success-plan-format.md` — the schema the skill expects for the success-plan doc, plus a fillable template the CSM team adopts
- `references/sample-output.md` — a worked example of populated slot content for a fictional account, used as a tone and structure anchor

## Method

Run these steps in order. Steps 1a-1d run in parallel because they hit independent systems and the bottleneck is API latency, not Claude tokens.

### 1. Parallel data pulls

a. **Salesforce account history.** Pull Account, Opportunity, and Case records for the past 12 months. Compute: ARR trajectory, expansion or contraction events, renewal date, NPS history if captured. Why parallel: Salesforce SOQL is the slowest of the four and gates the rest.

b. **Salesforce cases.** Pull all cases opened in the QBR quarter. Compute: ticket volume vs prior quarter, severity mix, median time-to-resolve, top three case categories.

c. **Gong call themes.** Pull all calls tagged to the account in the past 90 days. Why 90 days: anything older predates the quarter and biases the narrative backward. Surface raw transcripts plus call metadata (attendees, duration, recording URL).

d. **Success-plan doc.** Fetch the success plan referenced by `success_plan_ref`. Parse against the schema in `references/success-plan-format.md`. If the schema does not match, halt and surface the parse error rather than guessing.

If any of 1a-1d returns empty or errors, record `unavailable` for that stream rather than synthesizing. The output template explicitly accommodates missing streams.

### 2. Pass 1 — synthesis

Claude reads all four data streams and the previous QBR. It produces an internal scratchpad: top wins of the quarter, top losses, themes from Gong (what executives said about value, blockers raised, competitors mentioned), and a usage-trend summary keyed to the success-plan goals. Why a dedicated synthesis pass: the next two passes need a single coherent picture, not raw data. Doing synthesis-and-slides in one pass produces uneven slide content because Claude over-weights whichever stream it read last.

### 3. Pass 2 — risks and expansion paths

Claude takes the synthesis scratchpad plus the success plan and produces: open risks with severity (red, yellow, green) and a one-line mitigation per risk; proposed expansion paths ranked by signal strength (usage-led, persona-led, contract-led). Why a separate pass: risks and expansion are the parts a CSM most often edits, so they get focused token budget and explicit reasoning rather than being squeezed alongside slide-writing.

### 4. Pass 3 — tone-match and slot mapping

Claude reads the optional `voice_samples` (or falls back to `references/sample-output.md`) and rewrites the synthesis + risks + expansion content into the team's voice — neutral, data-led, no superlatives. Then it maps the rewritten content to the named slots from `references/qbr-template-slots.md`. Why per-template slot mapping: every team's QBR template differs (some have a "wins" slide, some fold wins into "value delivered"). Mapping at the end means swapping templates does not require rerunning the upstream passes.

### 5. Emit output

Write a single Markdown file with one section per slot. Each section is wrapped in a fenced block tagged with the slot name, so a downstream importer (the deck-assembly script the team runs separately) can split it back out. Also write a one-page exec summary as a separate file for the CSM to skim before opening the deck.

## Output format

````markdown
# QBR draft — {Account name} — {Quarter}

> Generated {YYYY-MM-DD HH:MM}. Status: {complete | partial: missing streams listed below}.
> Missing streams: {gong | success_plan | usage | none}

## Slot: `usage_trend`

```text
{Three-sentence summary of usage trajectory keyed to the prior quarter. Names the metric, the delta, and one likely cause from the synthesis pass.}
```

## Slot: `top_wins`

```text
- {Win 1 — outcome, metric, customer quote if available}
- {Win 2 — outcome, metric, customer quote if available}
- {Win 3 — outcome, metric, customer quote if available}
```

## Slot: `risk_summary`

```text
| Risk | Severity | Mitigation owner | Mitigation |
|---|---|---|---|
| {Risk 1} | red | {CSM | AE | Product} | {one line} |
| {Risk 2} | yellow | ... | ... |
```

## Slot: `success_plan_progress`

```text
| Goal | Target | Actual | Status |
|---|---|---|---|
| {Goal 1} | ... | ... | on-track |
| {Goal 2} | ... | ... | at-risk |
```

If success plan is `unavailable`, this slot emits the literal string `SUCCESS_PLAN_UNAVAILABLE` so the deck-assembly script can blank the slide rather than render stale content.

## Slot: `expansion_paths`

```text
1. **{Path 1}.** Signal: {usage | persona | contract}. Confidence: high | medium | low. Next step: {one sentence}.
2. **{Path 2}.** ...
3. **{Path 3}.** ...
```

## Slot: `exec_summary`

```text
{Five-bullet summary intended for the cover slide. Each bullet is one fact, no adjectives. Always ends with the proposed agenda for the live QBR call.}
```
````

## Watch-outs

- **Usage-data drift.** If the usage warehouse view changes shape (column rename, metric redefinition), the trend summary is silently wrong. Guard: the skill validates the usage CSV header against `references/qbr-template-slots.md` schema and refuses to populate `usage_trend` if columns are missing or renamed. The deck-assembly script then renders the slide blank rather than misleading content.
- **Success-plan staleness.** Success plans that have not been touched in over 60 days produce confident-sounding but stale `success_plan_progress` slots. Guard: the skill checks the success-plan doc's `last_updated` field; if older than 60 days, it prepends a `SUCCESS_PLAN_STALE` flag to that slot so the CSM has to acknowledge before the slide is approved.
- **Tone mismatch with the customer.** Default tone is the CSM team's voice — that may not match how this specific customer is used to being talked to (e.g. an enterprise customer expects more formal phrasing than a startup). Guard: when `voice_samples` are passed, the tone-match pass weights customer-facing artifacts (prior QBRs the customer received) over internal docs. If no voice samples, the skill emits content in neutral register and flags `TONE_REVIEW_NEEDED` on the exec summary.
- **Gong coverage gaps.** If fewer than three Gong calls were logged in the quarter, the themes section is thin and over-weights whichever calls did log. Guard: the skill counts Gong calls during the parallel pull; under three, the `top_wins` slot is generated from Salesforce signal only and prefixed with `GONG_COVERAGE_LOW` so the CSM knows to add color manually.
- **Diffing to the wrong prior QBR.** If `last_qbr_path` points at a deck from a different account or quarter, the "commitments then vs reality now" framing breaks silently. Guard: the synthesis pass extracts the account name and quarter label from the prior QBR's title slide and halts if they do not match the inputs.

# QBR template slots — TEMPLATE

> Replace this template's slot list with the actual named placeholders
> in your team's QBR deck (Google Slides or PowerPoint). The qbr-prep
> skill reads this file on every run; without your real slot map, the
> skill emits content keyed to slot names that your deck-assembly script
> cannot find.

## Template identity

- `template_id`: `standard-quarterly`
- `format`: `google-slides` | `pptx`
- `template_url_or_path`: `{Drive URL or local path}`
- `last_edited`: `{YYYY-MM-DD}`

## Slot manifest

Each row is one named placeholder in the deck. The skill emits one fenced block per slot in its output Markdown; the deck-assembly script splits on the slot name and injects.

| Slot name | Slide | Data shape | Required | Notes |
|---|---|---|---|---|
| `cover_account_name` | 1 | string | yes | Pulled from Salesforce Account.Name verbatim |
| `cover_quarter` | 1 | string | yes | Format `Q{N}-{YYYY}` |
| `exec_summary` | 2 | bullet list, 5 items | yes | One fact per bullet, no adjectives |
| `usage_trend` | 3 | paragraph + chart caption | yes | Three sentences max; chart is rendered separately by the deck-assembly script from the usage CSV |
| `top_wins` | 4 | bullet list, 3 items | yes | Each bullet has outcome, metric, optional customer quote |
| `risk_summary` | 5 | table | yes | Columns: Risk, Severity, Mitigation owner, Mitigation |
| `success_plan_progress` | 6 | table | conditional | Emits `SUCCESS_PLAN_UNAVAILABLE` if no plan; deck-assembly blanks the slide |
| `expansion_paths` | 7 | numbered list, 3 items | yes | Each item names signal type and confidence |
| `next_quarter_commitments` | 8 | bullet list | yes | Editable by CSM during live call; skill seeds with carry-over from success plan |
| `appendix_call_themes` | 9 | bullet list | optional | Surfaced from Gong synthesis; only included if Gong coverage was sufficient |

## Severity vocabulary

The `risk_summary` slot uses a fixed three-value scale. Other vocabularies break the deck-assembly script's color logic.

- `red` — active blocker, escalated to AE or product
- `yellow` — emerging concern, owner assigned, no escalation yet
- `green` — resolved within the quarter, listed for visibility

## Confidence vocabulary

The `expansion_paths` slot uses a fixed three-value scale.

- `high` — usage signal AND persona signal AND budget signal present
- `medium` — two of the three signals present
- `low` — one signal, included for the live QBR conversation rather than commitment

## Usage CSV schema

The `usage_trend` slot validates against this header before generating content. Missing columns cause the slot to render blank.

| Column | Type | Description |
|---|---|---|
| `event_date` | date | One row per day |
| `metric_name` | string | Constrained to the team's metric vocabulary (DAU, WAU, key-action count) |
| `metric_value` | number | The value for that metric on that day |
| `seat_count` | integer | Active seats on that day |
| `feature_area` | string | Category for grouping in the trend narrative |

# Success-plan format — TEMPLATE

> Replace this template's contents with your team's actual success-plan
> schema. The qbr-prep skill parses the success-plan doc against this
> shape; if the parse fails, the skill halts rather than guessing.
> Adopt this same template across the CSM team so every account's plan
> reads the same way.

## Storage location

Pick one and stick to it. Mixing storage breaks the skill's `success_plan_ref` resolver.

- Notion: one page per account, parented under "Customer Success Plans"
- Salesforce: custom object `Success_Plan__c`, lookup from Account
- Gainsight: CTA of type `Success Plan`, one open at a time per account

## Required fields

The skill expects these fields, in this order. Optional fields are tolerated and ignored.

| Field | Type | Description |
|---|---|---|
| `account_id` | string | Salesforce 18-character account ID — must match the skill's input |
| `plan_owner` | string | CSM email |
| `quarter_started` | string | Quarter label, e.g. `Q4-2025` |
| `last_updated` | date | The skill flags `SUCCESS_PLAN_STALE` if older than 60 days |
| `business_outcomes` | list of objects | The customer's stated outcomes; see schema below |
| `goals` | list of objects | The measurable goals laid against each outcome; see schema below |
| `risks_known` | list of objects | Risks the CSM has already logged outside the QBR cycle |
| `next_review_date` | date | When this plan is next scheduled for refresh |

## `business_outcomes` schema

Each outcome answers "what is the customer trying to achieve in their business?"

```yaml
- outcome_id: BO-1
  statement: "Reduce time-to-onboard new sales reps from 8 weeks to 4 weeks"
  stakeholder: "VP Revenue Operations"
  priority: critical | high | medium
```

## `goals` schema

Each goal is the measurable thing the product is supposed to move. Goals are what the `success_plan_progress` slot reports against.

```yaml
- goal_id: G-1
  outcome_id: BO-1
  metric: "Average rep time-to-first-deal"
  baseline: 56  # days, recorded at plan start
  target: 28
  current: 41   # updated quarterly by the CSM
  status: on-track | at-risk | off-track | achieved | abandoned
  evidence_url: "{link to dashboard or report}"
```

## `risks_known` schema

The skill cross-references these against the synthesis pass. Risks logged here that are still active become `yellow` or `red` rows in `risk_summary`.

```yaml
- risk_id: R-1
  description: "Champion left for new role; replacement not yet identified"
  severity: red | yellow | green
  owner: csm | ae | product | customer
  logged_date: 2026-01-15
  mitigation: "AE has scheduled intro with VP RevOps for replacement champion identification"
```

## Worked example

```yaml
account_id: "0014x000ABCDEFGHIJ"
plan_owner: "alex.csm@yourco.com"
quarter_started: "Q4-2025"
last_updated: 2026-04-12
next_review_date: 2026-07-15

business_outcomes:
  - outcome_id: BO-1
    statement: "Reduce time-to-onboard new sales reps from 8 weeks to 4 weeks"
    stakeholder: "VP Revenue Operations"
    priority: critical

goals:
  - goal_id: G-1
    outcome_id: BO-1
    metric: "Average rep time-to-first-deal (days)"
    baseline: 56
    target: 28
    current: 41
    status: at-risk
    evidence_url: "https://lookerstudio.example.com/reports/onboarding-tti"

risks_known:
  - risk_id: R-1
    description: "VP RevOps champion took new role at peer company in March"
    severity: red
    owner: ae
    logged_date: 2026-03-22
    mitigation: "AE working through CFO intro for replacement champion"
```

# Sample output — fictional account

> A worked example the qbr-prep skill anchors against for tone and
> structure. The account name, metrics, and quotes here are fabricated.
> Replace this file with three to five real (anonymized) prior QBRs from
> your CSM team to give the tone-match pass real material to mimic.

# QBR draft — Northwind Logistics — Q1-2026

> Generated 2026-04-30 14:22. Status: complete.
> Missing streams: none.

## Slot: `cover_account_name`

```text
Northwind Logistics
```

## Slot: `cover_quarter`

```text
Q1-2026
```

## Slot: `exec_summary`

```text
- ARR held flat at $480k through Q1; renewal scheduled for Q3-2026.
- Active seats grew from 84 to 112 (33%); WAU grew from 61 to 89 (46%).
- Two of three success-plan goals on-track; one (rep onboarding time) at-risk.
- One open red risk: champion transition in RevOps; AE owns replacement intro.
- Proposed agenda: usage trends, success-plan review, expansion conversation around the warehouse-management module.
```

## Slot: `usage_trend`

```text
Active seats grew 33% quarter-over-quarter (84 to 112) while weekly active usage grew 46% (61 WAU to 89 WAU), indicating per-seat engagement is rising rather than diluting. The growth concentrated in the dispatch and routing feature areas, which together accounted for 71% of key-action volume in March. The reporting feature area remains under-used relative to onboarded seats — a likely topic for the live QBR.
```

## Slot: `top_wins`

```text
- Cut average dispatch latency from 9 minutes to 4 minutes after enabling automated route assignment in February ("This freed an entire shift's worth of dispatcher time" — Ops Manager, Gong call 2026-03-12).
- Closed integration backlog with the warehouse system; 12 of 12 facilities now reporting through the unified dashboard.
- Onboarded the second business unit (Eastern region) ahead of plan; 28 new seats activated in March vs Q2 target of 20.
```

## Slot: `risk_summary`

```text
| Risk | Severity | Mitigation owner | Mitigation |
|---|---|---|---|
| RevOps champion took new role; replacement not yet identified | red | ae | CFO intro scheduled for week of May 6 |
| Rep onboarding time-to-first-deal trending 41 days vs 28-day target | yellow | csm | Targeted enablement session booked for new-rep cohort May 14 |
| Reporting feature adoption flat at 22% of seats | yellow | csm | Office-hours session scheduled June; track adoption pre/post |
```

## Slot: `success_plan_progress`

```text
| Goal | Target | Actual | Status |
|---|---|---|---|
| Reduce rep time-to-first-deal | 28 days | 41 days | at-risk |
| Cut dispatch latency | 5 min | 4 min | achieved |
| Unify reporting across 12 facilities | 12/12 | 12/12 | achieved |
```

## Slot: `expansion_paths`

```text
1. **Warehouse-management module.** Signal: usage. Confidence: high. Three Gong calls in March surfaced unprompted asks for the WMS add-on; Eastern region rollout creates natural anchor. Next step: AE to scope WMS pilot with VP Operations during the live QBR.
2. **Premium support tier.** Signal: persona. Confidence: medium. Champion transition makes premium tier (named CSM, 4-hour SLA) a continuity story. Next step: surface tier comparison in the wrap-up if champion replacement question stays open.
3. **Multi-year renewal at Q3.** Signal: contract. Confidence: medium. Two-year commit unlocks 12% pricing concession; usage growth supports the math. Next step: position with CFO during champion-replacement intro, not in the QBR itself.
```

## Slot: `next_quarter_commitments`

```text
- Drive rep onboarding goal back to on-track via May 14 enablement session
- Confirm replacement RevOps champion by end of May
- Run reporting-feature office hours and track adoption delta through June
- Scope WMS pilot with VP Operations and surface a written proposal by July 1
```

## Slot: `appendix_call_themes`

```text
- "We are getting more out of dispatch than we expected" (Ops Manager, 2026-03-12)
- Three calls surfaced WMS interest unprompted (2026-02-08, 2026-03-19, 2026-03-27)
- One call mentioned competitor evaluation in passing (2026-02-22) — context was board pressure, not active eval; AE to confirm
```