Issue #92: AI Automations That Build Assets (In Your Business)

Good morning.

In this issue, we’re focused on 3 AI automations that actually PRODUCE something.

Not dashboards. Not analysis. Not insights you'll never act on.

Assets.

The kind of assets that close deals, enable you to hire, and keep customers paying month after month.

Most AI automation advice focuses on monitoring, analyzing, and alerting. That's fine. But it doesn't build anything unless you take action or connect other automations or agents that do the work.

The entrepreneurs pulling ahead are using AI to create the documents, sequences, and systems that make their business run.

Today I'm giving you three automations that produce tangible deliverables:

Complete proposals ready to send after a discovery call

Formatted SOPs that let you delegate anything

Full onboarding sequences that retain customers automatically

Each one creates something you can use immediately. Something that used to take hours now takes minutes.

— Sam

IN TODAY’S ISSUE 🤖 

• Asset Win #1: The Proposal Generator (discovery call → send-ready proposal in 15 minutes)

• Asset Win #2: The SOP Factory (rough process → formatted procedure anyone can follow)

• Asset Win #3: The Onboarding Sequence Builder (your method → complete email sequence ready to load)

Let’s get into it.

Production Win #1: The Proposal Generator

Turn any discovery call into a send-ready proposal in 15 minutes

The Problem: You finish a great discovery call. The prospect is warm. You promise to send a proposal by tomorrow.

Then you sit down to write it. Two hours later, you're still formatting the scope section and second-guessing your pricing. The momentum dies. Sometimes you don't send it for three days.

Every day you delay, your close rate drops.

The Solution: A system that transforms discovery call notes or transcripts into complete, branded proposals (scope, deliverables, timeline, investment, terms) ready for final review and send.

• Time to implement: 20 minutes (manual) or 60 minutes (automated)

• Tools needed: Claude + your discovery call notes + your proposal template

• Produces: A 90% complete proposal document you can send within an hour of any call

Option 1: The Manual Method (20 minutes)

The Proposal Generator Prompt

PROPOSAL GENERATOR

You are an expert business proposal writer. Create a complete, professional proposal from this discovery call information.

MY BUSINESS CONTEXT:
- Company: [Your company name]
- Service type: [What you sell]
- Typical engagement: [How you usually work with clients]
- Pricing model: [Hourly/project/retainer/value-based]

DISCOVERY CALL NOTES:
[Paste your notes or transcript]

CLIENT INFORMATION:
- Company: [Their company]
- Contact: [Name and title]
- Industry: [Their industry]

GENERATE A COMPLETE PROPOSAL:

1. EXECUTIVE SUMMARY (2-3 paragraphs)
   - Restate their situation and challenges (use their words)
   - Bridge to how you'll solve it
   - High-level outcome they can expect

2. UNDERSTANDING YOUR SITUATION
   - Current state (challenges, pain points)
   - Desired future state (goals mentioned)
   - Why this matters now (urgency factors)
   - What happens if nothing changes

3. PROPOSED SOLUTION
   - Approach overview
   - Why this approach for their specific situation
   - What makes this different from alternatives they've tried

4. SCOPE OF WORK
   For each phase/deliverable:
   - What's included (specific)
   - What's NOT included (boundaries)
   - Their responsibilities
   - Timeline for this phase

5. DELIVERABLES
   Bullet list of exactly what they receive:
   - [Deliverable]: [Description]
   - [Deliverable]: [Description]
   (Be specific—not "strategy document" but "90-day content calendar with 45 post concepts")

6. TIMELINE
   Week-by-week or phase-by-phase breakdown:
   - Week 1: [Activities]
   - Week 2: [Activities]
   Include: Kickoff date assumption, key milestones, final delivery

7. INVESTMENT
   Present pricing clearly:
   - Option A: [Package/scope] — $X
   - Option B: [Package/scope] — $X (if applicable)
   
   Include:
   - What's included in the price
   - Payment terms (50% upfront, etc.)
   - What triggers additional costs

8. WHY [YOUR COMPANY]
   - Relevant experience
   - Similar results achieved
   - What makes you the right fit for THIS project

9. NEXT STEPS
   - How to proceed
   - What you need from them
   - Proposed start date
   - How long this proposal is valid

10. TERMS & CONDITIONS (Brief)
    - Payment terms
    - Revision policy
    - Cancellation terms
    - IP ownership

Write in confident, professional tone. Use their language from the call. Make it easy to say yes.

Manual Workflow:

1. Take notes during discovery call (or use transcript from Fathom/Otter/Grain)

2. Within 1 hour of call, paste into Claude with the prompt

3. Review output, adjust pricing and specifics

4. Drop into your branded template (Google Docs/Notion/PandaDoc)

5. Send same day while you're still top of mind

Pro Tip: Create 2-3 versions of this prompt for different service tiers or engagement types. A $5K project proposal differs from a $50K engagement.

Option 2: Claude Skills Setup

Create a Proposal Writing skill that maintains your voice, pricing, and terms:

SKILL.md contents:

---
name: proposal-generator
description: Generate complete client proposals from discovery call notes or transcripts. Use when creating proposals, quotes, SOWs, or engagement letters.
---

## Proposal Generation Protocol

### Required Inputs
Before generating, confirm you have:
- Discovery call notes or transcript
- Client company name and contact
- Service type being proposed
- Any pricing already discussed

### Company Context (Customize This Section)

**Our Company:** [Your Company Name]
**Services:** [Your service offerings]
**Typical Engagements:** [How you usually structure work]

**Pricing Framework:**
- Strategy/Consulting: $X per hour / $X per day
- Implementation: $X - $X per project
- Retainers: Starting at $X/month
- Rush fee: +25% for timelines under X weeks

**Standard Terms:**
- Payment: 50% upfront, 50% on completion
- Revisions: 2 rounds included
- Timeline: Proposals valid for 14 days
- IP: Client owns deliverables upon final payment

### Proposal Structure

**Voice & Tone:**
- Confident but not arrogant
- Specific, not vague
- Use client's language from the call
- Focus on outcomes, not activities

**Length Guidelines:**
- Executive Summary: 150-250 words
- Full proposal: 1,500-2,500 words
- More detail for larger engagements

**Pricing Presentation:**
- Always present 2-3 options when possible
- Anchor high, recommend middle
- Make ROI clear (investment vs. return)

### Quality Checks
Before finalizing, verify:
- [ ] Client's problem is restated in their words
- [ ] Scope boundaries are crystal clear
- [ ] Timeline is realistic
- [ ] Pricing matches discussed range
- [ ] Next steps are specific and easy
- [ ] No placeholder text remains

Option 3: Gumloop Automation

Build an automated pipeline from call recording to proposal draft:

Workflow Overview:

Discovery Call Recording → Transcript Extraction → AI Proposal Generation → Template Population → Draft Review Link → CRM Update

Node-by-Node Setup:

Node 1: Trigger

• Type: Webhook from meeting tool (Fathom, Grain) or manual trigger

• Input: Meeting recording URL or transcript

• Alternative: Email trigger when you forward call notes to a specific address

Node 2: Transcript Processing

• Type: Conditional router

• If audio: Send to Whisper transcription node

• If transcript text: Pass directly

• If notes: Pass directly

Node 3: Client Data Enrichment

• Type: HTTP request to CRM (HubSpot, Pipedrive, Salesforce)

• Pull: Company info, deal value, previous interactions

• Also: LinkedIn company data via API for context

Node 4: Proposal Generation

• Type: Claude node (Sonnet 4.5 recommended)

• System prompt: Your customized proposal generator prompt

• Include: Your pricing tiers, terms, and company context

• Output: Structured JSON with all proposal sections

{
  "executive_summary": "...",
  "situation_analysis": "...",
  "proposed_solution": "...",
  "scope_of_work": [...],
  "deliverables": [...],
  "timeline": [...],
  "investment": {
    "option_a": {...},
    "option_b": {...}
  },
  "next_steps": "..."
}

Node 5: Document Generation

• Type: Google Docs API or PandaDoc integration

• Action: Create new document from template

• Populate: All fields from AI output

• Format: Apply your branded styling

Gumloop Document Nodes:

• Use the Google Docs Writer node to create directly

• Or export to PDF via document generation node

• Alternative: Notion page creation for internal review first

Node 6: Review Notification

• Type: Slack or Email

• Message:

📄 New Proposal Draft Ready

Client: [Company Name]
Contact: [Name]
Estimated Value: $[Amount]

Review and edit: [Google Doc Link]

Call Summary:
- Main challenge: [AI-extracted summary]
- Proposed solution: [Brief description]
- Timeline discussed: [X weeks]

⏰ Send deadline: [24 hours from now]

Node 7: CRM Update

• Type: HubSpot/Pipedrive/Salesforce integration

• Actions:

  • Update deal stage to "Proposal Sent" (after you send)

  • Attach proposal document

  • Log activity

  • Set follow-up task for 3 days out

Cost: ~$37-97/month (Gumloop Solo/Team depending on volume)

Option 4: Lindy AI Agent

Agent Name: "Proposal Assistant"

Configuration:

You are my Proposal Assistant. Your job is to transform discovery calls into ready-to-send proposals as fast as possible.

TRIGGERS:
- New transcript appears in Google Drive folder: "Discovery Calls"
- I forward an email with subject containing "proposal" or "quote request"
- I message you in Slack with call notes
- Calendar event marked "Discovery Call" ends

WORKFLOW:

1. EXTRACT from the call/notes:
   - Client company and contact name
   - Their core challenge (in their words)
   - Desired outcome
   - Timeline mentioned
   - Budget signals
   - Decision process/stakeholders
   - Any objections or concerns raised

2. GENERATE proposal using my framework:
   [Insert your proposal structure here]
   
   Pricing guidelines:
   - Strategy: $X-X based on complexity
   - Implementation: $X-X based on scope
   - Retainer: $X-X/month based on hours
   
   Always offer 2-3 options when scope allows.

3. CREATE draft in Google Docs:
   - Use template: [Your template link]
   - Populate all sections
   - Highlight anything needing my review in yellow
   - Add internal notes with reasoning for pricing

4. NOTIFY me via Slack:
   - Summary of what was proposed
   - Link to draft
   - Recommended send time
   - Any flags (unclear scope, budget mismatch, etc.)

5. PREP follow-up:
   - Draft a "proposal sent" email for me to customize
   - Create calendar reminder for follow-up in 3 days
   - Note any specific objections to address in follow-up

QUALITY RULES:
- Never send proposal without my review
- Flag if proposed budget is >20% different from discussed
- If scope is unclear, ask me before generating
- Use client's exact language for their challenges
- Default to being specific rather than vague

Lindy Integrations Required:

• Google Drive (transcript storage)

• Google Docs (proposal creation)

• Slack (notifications and interaction)

• Your CRM (deal updates)

• Calendar (meeting triggers)

Why This Works

Proposal speed directly correlates with close rate. HubSpot data shows that responding to a prospect within an hour makes you 7x more likely to have a meaningful conversation than waiting even two hours.

The same applies to proposals. Send it while the conversation is fresh, while they're still excited, while you're still top of mind.

This system removes the friction between "great call" and "proposal sent."

The compound effect:

• Same-day proposals become your standard (not your exception)

• Close rates improve 20-40% from speed alone

• You can take more discovery calls (bottleneck removed)

• Proposals become consistent in quality

• Junior team members can draft proposals (you just review)

Production Win #2: The SOP Factory

Turn messy processes into clear procedures anyone can follow

The Problem: You know how to do everything in your business. It's all in your head. But that means:

• You can't delegate without 45-minute explanations

• New hires take months to become useful

• Things break when you're on vacation

• Your business is unsellable (it's just you with helpers)

You know you need SOPs. You've been meaning to write them for years. But who has time to document 47 processes?

The Solution: A system that transforms your rough notes, screen recording transcripts, or verbal brain dumps into formatted, step-by-step procedures anyone can follow.

• Time to implement: 20 minutes (manual) or 45 minutes (automated)

• Tools needed: Claude + your rough process notes or recordings

• Produces: Complete SOP documents ready for your company wiki

Option 1: The Manual Method (20 minutes)

The SOP Generator Prompt

SOP GENERATOR

You are a technical writer specializing in clear, actionable standard operating procedures. Transform my rough process explanation into a complete SOP document.

PROCESS TO DOCUMENT:
[Paste your rough notes, transcript, or brain dump here]

CONTEXT:
- Process name: [What is this procedure called?]
- Who performs this: [Role/team responsible]
- Frequency: [Daily/weekly/as needed/etc.]
- Typical time to complete: [Estimate]
- Tools/systems involved: [List software, platforms, etc.]

GENERATE A COMPLETE SOP:

1. HEADER SECTION
   - SOP Title
   - Version number (1.0)
   - Last updated date
   - Owner (role responsible for maintaining)
   - Applies to (who should follow this)

2. PURPOSE
   One paragraph explaining:
   - Why this process exists
   - What outcome it achieves
   - When to use this SOP

3. SCOPE
   - What this SOP covers
   - What this SOP does NOT cover
   - Prerequisites before starting

4. DEFINITIONS
   List any terms, acronyms, or jargon with definitions
   (Skip if none needed)

5. TOOLS & ACCESS REQUIRED
   Table format:
   | Tool/System | Purpose | Access Level Needed |
   |-------------|---------|---------------------|

6. PROCEDURE (The Core Steps)
   Numbered steps with:
   - Clear action verb to start each step
   - Specific details (don't assume knowledge)
   - Expected outcome of each step
   - Screenshots placeholder notes: [SCREENSHOT: description]
   
   Sub-steps where needed (6.1, 6.2, etc.)
   
   Decision points marked clearly:
   - IF [condition]: Do X
   - IF [other condition]: Do Y

7. QUALITY CHECKLIST
   Checkbox list of items to verify before marking complete:
   □ [Check item 1]
   □ [Check item 2]
   □ [Check item 3]

8. TROUBLESHOOTING
   Common problems and solutions:
   - Problem: [Issue]
     Solution: [Fix]

9. RELATED PROCEDURES
   Links to other SOPs that connect to this one

10. REVISION HISTORY
    | Version | Date | Changes | Author |
    |---------|------|---------|--------|

Write at a level where someone with no prior knowledge of this process could follow it successfully. When in doubt, be more specific rather than less.

Manual Workflow:

1. Brain dump the process (voice memo, rough notes, or record your screen while doing it)

2. If screen recording, run through Whisper or your transcription tool

3. Paste into Claude with the prompt

4. Review output for accuracy

5. Add screenshots where indicated

6. Upload to Notion/Confluence/Google Docs

Pro Tip: Record yourself actually doing the task via Loom. Talk through what you're doing and why. The transcript becomes your input.

Option 2: Claude Skills Setup

SKILL.md contents:

---
name: sop-factory
description: Transform rough process descriptions, recordings, or notes into complete Standard Operating Procedures. Use when documenting processes, creating training materials, or building operational playbooks.
---

## SOP Generation Protocol

### Input Flexibility
Accept process information in any form:
- Screen recording transcripts
- Voice memo transcripts
- Bullet point notes
- Chat/email explanations
- Step lists
- Even rambling brain dumps

### Output Standards

**Formatting Rules:**
- Use numbered steps (not bullets) for procedures
- Bold key actions and system names
- Use tables for tools, access, and revision history
- Include screenshot placeholders with descriptions
- Mark decision points clearly with IF/THEN structure

**Language Standards:**
- Start each step with an action verb (Click, Navigate, Enter, Select, Review, Confirm)
- Write in present tense, imperative mood
- Avoid jargon unless defined
- One action per step (break down complex steps)
- Include expected outcome where helpful

**Completeness Checks:**
- Every tool mentioned is in the Tools table
- Every acronym is defined
- No steps require assumed knowledge
- Decision points have all paths covered
- Troubleshooting covers common failures

### Complexity Scaling

**Simple SOP (under 10 steps):**
- Streamlined format
- Skip sections that aren't relevant
- Keep to 1-2 pages

**Standard SOP (10-25 steps):**
- Full format with all sections
- Include troubleshooting
- 2-4 pages typical

**Complex SOP (25+ steps or multiple decision paths):**
- Consider breaking into multiple SOPs
- Include process flow diagram description
- Add role-based sections if multiple people involved
- May need 5+ pages

### Company Context (Customize)

**Standard Tools:**
- Project Management: [Your tool]
- Communication: [Your tool]
- Documentation: [Your tool]
- CRM: [Your tool]

**SOP Storage Location:** [Where SOPs live]
**Review Cycle:** [How often SOPs are reviewed]
**Approval Process:** [Who approves new SOPs]

Option 3: Gumloop Automation

Build a pipeline that captures process recordings and outputs formatted SOPs:

Workflow Overview:

Loom/Recording Upload → Transcription → AI SOP Generation → Notion Page Creation → Review Notification

Node-by-Node Setup:

Node 1: Trigger

• Type: Multiple trigger options

  • Google Drive: New file in "Process Recordings" folder

  • Email: Forward recording to sop@[your-domain].gumloop.app

  • Webhook: From Loom or other recording tool

  • Manual: Upload transcript directly

Node 2: Transcription (if needed)

• Type: Whisper API node or Assembly AI

• Input: Audio/video file

• Output: Timestamped transcript

• Settings: Enable speaker identification if multiple people

Node 3: Context Extraction

• Type: Claude node (quick pass)

• Purpose: Extract metadata before full generation

• Prompt:

From this recording transcript, extract:
1. Process name (best guess)
2. Tools/systems mentioned
3. Approximate number of steps
4. Who typically performs this
5. Frequency (if mentioned)

Output as JSON.

Node 4: SOP Generation

• Type: Claude node (Sonnet 4.5)

• System prompt: Full SOP Generator prompt

• Input: Transcript + extracted context

• Output: Complete SOP in Markdown

Node 5: Notion Page Creation

• Type: Notion integration (Gumloop has native MCP)

• Action: Create new page in SOP database

• Properties:

  • Title: SOP name

  • Status: "Draft - Needs Review"

  • Owner: [You or assignee]

  • Category: [Extracted from context]

  • Created: Current date

• Content: Full SOP markdown

Node 6: Screenshot Reminder

• Type: Parse SOP for screenshot placeholders

• Create: Task list of screenshots needed

• Output: Checklist for manual screenshot addition

Node 7: Notification

• Type: Slack message

• Content:

📋 New SOP Draft Created

Process: [SOP Name]
Steps: [Count]
Complexity: [Simple/Standard/Complex]

Review here: [Notion link]

📸 Screenshots needed: [Count]
[List of screenshot descriptions]

Please review for accuracy and add screenshots within 48 hours.

Bonus Node: Screenshot Integration (Advanced)

• Type: Loom API or CloudApp integration

• Action: Pull timestamps from transcript

• Create: Screenshot capture tasks at key moments

• Note: This requires timestamps in your transcript

Cost: ~$37-97/month depending on volume

Option 4: Lindy AI Agent

Agent Name: "SOP Factory Agent"

Configuration:

You are my SOP Factory Agent. Your job is to transform any process explanation into a professional, usable Standard Operating Procedure.

TRIGGERS:
- File uploaded to Google Drive folder: "Process Recordings"
- Email received at sop@[domain] with attachment or process description
- Slack message to you starting with "SOP:" followed by process description
- Voice memo transcripts from Otter.ai

WORKFLOW:

1. RECEIVE the input (transcript, notes, or description)

2. ANALYZE to determine:
   - Process name
   - Complexity (simple/standard/complex)
   - Tools involved
   - Who performs this
   - Gaps in explanation (things that are unclear)

3. IF gaps exist:
   - Message me in Slack with specific questions
   - Wait for response before proceeding
   - Don't guess on critical steps

4. GENERATE complete SOP using standard format:
   - Header with metadata
   - Purpose and scope
   - Tools and access table
   - Numbered procedure steps
   - Quality checklist
   - Troubleshooting section

5. CREATE Notion page:
   - Database: "Company SOPs"
   - Status: "Draft"
   - Add all content
   - Insert [SCREENSHOT NEEDED] placeholders

6. IDENTIFY screenshots needed:
   - List each screenshot with description
   - Estimate which step it belongs to
   - Create task in Asana for screenshot capture

7. NOTIFY via Slack:
   - Summary of SOP created
   - Link to Notion page
   - List of questions (if any)
   - Screenshot task link

QUALITY RULES:
- Never publish without my review
- Ask rather than assume on unclear steps
- Break complex processes into multiple SOPs if >30 steps
- Use consistent formatting across all SOPs
- Include decision trees for processes with branching logic

SOP STANDARDS:
- Action verbs to start each step
- One action per step
- Include expected outcomes
- Note common errors and fixes
- Link related SOPs when relevant

Why This Works

SOPs are the infrastructure of scale. Without them:

• You're the bottleneck for everything

• Training takes forever

• Quality is inconsistent

• Your business has no value without you

The problem isn't that SOPs are hard to write. It's that writing them is boring and low-urgency. There's always something more pressing.

This system removes the writing friction. You just explain the process however is natural (recording yourself, rough notes, brain dump). An LLM does the tedious transformation into proper documentation.

The compound effect:

• Delegate tasks you've been hoarding for years

• New hires become productive 3x faster

• You can take vacation without everything breaking

• Your business becomes sellable (documented operations = higher multiple)

• Tribal knowledge becomes company knowledge

Production Win #3: The Onboarding Sequence Builder

Transform your customer success process into a complete email sequence

The Problem: Your onboarding is inconsistent. New customers get a welcome email, maybe a check-in call, then... radio silence until they churn.

You know onboarding matters. Research says customers who successfully onboard have 3x higher retention. But building a proper 7-10 email sequence? Writing all that copy? Setting up the automation? It keeps getting pushed to "someday."

The Solution: A system that transforms your onboarding knowledge into a complete, ready-to-load email sequence with subject lines, send timing, and actual copy for each email.

• Time to implement: 25 minutes (manual) or 60 minutes (automated)

• Tools needed: Claude + your onboarding knowledge

• Produces: A complete email sequence you can paste into ConvertKit/ActiveCampaign/HubSpot today

Option 1: The Manual Method (25 minutes)

The Onboarding Sequence Builder Prompt

ONBOARDING SEQUENCE BUILDER

You are an expert email copywriter and customer success strategist. Create a complete onboarding email sequence that turns new customers into successful, retained customers.

MY PRODUCT/SERVICE:
- What I sell: [Product/service description]
- Price point: [$X]
- Primary outcome: [What customers achieve with it]
- Time to value: [How long until they see results]
- Common failure points: [Where customers typically get stuck]

MY CUSTOMER:
- Who they are: [Target customer description]
- Why they bought: [Primary motivation]
- What they're afraid of: [Concerns/doubts after purchase]
- Definition of success: [What does a successful customer look like after 30 days?]

CURRENT ONBOARDING:
- What happens now: [Describe your current process]
- What's working: [Any elements that work well]
- Where they get stuck: [Common problems]
- Support questions we see: [Frequent early questions]

CREATE A COMPLETE ONBOARDING SEQUENCE:

For each email, provide:
- Email number and name (e.g., "Email 1: Welcome & Quick Win")
- Send timing (e.g., "Immediately after purchase" or "Day 3")
- Subject line (and one alternative)
- Preview text
- Complete email body (ready to use, not an outline)
- Call to action
- Internal notes (purpose of this email, what success looks like)

SEQUENCE STRUCTURE:

EMAIL 1: Welcome & Immediate Next Step
- Arrives: Immediately
- Purpose: Confirm purchase, reduce buyer's remorse, give ONE clear action

EMAIL 2: Quick Win Achievement
- Arrives: Day 1-2
- Purpose: Get them to complete first small success

EMAIL 3: Common Obstacle Anticipation
- Arrives: Day 3-4
- Purpose: Address the #1 place people get stuck

EMAIL 4: Deeper Engagement
- Arrives: Day 5-7
- Purpose: Move from "trying it" to "using it"

EMAIL 5: Social Proof & Milestone
- Arrives: Day 8-10
- Purpose: Show what others achieved, celebrate their progress

EMAIL 6: Advanced Feature/Next Level
- Arrives: Day 12-14
- Purpose: Expand their usage, increase stickiness

EMAIL 7: Check-in & Support Offer
- Arrives: Day 18-21
- Purpose: Identify struggling users, offer help

EMAIL 8: Success Story & Referral Ask
- Arrives: Day 25-30
- Purpose: Reinforce value, begin referral/upsell conversation

WRITING STYLE:
- Conversational, not corporate
- Short paragraphs (2-3 sentences max)
- One clear CTA per email
- Personal (from a real person, not "the team")
- Mobile-friendly formatting

Manual Workflow:

1. Answer the context questions honestly (this is the key input)

2. Run through Claude

3. Review each email for accuracy and brand voice

4. Adjust timing based on your product's reality

5. Load into your email platform

6. Set up automation triggers

Pro Tip: After initial generation, run each email back through Claude asking: "Rewrite this email to be more [conversational/urgent/supportive/specific]. Reduce length by 20%."

Option 2: Claude Skills Setup

SKILL.md contents:

---
name: onboarding-sequence-builder
description: Create complete customer onboarding email sequences with full copy, subject lines, and timing. Use when building onboarding flows, welcome sequences, or customer success campaigns.
---

## Onboarding Sequence Protocol

### Core Philosophy

**The Goal:** Transform a new buyer into a successful customer who:
1. Achieves their first win quickly (reduces refunds)
2. Develops the habit of using the product (increases retention)
3. Sees clear value (enables upsells and referrals)

**Key Principle:** Each email has ONE job. Don't cram multiple CTAs or topics.

### Sequence Architecture

**Phase 1: Activation (Days 0-7)**
Focus: Get them using the product
- Email 1: Welcome + one action
- Email 2: First win achievement
- Email 3: Obstacle clearing

**Phase 2: Engagement (Days 8-21)**
Focus: Build the habit
- Email 4: Deeper usage
- Email 5: Social proof + progress
- Email 6: Advanced features

**Phase 3: Retention (Days 22-30)**
Focus: Lock in the relationship
- Email 7: Check-in + support
- Email 8: Success celebration + expansion

### Email Standards

**Subject Lines:**
- 6-10 words optimal
- Use curiosity, specificity, or benefit
- Avoid spam triggers
- Always include alt subject line

**Preview Text:**
- Complement (don't repeat) subject
- Create curiosity gap
- 40-90 characters

**Body Copy:**
- Open with "you" not "I" or "we"
- Short paragraphs (mobile readers)
- One CTA per email
- Specific, not generic
- 150-300 words per email (varies by purpose)

**Send Timing:**
- Consider time zones (send at 10am recipient time if possible)
- Avoid weekends for B2B
- Space emails 2-4 days apart typically

### Success Metrics to Track
- Open rates by email (identify weak subject lines)
- Click rates (identify weak CTAs)
- Drop-off points (where do people stop engaging?)
- Time to first key action
- 30-day retention rate

Option 3: Gumloop Automation

Build a workflow that generates customized onboarding sequences and loads them into your email platform:

Workflow Overview:

New Product/Segment Input → AI Sequence Generation → Email Platform API → Automation Setup → Test Email Trigger

Node-by-Node Setup:

Node 1: Input Form

• Type: Gumloop Form Interface

• Fields:

  • Product/service name

  • Target customer description

  • Primary outcome

  • Common obstacles

  • Current onboarding notes

  • Email platform (dropdown: ConvertKit, ActiveCampaign, HubSpot, etc.)

Node 2: Context Enhancement

• Type: Claude node (quick pass)

• Purpose: Expand brief inputs into rich context

• Prompt: "Expand these onboarding inputs into detailed customer journey insights..."

Node 3: Sequence Generation

• Type: Claude node (Sonnet 4.5)

• System prompt: Complete Onboarding Sequence Builder prompt

• Output: Structured JSON with all 8 emails

{
  "sequence_name": "New Customer Onboarding",
  "emails": [
    {
      "number": 1,
      "name": "Welcome & Quick Win",
      "timing": "Immediately",
      "delay_hours": 0,
      "subject_line": "...",
      "alt_subject": "...",
      "preview_text": "...",
      "body_html": "...",
      "cta_text": "...",
      "cta_url": "{{product_login_url}}",
      "internal_notes": "..."
    },
    // ... remaining emails
  ],
  "triggers": {
    "start": "purchase_complete",
    "tags_to_add": ["onboarding-active"],
    "tags_on_complete": ["onboarding-complete"]
  }
}

Node 4: Platform Router

• Type: Conditional router based on selected platform

• Route to appropriate integration node:

  • ConvertKit: Use ConvertKit API nodes

  • ActiveCampaign: Use AC integration

  • HubSpot: Use HubSpot workflow builder API

  • Mailchimp: Use Mailchimp automation API

Node 5: Email Platform Integration

• Type: HTTP requests or native integration

• Actions:

  • Create email sequence/automation

  • Add each email with proper timing

  • Set trigger conditions

  • Configure tags/segments

Node 6: Test Trigger

• Type: Email to yourself

• Purpose: Send test version of first email

• Include: Link to platform to review full sequence

Node 7: Documentation

• Type: Notion or Google Docs

• Create: Sequence documentation page with:

  • All email copy (for reference)

  • Timing overview

  • Success metrics to track

  • Iteration notes

Node 8: Completion Notification

• Type: Slack

• Message:

✅ Onboarding Sequence Created

Product: [Name]
Platform: [ConvertKit/etc.]
Emails: 8
Total sequence length: 30 days

Review in [Platform]: [Link]
Documentation: [Notion link]

Test email sent to your inbox.

Next steps:
1. Review test email
2. Check sequence in platform
3. Activate automation
4. Set up tracking dashboard

Cost: ~$37-97/month

Option 4: Lindy AI Agent

Agent Name: "Onboarding Architect Agent"

Configuration:

You are my Onboarding Architect Agent. Your job is to create complete, production-ready email onboarding sequences that turn new customers into successful, retained customers.

TRIGGERS:
- I message you with "New onboarding:" followed by product details
- New row added to "Onboarding Requests" spreadsheet
- Email to onboarding@[domain] with product brief

WORKFLOW:

1. GATHER context (ask if not provided):
   - Product/service name and description
   - Price point
   - Primary outcome customers achieve
   - Common obstacles in first 30 days
   - What current onboarding looks like
   - Email platform being used

2. GENERATE complete 8-email sequence:
   - Follow the Welcome → Quick Win → Obstacle → Engagement → Proof → Advanced → Check-in → Success structure
   - Write complete copy for every email (not outlines)
   - Include subject lines, preview text, body, CTA
   - Specify exact send timing

3. OPTIMIZE each email:
   - Run each through editing pass for:
     - Clarity (is it scannable?)
     - Length (under 300 words?)
     - CTA clarity (one clear action?)
     - Mobile formatting (short paragraphs?)

4. CREATE deliverables:
   - Google Doc with all email copy (formatted for easy copying)
   - Sequence timing diagram
   - Platform-specific loading instructions
   - Tracking recommendations (what metrics to watch)

5. LOAD into email platform (if I grant access):
   - Create automation/sequence
   - Add all emails with proper delays
   - Set up trigger
   - Configure tags

6. NOTIFY me with:
   - Summary of sequence
   - Link to copy document
   - Link to platform (if loaded)
   - Recommendations for A/B tests
   - Suggested iteration schedule

QUALITY RULES:
- Every email must have ONE clear purpose
- Subject lines must be under 10 words
- Body copy must be scannable on mobile
- CTAs must be specific ("Start your first project" not "Click here")
- Include merge tags for personalization where appropriate
- Suggest segmentation if different customer types need different paths

EMAIL PLATFORM NOTES:
- ConvertKit: Use their visual automation builder
- ActiveCampaign: Set up as automation, not campaign
- HubSpot: Use workflow with enrollment trigger
- Mailchimp: Customer journey builder

Why This Works

Onboarding is the highest-leverage customer success activity. Get it right, and:

• First-week engagement predicts 90-day retention

• Quick wins reduce refund requests dramatically

• Proper sequences identify struggling users before they churn

• Automated onboarding scales without adding headcount

The problem is that writing 8 emails with proper copy, timing, and strategy takes 8-16 hours. Nobody has that time, so onboarding stays broken.

This system removes the creation bottleneck. You input your knowledge; it outputs a complete, ready-to-use sequence.

The compound effect:

• Higher activation rates (more customers actually use what they bought)

• Lower refund rates (buyer's remorse gets addressed early)

• Higher retention (successful customers stay)

• More referrals (successful customers refer)

• Better unit economics (all of the above)

That’s all I got for this issue.

Here's what I want you to take from today:

AI isn't most valuable when it's analyzing. It's most valuable when it's producing.

Each automation in this issue creates a real asset:

• Proposals that close deals

• SOPs that let you delegate and scale

• Onboarding sequences that retain customers

These are deliverables you can use immediately.

Pick the one your business needs most:

• Losing deals because proposals take too long? → Proposal Generator

• Can't delegate because nothing's documented? → SOP Factory

• Customers churning because onboarding is weak? → Onboarding Sequence Builder

Build it this week. Feel the weight lift when a 4-hour task becomes a 15-minute task.

Then come back and build the other two.

Your future self will thank you.

Until next time,
Sam Woods
The Editor

.