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.Documentation Index
Fetch the complete documentation index at: https://docs.tryearmark.com/llms.txt
Use this file to discover all available pages before exploring further.
Foundation
Identify which sessions feed the workflow
Not every customer touchpoint is a training session. The candidates:| Session type | Run the workflow? |
|---|---|
| Kickoff / discovery | Yes — usually high item volume |
| Configuration sessions | Yes — the highest-volume category |
| Training sessions (feature-by-feature) | Yes — primary use case |
| Workshops with multi-team customers | Yes — items often by stakeholder |
| Pre-go-live readiness reviews | Yes — high-stakes; gaps must be caught |
| Go-live support / hypercare calls | Yes — incident-like items |
| Post-launch follow-up sessions | Yes — items often roll into expansion or churn risk |
| Quick status checks (5-min syncs) | Optional — usually too thin |
| Internal customer-account reviews | Use structured meeting notes instead |
| Pure sales follow-ups | Use sales calls workflow |
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:| Category | What goes here |
|---|---|
| Questions needing configuration | Customer asked about a setting, workflow, or option that needs to be set up or confirmed. Trainer owns figuring out the answer; sometimes the customer owns making the change. |
| Feature requests | Customer asked for capability the product doesn’t currently have. Product / engineering owns. |
| Documentation gaps | Customer asked a question that should have been answerable from existing docs but wasn’t. Documentation team owns. |
| Bug reports | Something is broken. Engineering owns; trainer flags. |
| Follow-ups by trainer / EIC | Trainer committed to doing something — sending a doc, scheduling a follow-up, looking into a question. Trainer owns. |
| Follow-ups by customer | Customer committed to doing something — configuring, getting back to the trainer, talking to their team. Customer owns. |
| Follow-ups by other team | Items requiring engineering, support, product, or other internal teams. |
| Risks and concerns | Things the customer raised that signal implementation or escalation risk. |
| Wins and positive signals | Things worth tracking for advocacy, case studies, renewal positioning. |
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:| Audience | Destination |
|---|---|
| The customer | Same-day follow-up email; sometimes a shared implementation doc |
| The trainer’s own queue | Personal task system (Linear, Asana, Things) |
| The implementation team | Per-customer tracking doc (Notion, Coda) or CSM platform (Gainsight, ChurnZero, Vitally, Catalyst) |
| Product team | Productboard, Jira Product Discovery, or whatever your product feature-request system is |
| Documentation team | Documentation backlog (Notion, GitHub Issues, internal queue) |
| Engineering team | Tickets in Linear, Jira, or GitHub via the meeting-to-tickets workflow |
| CRM | Customer’s account record with implementation status |
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.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.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.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.Save them as workspace templates
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.
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.
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
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.
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.
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.
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 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
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
- Workflows — the general shape this is an instance of
- Action items workflow — the general version this workflow specializes
- Email follow-up workflow — for the customer-facing email patterns
- Meeting-to-tickets workflow — for routing bugs and engineering work to the tracker
- Customer research workflow — for the customer-signal-capture sibling to this workflow
- SOPs and playbooks workflow — for documenting the implementation procedures themselves
- Demo and facilitator scripts workflow — for capturing how senior trainers run their sessions, as transferable scripts
- Linear integration — for engineering tickets
- Custom templates — visibility, sharing, and edit permissions
- Composer — for tuning the prompt before saving as a workspace template
- Before a meeting — pre-seeding the template on every training session
- Local transcripts — for external synthesis on large cross-customer corpora

