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:
| Criterion | 1 | 2 | 3 |
|---|---|---|---|
| How often it runs | Quarterly or less | Monthly | Weekly or more |
| Cost when it breaks | An annoyance | Delays a report or a campaign | Pipeline, revenue or customer data is affected |
| People who can run it today | Three or more | Two | One |
| How stable it is | Changes every week | Changes every quarter | Unchanged 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:
| Field | What goes in it |
|---|---|
| Purpose | The output, in one sentence, and who uses it |
| Trigger | When to run it (schedule or event) |
| Owner and backup | Named people, not teams |
| Inputs | Data, access and tools needed before step 1. Never passwords; point to where access is granted |
| Steps | Numbered, one action per step, each with a screenshot or a timestamp link to the recording |
| Checks | How you know each critical step worked, and how you check the final output |
| Exceptions | Known edge cases and what to do about each |
| Escalation | Who to ask, and how |
| Last tested | Date, and the name of the person who passed the test |
| Change log | Date, 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:
| Trigger | Action |
|---|---|
| The process or a tool in it changes | Update the page as part of the same change |
| Someone asks a question the page should have answered | Add the answer within a week |
| The owner changes | The new owner runs the Level 3 test before taking over |
| A quarter passes with no update | The 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
| Aspect | Traditional | Our Approach |
|---|---|---|
| When the owner is away | The process waits, or someone guesses | A tested backup runs it |
| When the owner resigns | Capture happens in the notice period, if at all | The page already exists and has passed a test |
| Onboarding a new operator | Shadowing for weeks, with gaps | They run the page, ask questions, and the page improves |
| Finding errors | Nobody else knows what "right" looks like | The checks are written down |
| Changing the process | The change lives in one head | The change log shows what changed and why |
| Handing work to AI agents or automation | Nothing to hand over | The steps and checks are the spec |
| Valuation and due diligence | One person is a single point of failure | The process belongs to the company |
Tools & Data
Required (Minimum Viable)
Use existing tools where they fit. Current vendor plans are linked in Sources.
Recommended (Full System)
Competitor Landscape
| Tool | Approach | Best For | Limitation |
|---|---|---|---|
| Click-capture SOP tools (e.g. Scribe, Tango) | Turn a captured process into a step-by-step guide | Partially: speeds up Level 2 | Good 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 it | Partially: the recording step | Captures 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 knowledge | Partially: the Level 4 home | Provides the home for the page. The team still needs to run the colleague test and assign an owner |
| Consultant-led process mapping | Map every revenue process end to end | Partially: useful for inventory, weak on testing and upkeep | Agree a bounded scope, a colleague test, and ownership after the project |
| DIY: record, AI draft, colleague test, named owner | One process at a time, tested before it counts | Yes: this is the Mazorda approach | Costs operator and tester time; the test is how you know the knowledge moved |
Industry Benchmarks
| Metric | Benchmark | Source |
|---|---|---|
| Median US employee tenure | 4.1 years (January 2026); 3.0 years for ages 25-34 | US Bureau of Labor Statistics, 2026. Confirmed source; US wage and salary workers, not a departure forecast |
| Cost to replace an employee | Historical estimate of half to twice annual salary | Gallup, 2019. Confirmed source; older than 12 months, not a current GTM benchmark |
| Average B2B account executive ramp time | 6.2 months in a survey of 158 B2B companies | The Bridge Group, 2026. Confirmed source; sales role, not RevOps or documentation |
| Knowledge capture from departing retirees | 8% always; 16% never attempted it | APQC with eGain, 2025. Confirmed source; sponsored, retirement context, older than 12 months |
Team Responsibilities
| Role | Responsibility |
|---|---|
| Founder or RevOps lead | Picks the first process from the Level 1 scores, protects the operator's time for the recording, and signs off the pass |
| Operator | Runs 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 |
| Tester | A colleague who has never run the process; runs it from the page and logs every question |
| Page owner | Keeps the page current against the review triggers; can be the operator once a backup has passed the test |
Failure Patterns
| Pattern | What Happens | Why | Prevention |
|---|---|---|---|
| Written from memory | The page skips the steps the operator does without thinking, and the first real run fails | Nobody watched the process run | Record a live run (Level 2) before writing a word |
| Never tested | The page looks complete, then fails the first time the operator is away | Writing it down felt like the finish line | Nothing counts as done until a colleague passes Level 3 |
| The wall of text | Nobody reads it, so the team keeps messaging the operator | Background and history buried the steps | One page, fixed fields, numbered steps, with background kept to the Purpose field |
| The orphaned page | The tool changes, the page doesn't, and the next person follows old steps | No owner, no review trigger | Named owner and backup, review triggers, "Last tested" date at the top |
| Captured at exit | Two weeks of rushed handover notes from someone who has already left in their head | Nobody starts until someone resigns | Start with the highest-scoring process now, while the operator is engaged |
| Everything at once | A documentation project that stalls before the first page passes a test | The team tried to capture every process in one push | One 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
Sources
- 1. : https://www.bls.gov/news.release/tenure.nr0.htm
- 2. : https://www.gallup.com/workplace/247391/fixable-problem-costs-businesses-trillion.aspx
- 3. : https://www.bridgegroupinc.com/research/2026-ae-models-motions-metrics
- 4. : https://hd.egain.com/wp-content/surveys/APQC_Report-Great_Retirement_Survey_Summary.pdf
- 5. : https://www.pedowitzgroup.com/document-revenue-processes-clarity-speed-compliance
- 6. : https://www.loom.com/pricing
- 7. : https://scribe.com/pricing
- 8. : https://www.notion.com/pricing
- 9. : https://www.atlassian.com/software/confluence/pricing
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
Put this playbook to work
Need help adapting this workflow to your team? Explore the relevant implementation services.
- GTM Engineering
Connect this workflow to your data, tools, and revenue signals.
- RevOps & CRM Automation
Implement the data quality, scoring, and CRM workflows needed to run this play.