How to Add New Campaign Types

Purpose: Step-by-step guide for adding new campaign types and sequences
Audience: GTM team, developers, AI prompt engineers
Time Required: 30-60 minutes per campaign type
Last Updated: 2026-01-26

Overview

Adding a new campaign type involves:

Research & Planning (15 minutes) - Define use case, segments, personas
Playbook Creation (30 minutes) - Write markdown playbook with sequences
Schema Updates (5 minutes) - Add types and interfaces
Code Integration (10 minutes) - Import and configure in agent
Testing (15 minutes) - Validate with test triggers

Total Time: ~60 minutes from idea to production

Step-by-Step Guide

Step 1: Research & Planning (15 minutes)

1.1 Define the Use Case

Answer these questions:

Campaign Basics:

What’s the trigger for this campaign? (e.g., form submission, event, milestone)
What’s the goal? (meeting booked, demo requested, content downloaded)
Who is the target audience?
Why is this campaign needed? (gap in existing campaigns)

Example:

Campaign: Product Demo Request
Trigger: Demo form submission on website
Goal: Schedule demo within 48 hours
Audience: Prospects who requested demo (warm inbound)
Why: Current campaigns don't handle demo requests specifically

1.2 Identify Segments

What are the different variations within this campaign?

Segment Criteria:

Company stage (early-stage, scale-up, enterprise)
Request urgency (immediate need vs exploratory)
Use case specificity (knows exactly what they want vs exploring options)
Previous engagement (new lead vs returning visitor)

Example Segments:

1. Immediate Need - Enterprise: Large company, specific use case, urgent
2. Immediate Need - Startup: Small company, fast-moving, quick decision
3. Exploratory - Technical: Engineer/practitioner exploring options
4. Exploratory - Executive: C-level/VP evaluating vendors

1.3 Map Personas

For each segment, which personas will you encounter?

Standard Personas:

Executive: C-level, VPs (ROI-focused, concise)
Practitioner: Engineers, analysts (technical, tactical)
Champion: Internal advocate (enablement-focused)
Blocker: Skeptical, risk-averse (proof-driven)

Example Mapping:

Segment: Immediate Need - Enterprise
Personas: Executive (60%), Champion (30%), Blocker (10%)

Segment: Exploratory - Technical
Personas: Practitioner (80%), Champion (20%)

1.4 Draft Sequence Strategy

How many touchpoints? What channels? What timing?

Sequence Planning:

Length: 2-6 touchpoints (shorter for warm, longer for cold)
Timing: Days between touchpoints (faster for warm/urgent)
Channels: Email, LinkedIn, phone, video
Fallbacks: What happens if no response?

Example:

Sequence: Immediate Need - Enterprise - Executive

Step 1 (Immediate): Email - Confirm receipt, propose time
Step 2 (4 hours later): Email - Share agenda, case study
Step 3 (Day 2): Phone call - Personal outreach
Fallback: If no response after 3 days, send async Loom demo

Step 2: Playbook Creation (30 minutes)

2.1 Create Playbook File

Create new markdown file in playbooks/ directory:

touch gtm/agents/playbooks/[campaign-name]-playbook.md

File naming convention:

Lowercase, hyphenated
Descriptive but concise
Examples: product-demo-playbook.md, referral-request-playbook.md

2.2 Use Playbook Template

Copy this template structure:

# [Campaign Name] Playbook
 
> **Purpose**: [One-line description]
> **Use Case**: [When to use this campaign]
> **Key Principle**: [Core messaging principle]
> **Last Updated**: [Date]
 
---
 
## Overview
 
**Use Case:** [Detailed description]
**Goal:** [Specific measurable outcome]
**Key Principle:** [Guiding principle for messaging]
 
**Success Rate Target:**
- Response Rate: [X]%
- [Metric 2]: [Target]%
- [Metric 3]: [Target]%
 
---
 
## Segmentation Strategy
 
### Segment 1: [Name]
 
- **Context**: [When this segment applies]
- **Engagement Level**: [Light/Moderate/High/Very High]
- **Urgency**: [Low/Medium/High]
- **Personalization Angle**: [What to personalize on]
- **Example Context**: "[Sample opening line]"
 
### Segment 2: [Name]
...
 
---
 
## Persona-Based Messaging
 
### Persona 1: [Executive/Practitioner/Champion/Blocker]
 
**Tone & Style:**
- [Style description]
- [Key characteristic]
 
**Key Messages:**
- [Message 1]
- [Message 2]
- [Message 3]
 
**What to Avoid:**
- [Anti-pattern 1]
- [Anti-pattern 2]
 
**Example Opening:**

[Sample opening line or paragraph]


**Example Value Prop:**

[Sample value proposition]


**Example CTA:**

[Sample call-to-action]


**Timing**: [Number] steps over [Number] days

---

## Multi-Step Sequences

### Sequence 1: [Segment] - [Persona] ([N] steps, [X] days)

**Total Duration**: [X] days  
**Expected Conversion**: [X]% to [goal]

#### Step 1: [Step Name] (Day [N])

**Channel**: Email/LinkedIn/Phone  
**Goal**: [Specific goal for this step]

**Template**:

Subject: [Subject template]

[Body template with [PERSONALIZATION] markers]

[CTA]


**Personalization Checklist**:
- [ ] [Personalization requirement 1]
- [ ] [Personalization requirement 2]
- [ ] [Personalization requirement 3]

**Success Criteria**: [X]% response within [timeframe]

---

#### Step 2: [Step Name] (Day [N])
...

---

## Success Metrics by Segment

| Segment | Response Rate | [Metric 2] | [Metric 3] |
|---------|---------------|------------|------------|
| [Segment 1] | [X]% | [Y]% | [Z]% |
| [Segment 2] | [X]% | [Y]% | [Z]% |

---

## Common Mistakes to Avoid

### ❌ [Mistake 1]
- **Mistake**: [Description]
- **Fix**: [Solution]
- **Why**: [Reasoning]

### ❌ [Mistake 2]
...

---

## Integration with Message Sequence Agent

### Trigger Example

```typescript
{
  source: 'form-submission',
  triggeredAt: Date.now(),
  
  prospect: { ... },
  
  context: {
    [campaign-specific context fields]
  },
}

Campaign Classification

AI should classify as:

Campaign Type: [campaign-type-slug]
Segment: [list of possible segments]
Persona: Based on title/role
Sequence Length: [N] steps
Priority: [high/medium/low]


#### 2.3 Fill in Template with Real Content

**Key Sections to Focus On**:

1. **Segmentation Strategy**: Be specific about what differentiates each segment
2. **Persona Messaging**: Include real examples, not generic templates
3. **Multi-Step Sequences**: Write actual email templates with personalization markers
4. **Success Metrics**: Use realistic targets based on similar campaigns

**Tips**:
- Include 3-5 real examples in each section
- Use actual language you've used successfully before
- Be prescriptive about what to do/say, not just principles
- Include anti-patterns (what NOT to do)

---

### Step 3: Schema Updates (5 minutes)

#### 3.1 Add Campaign Type to Enum

**File**: `gtm/agents/CAMPAIGN_TYPES_SCHEMA.md`

**Update**:
```typescript
export type CampaignType =
  | 'event-follow-up'
  | 'mutual-intro'
  | 'partnership-outreach'
  | 'product-launch'
  | 'content-syndication'
  | 're-engagement'
  | 'cold-outbound'
  | 'referral-request'
  | 'product-demo-request'  // ← Add new campaign type
  | 'your-new-campaign';    // ← Add your campaign type

3.2 Define Segment Type

Add segment type for your campaign:

// In CAMPAIGN_TYPES_SCHEMA.md
 
export type YourCampaignSegment =
  | 'segment-1'
  | 'segment-2'
  | 'segment-3';

3.3 Define Context Interface

Create context interface with campaign-specific fields:

export interface YourCampaignContext {
  // Required fields
  specificField1: string;
  specificField2: Date;
  
  // Optional fields
  additionalContext?: string;
  metadata?: Record<string, any>;
}

Example:

export interface ProductDemoRequestContext {
  requestDate: Date;
  demoType: 'live' | 'recorded' | 'self-service';
  useCase?: string;
  urgency: 'immediate' | 'this-week' | 'this-month' | 'exploratory';
  teamSize?: string;
  currentTools?: string[];
  formResponses?: Record<string, string>;
}

3.4 Add to Campaign Classification Schema

Update the campaignClassificationSchema to include your new campaign type:

export const campaignClassificationSchema = z.object({
  campaignType: z.enum([
    'event-follow-up',
    'mutual-intro',
    // ... other types
    'your-new-campaign',  // ← Add here
  ]),
  // ... rest of schema
});

Step 4: Code Integration (10 minutes)

4.1 Create Playbook Import

File: lib/playbooks/your-campaign.ts

// Read playbook markdown
import fs from 'fs';
import path from 'path';
 
const playbookPath = path.join(
  process.cwd(),
  'gtm/agents/playbooks/your-campaign-playbook.md'
);
 
export const yourCampaignPlaybook = {
  type: 'your-campaign' as const,
  content: fs.readFileSync(playbookPath, 'utf-8'),
  version: '1.0.0',
  lastUpdated: new Date('2026-01-26'),
};

4.2 Update Playbook Registry

File: lib/playbooks/index.ts

import { eventFollowUpPlaybook } from './event-follow-up';
import { mutualIntroPlaybook } from './mutual-intro';
import { yourCampaignPlaybook } from './your-campaign';  // ← Import
 
export const playbookRegistry = {
  'event-follow-up': eventFollowUpPlaybook,
  'mutual-intro': mutualIntroPlaybook,
  'your-campaign': yourCampaignPlaybook,  // ← Add to registry
  // ... other playbooks
} as const;
 
export function getPlaybook(campaignType: CampaignType) {
  return playbookRegistry[campaignType];
}

4.3 Update Classifier Prompt (Optional)

If your campaign needs specific classification logic, update the classifier prompt:

File: lib/services/classifier.ts

const CLASSIFIER_PROMPT = `
Classify this campaign based on the trigger context and research report.
 
Campaign Types:
- event-follow-up: Post-event outreach
- mutual-intro: Warm introduction
// ... other types
- your-campaign: [Description of when to use]  // ← Add description
 
When to use 'your-campaign':
- [Specific trigger condition 1]
- [Specific trigger condition 2]
- [Specific trigger condition 3]
`;

4.4 Add Trigger Recognition (If Needed)

If your campaign has a unique trigger endpoint:

File: app/api/trigger/your-campaign/route.ts

import { NextRequest, NextResponse } from 'next/server';
import { startSequenceWorkflow } from '@/workflows/sequence';
 
export async function POST(request: NextRequest) {
  const body = await request.json();
  
  // Validate trigger
  const trigger = {
    source: 'form-submission',
    triggeredAt: new Date(),
    prospect: {
      email: body.email,
      name: body.name,
      company: body.company,
    },
    context: {
      // Campaign-specific context
      specificField1: body.specificField1,
      specificField2: body.specificField2,
    },
  };
  
  // Start workflow
  const workflowId = await startSequenceWorkflow(trigger);
  
  return NextResponse.json({ success: true, workflowId });
}

Step 5: Testing (15 minutes)

5.1 Create Test Trigger

File: tests/fixtures/your-campaign-trigger.json

{
  "source": "manual-trigger",
  "triggeredAt": "2026-01-26T12:00:00Z",
  "prospect": {
    "email": "test@example.com",
    "name": "Test Prospect",
    "company": "Test Company",
    "title": "VP of Engineering"
  },
  "context": {
    "specificField1": "value1",
    "specificField2": "2026-01-26T12:00:00Z"
  }
}

5.2 Test Campaign Classification

Run classifier with test data:

curl -X POST http://localhost:3000/api/classify \
  -H "Content-Type: application/json" \
  -d @tests/fixtures/your-campaign-trigger.json

Expected Output:

{
  "campaignType": "your-campaign",
  "segment": "segment-1",
  "persona": "executive",
  "sequenceLength": 3,
  "priority": "high",
  "reasoning": "..."
}

5.3 Test Sequence Generation

Run full workflow:

curl -X POST http://localhost:3000/api/trigger \
  -H "Content-Type: application/json" \
  -d @tests/fixtures/your-campaign-trigger.json

Check:

5.4 Test Slack Approval

Check Slack channel for approval request
Verify all information is displayed correctly
Test each action:
- ✅ Approve
- ✏️ Edit
- 🔍 View Full Sequence
- ❌ Reject
Confirm workflow continues/stops appropriately

5.5 Test End-to-End

Full E2E Test:

Trigger campaign
Approve in Slack
Verify sequence is queued
Check CRM for sequence tracking
Monitor first message send
Verify engagement tracking works

Quick Reference Checklist

Use this checklist when adding a new campaign:

Planning Phase

Defined use case and goal
Identified 3-5 segments
Mapped personas to segments
Drafted sequence strategy (length, timing, channels)

Playbook Creation

Created playbook markdown file
Filled in Overview section
Documented all segments with examples
Wrote persona-based messaging for each
Created 2-3 complete multi-step sequences
Included success metrics
Added common mistakes section
Provided integration example

Schema Updates

Added campaign type to enum
Defined segment type
Created context interface
Updated classification schema

Code Integration

Created playbook import file
Updated playbook registry
Added to classifier prompt (if needed)
Created trigger endpoint (if needed)

Testing

Documentation

Updated main architecture doc (if needed)
Added to campaign list in README
Documented any special considerations
Shared with team for feedback

Common Patterns

Pattern 1: Inbound vs Outbound

Inbound (form submission, demo request, content download):

Shorter sequences (2-3 steps)
Faster timing (hours/days, not weeks)
Higher response expectations (60-80%)
Focus on scheduling/next steps

Outbound (cold prospecting, partnership outreach):

Longer sequences (4-6 steps)
Slower timing (days/weeks)
Lower response expectations (15-30%)
Focus on value-add and personalization

Pattern 2: Warm vs Cold

Warm (intro, referral, event follow-up):

Acknowledge source immediately
Move with urgency
Reference shared context
Higher approval rate in Slack (80%+)

Cold (no prior relationship):

Lead with research insight
Build credibility gradually
Provide value before asking
Higher edit rate in Slack (30-40%)

Pattern 3: Transactional vs Relationship

Transactional (quick win, specific ask):

Clear CTA from step 1
Short sequence (2-3 steps)
Direct language
Fast follow-up timing

Relationship (long-term partner, enterprise deal):

Softer CTA in step 1
Longer sequence (4-6 steps)
Consultative language
Slower follow-up timing

Examples from Existing Campaigns

Example 1: Event Follow-Up

Use Case: Follow up after conference/event

Key Decisions:

5 segments (booth visitor, panelist, VIP dinner, meeting log, general attendee)
3-5 step sequences depending on engagement level
Very fast timing (first email within 24 hours)
Heavy personalization on event context

File: gtm/agents/playbooks/event-follow-up-playbook.md

Example 2: Mutual Introduction

Use Case: Warm intro from investor/customer/partner

Key Decisions:

4 segments (warm exec, warm peer, cold with context, multi-hop)
3-4 step sequences
Immediate first response (within 4-8 hours)
Always honor the introducer

File: gtm/agents/playbooks/mutual-intro-playbook.md

Example 3: Cold Outbound

Use Case: Proactive outreach to ICP

Key Decisions:

4 segments (funded startup, scale-up, enterprise, geographic expansion)
3-5 step sequences depending on persona
Research-heavy (10 min per prospect)
Multiple personalization levels

File: gtm/agents/playbooks/cold-outbound-playbook.md

Troubleshooting

Issue: Campaign not being classified correctly

Symptoms: AI classifies as wrong campaign type

Debug:

Check classifier prompt - is your campaign described clearly?
Review trigger context - are all required fields present?
Test with more specific context data
Add campaign type to classifier prompt with clear distinguishing features

Fix: Update classifier prompt with clearer differentiation

Issue: Generated sequences don’t match playbook

Symptoms: Sequences are generic or off-brand

Debug:

Check playbook quality - are examples specific enough?
Review sequence templates - are personalization markers clear?
Test with different research data - does more context help?
Check generator prompt - is it using playbook correctly?

Fix: Add more specific examples to playbook, improve templates

Issue: Slack approval requests timing out

Symptoms: High timeout rate on approvals

Debug:

Check timeout settings (24 hours is default)
Review approval channel activity - is team seeing requests?
Check reminder timing (4 hours is default)
Review approval UX - is it clear what needs to be done?

Fix: Adjust timeout, send more frequent reminders, improve message format

Issue: Low response rates on new campaign

Symptoms: Response rates below target

Debug:

A/B test different message approaches
Review personalization depth
Check timing of follow-ups
Analyze rejection/opt-out reasons
Compare to similar campaigns

Fix: Iterate on messaging, improve personalization, adjust timing

Resources

Examples

Documentation

Getting Help

Questions?

Review existing playbooks for patterns
Check schema documentation for types
Test with sample data first
Ask team for feedback on draft playbook

Need Review?

Share playbook draft with GTM team
Test with 5-10 manual triggers
Review approval rates and edits
Iterate based on feedback

Next Steps After Adding Campaign

Monitor Performance:
- Track approval rates in Slack
- Measure response rates
- Review edit patterns
- Collect feedback from prospects
Iterate:
- Update playbook based on what works
- Add new segments as you learn
- Refine sequence timing
- Improve personalization depth
Scale:
- Increase volume gradually
- Monitor quality metrics
- Train team on new campaign
- Document learnings
Share:
- Present to GTM team
- Share success stories
- Document best practices
- Help others add similar campaigns

Remember: The best playbooks are living documents. Start simple, test, learn, iterate.

Brainforge Knowledge

Explorer

HOW_TO_ADD_CAMPAIGNS

How to Add New Campaign Types

Overview

Step-by-Step Guide

Step 1: Research & Planning (15 minutes)

1.1 Define the Use Case

1.2 Identify Segments

1.3 Map Personas

1.4 Draft Sequence Strategy

Step 2: Playbook Creation (30 minutes)

2.1 Create Playbook File

2.2 Use Playbook Template

Campaign Classification

Related Documentation

3.2 Define Segment Type

3.3 Define Context Interface

3.4 Add to Campaign Classification Schema

Step 4: Code Integration (10 minutes)

4.1 Create Playbook Import

4.2 Update Playbook Registry

4.3 Update Classifier Prompt (Optional)

4.4 Add Trigger Recognition (If Needed)

Step 5: Testing (15 minutes)

5.1 Create Test Trigger

5.2 Test Campaign Classification

5.3 Test Sequence Generation

5.4 Test Slack Approval

5.5 Test End-to-End

Quick Reference Checklist

Planning Phase

Playbook Creation

Schema Updates

Code Integration

Testing

Documentation

Common Patterns

Pattern 1: Inbound vs Outbound

Pattern 2: Warm vs Cold

Pattern 3: Transactional vs Relationship

Examples from Existing Campaigns

Example 1: Event Follow-Up

Example 2: Mutual Introduction

Example 3: Cold Outbound

Troubleshooting

Issue: Campaign not being classified correctly

Issue: Generated sequences don’t match playbook

Issue: Slack approval requests timing out

Issue: Low response rates on new campaign

Resources

Templates

Examples

Documentation

Getting Help

Next Steps After Adding Campaign

Graph View

Table of Contents

Backlinks