Skip to main content
The first 30–90 days of a customer’s relationship with your product is where retention gets decided. Customers who experience smooth onboarding — questions answered, configurations completed, follow-ups honored, value realized on the timeline that was promised — become loyal customers who stay for years. Customers who experience rough onboarding — questions that don’t get answered, configurations that drift, follow-ups that get forgotten — churn within 6–18 months regardless of how strong the product is. The work that determines which experience the customer has is largely done by trainers, implementation engineers, EICs, and CSMs running training sessions. They run six to ten sessions per week, sometimes more. Each session produces dozens of small “we’ll come back to that” moments — a configuration question that needs a documentation lookup, a feature request that should go to product, a workflow the customer wants to confirm with their internal team, a follow-up the trainer promised. By end of day, the trainer has accumulated 50+ small items across 6–8 sessions. Half have already started decaying in memory. The follow-up email captures the most prominent items; the rest live in a notebook, a Slack thread, a hastily-jotted post-it, or nowhere at all. The customer waits for follow-ups that don’t arrive. The internal queue of items needing engineering or documentation work gets fragmented across many trainers, never reaching the people who could act on it. This guide is a specific instance of the workflows pattern, applied to the highest-volume specialized workflow most CS organizations run. It is the specialized implementation-context version of the action items workflow — that workflow handles general meeting commitments; this one is shaped for the rigid categorization and high session volume of customer implementation work.

Foundation

Identify which sessions feed the workflow

Not every customer touchpoint is a training session. The candidates: The workflow’s value scales with how consistently it runs on every session.

Establish your categorization model

The single most important decision in this workflow. The categories determine what the artifact looks like and what makes it useful. A starting model that covers most implementation contexts: The discipline this categorization imposes is what makes the artifact useful. A flat list of items requires the trainer to mentally sort every time they read it. A categorized list is scannable — the trainer reads only their own items, the customer reads only theirs, engineering reads only the relevant categories.

The “only unresolved” discipline

This is the operating principle that separates this workflow from generic meeting recaps:
Capture only unresolved insights, feedback, requests, or concerns that require action or follow-up. Do not log questions that were fully answered during the session.
A trainer running 6 sessions a day cannot read 6 full session recaps. They can read 6 “what’s still open” lists. The template enforces this. Items raised and resolved during the session do not enter the artifact. The artifact is a queue of work, not a record of conversation. The conversation record lives in the Earmark transcript; the work queue lives in the artifact. This is the single biggest behavioral difference from generic meeting recaps. Internalize it before standing the workflow up.

Destinations

The artifact has multiple audiences; the destinations vary: The workflow’s value scales with how cleanly these handoffs work. An item categorized correctly but routed nowhere is functionally the same as an item not captured. Wire the destinations before standing the workflow up.

Ownership

The trainer who ran the session owns the cleanup and routing. Always. For sessions with multiple trainers from your side (a CSM, an EIC, and a solutions engineer on the same call), one of them owns the artifact — usually the relationship lead. For team-wide pattern detection, the implementation team lead or training lead owns the cross-customer synthesis cadence.

The four templates

Template A — Per-session training capture

The workhorse. Runs on every training session.
Three things in this template are load-bearing. The “only unresolved” rule. Items raised and resolved during the session do not enter the artifact. This is the discipline that makes the workflow usable at six sessions a day. A flat list of everything would be ignored; a queue of what’s still open gets used. Rigid categorization with no catch-all. Items get sorted into specific buckets. If an item doesn’t fit a category, the categories need updating, not a catch-all. The rigidity is what makes the artifact scannable and routable. The customer-facing email generated alongside the internal artifact. Same source; different audiences; both produced in one pass. The trainer doesn’t write the email separately — the workflow produces it together with the internal queue. The “what was resolved in this session” section is counterintuitive. It lists what NOT to include in the queue. Its purpose is to confirm the trainer’s mental model: these things came up, they were handled, they don’t need follow-up. Helps the trainer trust that the workflow isn’t losing items.

Template B — Customer-facing follow-up email

For trainers who want the customer email as a standalone artifact rather than as a section of Template A. Same content, slightly warmer phrasing.
The structure separates customer-owned items from trainer-owned items deliberately. Customers see what they need to do; they also see what’s being done for them. Both sides know what’s coming.

Template C — Customer implementation milestone synthesis

For looking at one customer across all their training sessions. Run before milestones (pre-go-live, end-of-onboarding, mid-implementation review) or whenever the team needs a snapshot of where this customer stands.
This template is what the implementation team takes into pipeline reviews, milestone gates, and renewal conversations. It also feeds customer-facing implementation review meetings.

Template D — Cross-customer pattern detection

For the implementation team lead. Run quarterly (or monthly for higher-volume teams) across all customer implementation artifacts to surface patterns. This template uses the standard multi-meeting workaround — paste relevant artifacts from many customer sessions into Customize context, then run the template.
This template is what transforms the training function from reactive to systematic. The implementation team starts shaping the product, documentation, and training process based on real aggregate signal — not on which customer complained loudest in the last QBR.

Save them as workspace templates

1

Start with Template A

The per-session capture is the workhorse. Save it first with your team’s categorization customized. The other templates can be added as you encounter their use cases.
2

Embed your categorization

The starting categorization in the Foundation section is generic; adapt it to your team’s actual implementation model. If your trainers track different categories or your destinations have different intake structures, build that into the template.
3

Save with Workspace visibility

Training capture is a team standard, especially for teams with multiple trainers. Workspace visibility means every trainer produces artifacts in the same shape. See Custom templates.

Running the workflow on a single session

1

Pre-seed every training session

For trainers running multiple sessions per day, the template attachment becomes a recurring habit. Some teams set up the template as the default for the entire training calendar series; others attach per-session. Either way, set it before the session starts so the artifact is ready when the session ends. See Before a meeting.
2

State the right things during the session

A few habits make the categorization noticeably more accurate:
  • Name the category out loud when you commit to follow-ups. “Let me look into that configuration question and get back to you” — the words “configuration” plus “let me look into” plus “get back to you” give the model a clean signal.
  • Confirm ownership explicitly. “I’ll send you the documentation by Thursday” beats “we’ll figure out the documentation.”
  • Distinguish resolved from unresolved out loud. “OK, so we’ve handled the user permissions question. Moving on to…” — this verbal marker tells the model the previous item is resolved.
  • Flag what’s blocking what. “We can’t move forward on training until you’ve got your data imported” — signals dependency.
3

The three-to-five-minute curation pass

Fast enough to fit between back-to-back sessions:
  • Read the headline. Does it reflect where the implementation actually stands?
  • Verify the categorization. Items in the wrong category cause downstream confusion. Quick scan; fix anything that’s clearly miscategorized.
  • Confirm “resolved during session” items are actually resolved. The model occasionally promotes a resolved item into the open queue. Move anything still open back into the queue.
  • Sharpen vague items. “Customer to confirm something with their team” is too vague. Sharpen to “Customer to confirm timeline with operations team by Friday.”
  • Confirm the customer-facing email reads like you wrote it. Adjust tone, add personal touches, verify customer name and stakeholder names are correct.
Skipping this pass means the model’s output ships unverified, which erodes trust quickly.
4

Route to destinations same-day

Same-day, every time:
  • Send the customer-facing email. Within hours of the session.
  • Update the customer’s implementation tracking record. New items added; resolved items marked.
  • Push trainer follow-ups to your task system. Don’t trust the artifact alone; put your action items where you actually plan your day.
  • File feature requests in product’s intake system. Use the meeting-to-tickets workflow for engineering work.
  • Log documentation gaps in the docs team’s intake.
  • Update CSM platform / CRM with implementation status changes.
The routing step is where the workflow’s value gets realized. Items captured but not routed are functionally the same as items not captured.
5

Brief the next session

If another team member runs the next session with this customer, share the artifact with them ahead of their session. They start with the customer’s open items already in their head; the customer experiences continuity.
The “only unresolved” discipline is the discipline. Items that came up and were resolved during the session don’t enter the queue. The artifact is a queue of work, not a transcript of conversation. The conversation lives in the Earmark recording; the queue lives in the artifact.

The customer journey: cross-session synthesis per customer

Single sessions are tactical. The cross-session view per customer is what the implementation team needs to manage the customer’s overall trajectory. This synthesis uses the standard cross-meeting workaround — paste the relevant session artifacts for one customer into Customize context, run Template C against the assembled corpus. The weekly customer health check. For each active customer implementation, run Template C weekly. The 15-minute output shows items still open and aging, implementation health read, risks and wins, recommendation for next session. This is the artifact the implementation manager reviews in their weekly portfolio walkthrough. Pre-milestone synthesis. Before any implementation milestone (kickoff complete, configuration phase complete, pre-go-live readiness, go-live, end of onboarding), run Template C and validate: Are all critical items for this phase resolved? Are there blockers that should delay the milestone? What does the customer still need from us? What do we still need from the customer? This is the structured gate that prevents “we said we’d go live this week but we missed three configuration items” failures. Stuck-implementation diagnosis. When an implementation is dragging — sessions are happening but the customer isn’t progressing — Template C surfaces why. Common patterns: customer-side actions pending too long (customer was supposed to do X three sessions ago; never did); same questions recurring (customer keeps asking variations of the same thing — diagnose understanding gap); feature gaps blocking progress (customer’s use case requires capabilities the product doesn’t have); stakeholder drift (initial champion has disengaged; new contact doesn’t have context). Each pattern has a different remediation. Renewal and expansion preparation. Before a renewal conversation, run Template C across the customer’s full implementation history. The artifact tells the renewal lead what was promised vs. delivered, what’s still pending, where enthusiasm was strongest, where friction was raised, what stakeholders are most engaged. A renewal conversation grounded in this artifact is materially different from one grounded in memory.

Cross-customer pattern detection

The single most strategically valuable habit in the workflow. Most implementation teams know they have aggregate insight buried in their session artifacts; few have a systematic way to surface it. The quarterly pattern report. Once a quarter, the implementation lead runs Template D across the team’s session artifacts (manually assembled via the standard cross-meeting workaround). The output:
  • Configuration questions that recurred across N customers → documentation update or self-serve build
  • Feature requests that recurred → product priority signal
  • Documentation gaps that recurred → documentation work
  • Bug patterns → engineering escalation
  • Customer-side friction patterns → onboarding process improvement
  • Trainer behavior patterns → enablement focus
This is what transforms implementation from a reactive function into a feedback engine for product, documentation, and process. The monthly recurrence scan. For higher-volume teams, a monthly scan catches patterns faster. Lighter than the quarterly report — focused on “what came up this month that’s worth flagging?” Cross-functional handoffs. Patterns surfaced through the workflow need to land somewhere actionable. Product: feature-request patterns feed Productboard, JPD, or your product intake. Documentation: gap patterns feed the docs team’s quarterly backlog. Engineering: bug patterns feed engineering triage. Training enablement: trainer behavior or customer friction patterns feed the training improvement queue. Without these handoffs, patterns surface but nothing changes. For very large multi-customer corpora, exporting local transcripts and running an external agent is the alternative to manual assembly.

Routing into systems of record

The customer’s implementation tracking record. The primary durable home. Whether you use a CSM platform (Gainsight, ChurnZero, Vitally, Catalyst), a custom Notion / Coda workspace, or your CRM’s account record — every customer has one place where their implementation status lives. Every session artifact updates this record. Open items get added; resolved items get marked. The record stays current within hours of each session. Trainer / EIC personal queue. Each trainer’s own task system holds their specific follow-ups. Every trainer-owned item from every session lands here, dated. This is what makes “what do I owe customers today?” a 10-second answer. Product intake. Feature requests routed to the product team’s intake system. Aggregate via the pattern report so product sees frequency-weighted requests. Documentation team intake. Documentation gaps routed to docs team’s queue. Engineering intake. Bug reports and engineering-blocking items routed via the meeting-to-tickets workflow and the Linear integration. CSM / Account record. The CRM or CS platform’s account record tracks the customer’s overall trajectory. Earmark archive as source. Source meetings stay in Earmark. Every artifact links back. When a question arises six months later — “what did we agree on about during the configuration phase?” — the answer is one click from the artifact to the source. Especially valuable during renewal conversations and during escalations.

Closing the loop

Three habits. Resolution tracking. Open items need to close. Every item has a target resolution date; items past their target get flagged; a weekly trainer review confirms resolution status; items resolved get marked closed; items still open get re-dated or escalated. A trainer’s running queue should trend toward equilibrium — items getting resolved at roughly the rate they’re being added. If items accumulate, that’s a signal: either the trainer is overloaded, or items are being added that don’t need resolution, or items are stuck on dependencies that need to be unblocked. Milestone validation. Before declaring an implementation milestone complete, run Template C and verify no critical items still open, all committed customer-side actions resolved or actively in progress, all committed trainer/team actions resolved or actively in progress, no risks unaddressed. Milestones declared complete without this check come back as escalations weeks later. Onboarding retrospective. Within 30 days of an implementation completing, run a brief retrospective using the customer’s full implementation artifact archive. What did we promise? Did we deliver? What items took longest to resolve? Why? What patterns showed up that should inform the next implementation? What did we learn about the customer that should inform their post-launch engagement? What feedback should go to product, docs, engineering? The retrospective is what feeds learnings forward.

Common pitfalls

  • Logging resolved items as if they were open. Defeats the workflow’s whole purpose. The “only unresolved” discipline is non-negotiable.
  • Skipping categorization. A flat list requires manual sorting every time. Force the categorization.
  • No “follow-up by customer” tracking. Trainers focus on their own queue; customer-side items get forgotten. Track them deliberately; chase them when they age past their target.
  • No same-day customer email. The email’s value degrades hourly.
  • Categorized items that don’t get routed. Items captured in the artifact but never sent to the destination they need to reach. The routing step is where value gets realized.
  • No cross-customer synthesis. Patterns that exist in the data go unseen because nobody runs Template D. Quarterly at minimum.
  • Stuck implementations not getting diagnosed. When an implementation drags, run the diagnostic synthesis.
  • No milestone gating. Going live without verifying critical items are resolved is the most common cause of post-launch escalations.
  • No resolution tracking. Open items accumulate forever. Trust in the artifact collapses.
  • Feature requests captured but never aggregated. Individual requests lose their signal. Aggregate in pattern reports.
  • Inconsistent trainers. Some run the workflow; others don’t. Customers assigned to non-using trainers get worse experiences. Standardize team-wide.
  • Customer-facing email written generically. Recipients can tell. Reference specifics from the session.
  • Letting the artifact replace the relationship. The artifact tracks; the trainer relates. The customer’s experience depends on both.
  • No senior-trainer review of artifacts in early adoption. New trainers benefit from senior trainers reviewing their first artifacts and catching categorization issues.

Where to go next