Strategy & Planning

How to run a retrospective or post-mortem as Small Customer Success Teams

Strategy & PlanningFor Small Customer Success Teams3 apps12 steps~24 min to set up

Your team runs a post-mortem after every messy churn or rough onboarding — and then the notes sit in a Google Doc nobody rereads. The actual lessons (why account X churned three months after a rocky kickoff, why the same onboarding question keeps hitting Intercom) never make it into a process change. You're pulling context from HubSpot deal notes, Intercom ticket threads, Gmail threads, and one person's memory. There's no structured format, no action item tracking, no way to search what you decided last quarter. Three people covering 250 accounts can't afford to repeat the same churn patterns because the retrospective process is a shared doc that goes stale.

Build this on Starch → See the apps used

Strategy & PlanningFor Small Customer Success Teams3 apps12 steps~24 min to set up

Outcome

What you'll set up

A structured post-mortem app that pulls context from HubSpot, Gmail, and Intercom into a consistent format so you're not starting from a blank doc every time

A searchable archive of every retrospective and the decisions that came out of it, so next quarter you can actually check whether you closed the loop

An action-item tracker wired to the retrospective that assigns follow-ups to the right person with a due date and surfaces overdue items before they get forgotten

The Starch recipe

Apps, data, and prompts

The combination of Starch apps, the data sources they pull from, and the prompts you use to drive them.

Apps used

Knowledge Management Meeting Notes Task Manager

Data sources & config

Starch syncs your HubSpot data on a schedule (contacts, companies, deals, owners) and syncs your Gmail on a schedule (message threads, labels) so the post-mortem app can pull account history without manual copy-paste. Connect Intercom from Starch's integration catalog — the agent queries it live when building the retrospective context. Google Calendar is synced on a schedule to pull meeting history for the account. Meeting Notes captures the retrospective call itself; Knowledge Management stores and indexes all completed retrospectives for future search.

Prompts to copy

Build me a post-mortem template for customer churn events. Pull the HubSpot deal timeline for the account, the last 10 Gmail threads with that customer, and any open Intercom tickets. Format it with sections for: what happened, early signals we missed, what we tried, root cause, and action items with owners and due dates.

After I finish a post-mortem call, generate a summary with key decisions, lessons learned, and action items. Assign each action item to a team member and set a default due date of two weeks out.

Create a task for me to follow up on the Acme churn retrospective action items, P2 priority, due in 14 days, and remind me if it's still open a week from now.

Run these in Starch → or paste them into your favorite agent

Walkthrough

Step-by-step

1 Connect HubSpot — Starch syncs your deals, contacts, companies, and owner data on a schedule so account history is always current when you kick off a post-mortem.

2 Connect Gmail — Starch syncs your message threads on a schedule, giving the post-mortem app access to every email exchange with the account without you digging through your inbox.

3 Connect Intercom from Starch's integration catalog — the agent queries ticket and conversation history live when you trigger a retrospective for a specific account.

4 Connect Google Calendar — Starch syncs event history so the app can surface every call you held with the account over the past 90 days as part of the timeline.

5 Tell Starch in natural language: 'Build me a post-mortem app that takes an account name, pulls HubSpot deal history, Gmail threads, Intercom tickets, and Calendar meetings for that account, and populates a structured template with timeline, signals missed, what we tried, root cause, and action items.' Starch builds the app.

6 Install the Meeting Notes app from the App Store — start every retrospective call with it running so transcription and action-item extraction happen automatically while you focus on the conversation.

7 After the call, Meeting Notes generates a summary with decisions and highlights. Review it, then push action items directly into the Task Manager with owners and due dates.

8 Install the Knowledge Management app from the App Store to store every completed retrospective. Each post-mortem document is indexed and searchable — when you're about to onboard a new account in the same industry, you can search 'healthcare onboarding problems' and get the three retrospectives that flagged this before.

9 Set up a recurring Task Manager reminder — every Monday, surface any retrospective action items that are overdue or unassigned, so nothing falls through the cracks between QBR cycles.

10 Tell Starch: 'Every quarter, generate a retrospective digest — summarize all post-mortems from the last 90 days, group by root cause category (onboarding, product gaps, champion loss, pricing), and show which action items were closed vs. still open.' Use this as input for your team's quarterly CS strategy review.

11 Over time, ask Knowledge Management: 'What are the three most common root causes in our churn post-mortems from the last six months?' — the search runs across every archived retrospective and surfaces patterns you haven't noticed manually.

12 Fork the post-mortem app to create a lighter version for onboarding stumbles that don't result in churn — same structure, shorter timeline window, same action-item tracking — so you're running retrospectives proactively, not just after you lose an account.

See this running on Starch

Connect your tools, describe what you want, and the agent builds it. Closed beta is free.

Try it on Starch →

Worked example

Acme Corp churn retrospective — March 2026

Sample numbers from a real run

Acme Corp (SMB, $18,000 ARR)	18,000
Churned month 7 of 12-month contract	0
3 Intercom tickets flagged 'confused about reporting' in months 3-4	0
Last QBR held 5 months prior	0
Action item from prior post-mortem ('schedule mid-year check-in for accounts > $15k') — never assigned	0

You trigger the post-mortem app for Acme Corp the day after they churn. Starch pulls the HubSpot deal timeline (7 months, 2 expansion conversations that went cold), the last 14 Gmail threads (last reply was 6 weeks ago), 3 Intercom tickets all tagged 'reporting confusion' in months 3 and 4, and 4 Calendar meetings — the last one 5 months back. The post-mortem app populates the template: the root cause section flags that there was no structured follow-up after the onboarding confusion tickets were resolved, and the 'signals we missed' section highlights the 6-week email silence before renewal. Meeting Notes from your retrospective call adds the team's live discussion: your colleague mentions they saw the same 'reporting confusion' pattern in two other accounts that month but never flagged it formally. That observation becomes a task: audit all Intercom tickets tagged 'reporting confusion' in the past 90 days, P1, assigned to the team lead, due in 5 days. Knowledge Management indexes the whole retrospective. Three months later, when a similar account in the same segment hits month 4, you search 'reporting confusion onboarding' and find the Acme post-mortem immediately — you schedule a proactive check-in call before the silence starts.

Measurement

How you'll know it's working

Post-mortem action item close rate (% of items marked done within 30 days vs. left open)

Time from churn event to completed retrospective (target: under 5 business days)

Repeat root cause rate (% of churns in a quarter sharing a root cause flagged in a prior retrospective)

Accounts touched by a proactive intervention triggered by a retrospective finding

Average number of signals identified per post-mortem that were present in the account's data but not acted on

Comparison

What this replaces

The other ways teams handle this today, and how the Starch version compares.

Google Docs + a shared folder

Free and familiar, but retrospectives are unsearchable at scale — you can't query across 30 docs to find patterns, and action items live nowhere tracked.

Notion

Better structure and search than Docs, but you're still manually copying deal notes from HubSpot and ticket threads from Intercom — no data connections, so the prep work is on you.

Gainsight or ChurnZero

Purpose-built for CS retrospectives and health scoring, but starts at six figures and requires a CS-ops person to configure the playbooks — not realistic for a three-person team.

Loom + manual notes

Good for capturing the conversation, but there's no action-item extraction, no structured template, and no way to search what was decided across multiple recordings.

On Starch RECOMMENDED

One platform — knowledge management, meeting notes, task manager all running on connected data. Setup in plain English; numbers stay current via scheduled syncs and live agent queries.

Try it on Starch →

FAQ

Frequently asked questions

Does Starch actually read the content of our Gmail threads with customers, or just metadata?

Starch syncs Gmail messages — subject, body, labels — on a schedule. The post-mortem app can read thread content to surface relevant exchanges for a given account. One honest note: the Gmail OAuth consent screen currently shows the underlying connector name rather than Starch — that's on the roadmap to fix. And message sync is capped at 30 messages per page to avoid errors on long HTML threads, which is fine for most account retrospectives.

We use Intercom for customer support tickets. Can Starch pull that in?

Yes — connect Intercom from Starch's integration catalog and the agent queries your conversation and ticket history live when you run a post-mortem for a specific account. It's not synced on a schedule like HubSpot or Gmail, so it queries at the moment you trigger the retrospective — which is exactly when you need it.

Can the post-mortem app work for onboarding stumbles, not just churns?

Yes, and it's worth setting up. Tell Starch: 'Fork my churn post-mortem app and make a lighter version for onboarding issues — same sections but with a 60-day timeline window and a lower severity threshold.' You get a separate app for proactive retrospectives so you're not waiting until you lose an account to run the process.

Is the Knowledge Management app good enough to replace our shared Notion wiki?

For retrospective archives specifically, yes — it stores, indexes, and lets you query across all your post-mortems in natural language. Whether it replaces your entire Notion setup depends on what else you have in there. Starch also connects to Notion from its integration catalog if you want to keep both and have the agent query across them.

What if someone forgets to open Meeting Notes before the retrospective call starts?

The retrospective app still works — it pulls structured data from HubSpot, Gmail, Intercom, and Calendar regardless of whether a call was recorded. Meeting Notes adds the live discussion layer (direct quotes, in-call action items), but the account context and template population happen from your connected data sources, not from the transcript.

We're not SOC 2 certified — does that matter for a customer success team?

Starch is not SOC 2 Type II certified today, and there's no on-prem option. If your company has enterprise security requirements that mandate SOC 2 for any tool touching customer data (HubSpot contacts, Gmail threads), that's a real constraint worth checking with your IT or legal team before you set this up.