Skip to content

Codify your GTM playbook before your best operator leaves

Capture one operator’s recurring GTM process, turn it into a usable page, and test whether a colleague can run it. Assign an owner and a tested backup.

Goal: Make one recurring GTM process usable by a colleague through a documented and tested handover.

Complexity

Low

Tools

6

Context

The Problem

When only one person can run a recurring GTM process, a colleague has no tested way to take over. The rest of the team finds out what it involves on the day that person is off sick, on leave or serving notice.

  • Lead routing rules nobody else understands stop matching new forms, and inbound leads sit unassigned
  • The weekly pipeline report goes out late or wrong, and the board pack inherits the error
  • A CRM enrichment or sync job fails silently, and nobody knows what "normal" output looks like
  • Handover happens in a two-week notice period, from someone whose attention is already on the next job

Why it matters: Gallup estimated in 2019 that replacing an employee could cost between half and twice their annual salary. This is historical context, not a current GTM-specific cost benchmark. In APQC's 2025 research with eGain, 8% of respondents said they always captured knowledge from departing retirees, and 16% never attempted it. The survey covered 1,000 organisations and retirement-related knowledge capture, not GTM teams specifically.

Resolution

The Solution

Start with one process. Get it out of one person's head, onto a page, and through a test a colleague can pass. Then give the page an owner. Repeat for the next process.

Level 1: Pick the first process (Week 1)

List every recurring GTM process that only one person can run today. Typical candidates: lead routing rules, the weekly pipeline report, a CRM enrichment run, campaign launch QA, renewal alerts, the attribution report, new-hire tool access.

Use this suggested scoring rule, from 1 to 3, on four criteria:

Criterion123
How often it runsQuarterly or lessMonthlyWeekly or more
Cost when it breaksAn annoyanceDelays a report or a campaignPipeline, revenue or customer data is affected
People who can run it todayThree or moreTwoOne
How stable it isChanges every weekChanges every quarterUnchanged for three months or more

The highest total goes first. On a tie, pick the one that costs most when it breaks. As a gut check, ask which process would hurt most if its owner were away next week.

Before moving on, write the process's name, the event that starts it and the output that ends it. As a scoping rule, aim for a walkthrough of about ten minutes. If it takes longer, look for a smaller process to capture first.

Level 2: Record it once, then write it down (Week 1-2)

Record the real run. The operator does the task live, at normal pace, on a day it actually needs doing. They say out loud what they are doing, why, and what they check before moving on. Don't script it from memory; scripted runs skip the clicks people do on autopilot.

Straight after, spend 15 minutes on what the recording missed, with three questions: What goes wrong with this, and what do you do? What do you check that isn't on screen? Who do you ask when you're stuck?

Turn the recording and the answers into one page with these fields:

FieldWhat goes in it
PurposeThe output, in one sentence, and who uses it
TriggerWhen to run it (schedule or event)
Owner and backupNamed people, not teams
InputsData, access and tools needed before step 1. Never passwords; point to where access is granted
StepsNumbered, one action per step, each with a screenshot or a timestamp link to the recording
ChecksHow you know each critical step worked, and how you check the final output
ExceptionsKnown edge cases and what to do about each
EscalationWho to ask, and how
Last testedDate, and the name of the person who passed the test
Change logDate, what changed, who changed it

An AI assistant can turn the recording's transcript into a first draft in minutes. The operator then reads it for the steps the transcript can't see: permissions, file locations, settings changed in another tab.

Worked example: how Mazorda runs its own Hub. Since January, Mazorda has kept its working knowledge in one shared folder, the Hub: playbooks, business context, drafts, decisions and reusable AI skills. At the start of a task, we point our AI assistant at the relevant files. At the end, we save the useful work back, including what the finished deliverable leaves out: why we rejected an audience, which number still needs checking, what was agreed, where to pick up tomorrow.

The Hub example informs two parts of this method. First, the folder needs looking after: we have caught old instructions contradicting newer ones, and keeping work in files makes those contradictions visible without fixing them. That is why Level 4 gives every page an owner. Second, our suggested handover exercise follows Level 3. Ask a colleague to pick up an active task from the folder alone, with no chat history or call, and record their questions. This describes the exercise, not a measured result.

Level 3: The test (Week 2-3)

Give the page to a colleague who has never run the process. They run it for real, from the page alone. The operator is in the room but stays silent, or reviews the output afterwards.

Log every question the tester asks and every place they stop, and treat each one as a fix to the page.

The tester passes when they finish without asking anything and their output matches the operator's. Pedowitz Group sets the same bar: if a trained peer can't run the process from the page without asking questions, the documentation isn't done.

Fix the page, then test again, with a different colleague if you can. Record the pass in the "Last tested" field.

Level 4: Where it lives and who keeps it current (ongoing)

Put the page where the team already works every day, and link to it from the tool where the process runs: the CRM workflow description, the task template, the report header. One process, one page. Link to other pages instead of copying them in.

Every page has a named owner and a backup. The backup has passed the Level 3 test. The owner can be the original operator, as long as someone else can run it.

Update the page when any of these happen:

TriggerAction
The process or a tool in it changesUpdate the page as part of the same change
Someone asks a question the page should have answeredAdd the answer within a week
The owner changesThe new owner runs the Level 3 test before taking over
A quarter passes with no updateThe owner re-runs the process from the page and confirms it still works

Show the "Last tested" date at the top of every page. Treat anything older than one quarter as unverified until someone re-tests it.

Pilot targets and planning estimate

Zero at sign-off. Count them on the first test as your baseline

Questions the tester asks during the Level 3 test

2-3 weeks (Estimate: Mazorda planning figure, not a benchmark)

Elapsed time to codify the first process

Falls by one for every process taken through all four levels

GTM processes only one person can run

100% of codified pages

Codified pages with a "Last tested" date inside the last quarter

At least one per codified process

Named backups who have passed the test

Knowledge in one person’s head vs. a tested process

When the owner is away

Traditional

The process waits, or someone guesses

Our Approach

A tested backup runs it

When the owner resigns

Traditional

Capture happens in the notice period, if at all

Our Approach

The page already exists and has passed a test

Onboarding a new operator

Traditional

Shadowing for weeks, with gaps

Our Approach

They run the page, ask questions, and the page improves

Finding errors

Traditional

Nobody else knows what "right" looks like

Our Approach

The checks are written down

Changing the process

Traditional

The change lives in one head

Our Approach

The change log shows what changed and why

Handing work to AI agents or automation

Traditional

Nothing to hand over

Our Approach

The steps and checks are the spec

Valuation and due diligence

Traditional

One person is a single point of failure

Our Approach

The process belongs to the company

Tools & Data

Required (Minimum Viable)

Use existing tools where they fit. Current vendor plans are linked in Sources.

A screen recorder that produces a transcript : captures the live run and the operator's narration for Level 2. Your video-call tool's recording often does the job. Example: Loom. Its Starter plan has a five-minute recording limit, so use a suitable paid plan or your existing recorder for a longer walkthrough.
A shared home the team already opens every day : holds the one-page process and its "Last tested" date. A shared drive folder works. Examples: Notion or Confluence. Check the current plans for your team size.
An AI assistant : turns the transcript into a first draft. Use whichever assistant your team already pays for.

Recommended (Full System)

A click-capture tool : records each click and screenshot automatically, which speeds up the Steps field for software-heavy processes. Example: Scribe. Review its current plans and capture features before choosing a tier.
Version history : shows what changed on the page and when. Git, or the page history in your doc tool.
A reminder in your task tool : fires the quarterly review trigger for each page owner.

Competitor Landscape

ToolApproachBest ForLimitation
Click-capture SOP tools (e.g. Scribe, Tango)Turn a captured process into a step-by-step guidePartially: speeds up Level 2Good at clicks and screenshots. Review the why, exceptions, and judgement calls separately. A captured guide still needs the colleague test and an owner
Async video (e.g. Loom)Record your screen and share itPartially: the recording stepCaptures narration well. A video is hard to scan and hard to follow mid-task, so use it as raw material for the page
Wikis and knowledge bases (e.g. Notion, Confluence)One place for team knowledgePartially: the Level 4 homeProvides the home for the page. The team still needs to run the colleague test and assign an owner
Consultant-led process mappingMap every revenue process end to endPartially: useful for inventory, weak on testing and upkeepAgree a bounded scope, a colleague test, and ownership after the project
DIY: record, AI draft, colleague test, named ownerOne process at a time, tested before it countsYes: this is the Mazorda approachCosts operator and tester time; the test is how you know the knowledge moved

Industry Benchmarks

MetricBenchmarkSource
Median US employee tenure4.1 years (January 2026); 3.0 years for ages 25-34US Bureau of Labor Statistics, 2026. Confirmed source; US wage and salary workers, not a departure forecast
Cost to replace an employeeHistorical estimate of half to twice annual salaryGallup, 2019. Confirmed source; older than 12 months, not a current GTM benchmark
Average B2B account executive ramp time6.2 months in a survey of 158 B2B companiesThe Bridge Group, 2026. Confirmed source; sales role, not RevOps or documentation
Knowledge capture from departing retirees8% always; 16% never attempted itAPQC with eGain, 2025. Confirmed source; sponsored, retirement context, older than 12 months

Team Responsibilities

RoleResponsibility
Founder or RevOps leadPicks the first process from the Level 1 scores, protects the operator's time for the recording, and signs off the pass
OperatorRuns the recorded session, answers the follow-up questions, and reviews the draft for missing steps
Writer (often the RevOps lead, with an AI assistant)Turns the recording into the one-page draft and makes every fix the test turns up
TesterA colleague who has never run the process; runs it from the page and logs every question
Page ownerKeeps the page current against the review triggers; can be the operator once a backup has passed the test

Failure Patterns

PatternWhat HappensWhyPrevention
Written from memoryThe page skips the steps the operator does without thinking, and the first real run failsNobody watched the process runRecord a live run (Level 2) before writing a word
Never testedThe page looks complete, then fails the first time the operator is awayWriting it down felt like the finish lineNothing counts as done until a colleague passes Level 3
The wall of textNobody reads it, so the team keeps messaging the operatorBackground and history buried the stepsOne page, fixed fields, numbered steps, with background kept to the Purpose field
The orphaned pageThe tool changes, the page doesn't, and the next person follows old stepsNo owner, no review triggerNamed owner and backup, review triggers, "Last tested" date at the top
Captured at exitTwo weeks of rushed handover notes from someone who has already left in their headNobody starts until someone resignsStart with the highest-scoring process now, while the operator is engaged
Everything at onceA documentation project that stalls before the first page passes a testThe team tried to capture every process in one pushOne process through all four levels before starting the second

ICP Fit Notes

Best fit

  • •Series A to C B2B SaaS, roughly $2M to $50M ARR, where RevOps or marketing operations is one or two people
  • •Founder-led teams hiring their first operations person or their first account executives, who will need to run processes the founder built
  • •Companies preparing to raise or sell, where diligence will ask what happens if one person leaves

Also works for

  • •Agencies and consultancies handing work to a client team. It works, but the client's tester wasn't in the room when the process was built, so expect more fixes at Level 3
  • •Larger companies, one team at a time. The method holds; the inventory in Level 1 gets long, so score within a single team first

Insight: Codify while the operator is engaged and busy. Someone serving notice tends to walk you through the normal run and skip the exceptions.

Implementation Checklist

Phase 1: Choose (Week 1)

  • List every recurring GTM process only one person can run today
  • Score each one on the four Level 1 criteria
  • Pick the top process and write its trigger and its output
  • Book a recording slot with the operator on a day the process actually runs

Phase 2: Capture (Week 1-2)

  • Record the live run, with the operator narrating the why
  • Run the 15-minute follow-up on exceptions, hidden checks and who to ask
  • Draft the one-page document using the Level 2 fields
  • Operator reviews the draft for missing steps

Phase 3: Test (Week 2-3)

  • A colleague who has never run it runs it from the page
  • Log every question and stop; fix the page for each one
  • Re-test until the tester finishes with no questions and a matching output
  • Record the pass date and tester in "Last tested"

Phase 4: Own (ongoing)

  • Publish the page where the team works and link it from the tool where the process runs
  • Name the owner and the backup
  • Set the quarterly review reminder
  • Start Phase 1 for the next process on the list

FAQ

When NOT to Use

  • •**The process changes every week:** A page that is out of date by Friday does more harm than none. Stabilise the process first, or capture only the parts that don't change, such as the checks and the escalation path.
  • •**The process is broken:** Writing down a bad process makes it permanent. If the operator's own run produces errors or workarounds, fix the process first and record the fixed version.
  • •**You are replacing the operator with a hire:** Codifying helps the hire ramp, but it won't recruit them. If the real gap is hiring and moving work in-house, see [Team Building & Knowledge Transfer](/playbooks/team-building-and-knowledge-transfer) (play_019).
  • •**The knowledge is a relationship:** A page can't transfer a major account's trust in one person. Use this playbook for the steps around the relationship, and plan introductions and joint calls for the relationship itself.
  • •**It runs once a year:** For an infrequent task, start with a short checklist and review whether the full capture and test are warranted. A short checklist and a calendar reminder are enough until it runs more often.
  • •**There is nobody to test it:** Without a second person, Level 3 can't happen and the page stays untested. Solve the single-person team problem first; this playbook assumes at least one colleague who can run the page.

Tools & Tech

A screen recorder that produces a transcript
A shared home the team already opens every day
An AI assistant
A click-capture tool
+2
Take the GTM Readiness Score

Put this playbook to work

Need help adapting this workflow to your team? Explore the relevant implementation services.