Funding Signal Outreach

Detects recent funding events across a set of companies, qualifies them against your company's context, finds the right people to reach out to, and drafts personalized emails. The full chain from signal to outreach-ready.

When to Auto-Load

Load this composite when:

• User says "check if any of these companies raised funding", "funding signal outreach", "reach out to recently funded companies"
• User has a list of companies and wants to act on funding signals
• An upstream workflow (TAM Pulse, company monitoring) triggers a funding signal check

Architecture

This composite is tool-agnostic. Each step defines a data contract (what goes in, what comes out). The specific tools that fulfill each step are configured once per client/user, not asked every run.

┌─────────────────────────────────────────────────────────────────┐
│                  FUNDING SIGNAL OUTREACH                        │
│                                                                 │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐    │
│  │  DETECT  │──▶│ QUALIFY  │──▶│  FIND    │──▶│  DRAFT   │    │
│  │ Funding  │   │ & Rank   │   │  People  │   │  Emails  │    │
│  └──────────┘   └──────────┘   └──────────┘   └──────────┘    │
│       │              │              │              │            │
│  Input: companies  + your company  + buyer       + signal      │
│  Tool: web search    context        personas      context      │
│    or apollo         (LLM)         Tool: apollo   (LLM)       │
│    or crunchbase                     or linkedin              │
│    or any                            or clearbit              │
│                                      or any                   │
└─────────────────────────────────────────────────────────────────┘

Step 0: Configuration (One-Time Setup)

On first run for a client/user, collect and store these preferences. Skip on subsequent runs.

Company Source Config

Signal Detection Config

Contact Finding Config

Outreach Config

Your Company Context

Store config in: clients/<client-name>/config/signal-outreach.json or equivalent.

Step 1: Detect Funding Signals

Purpose: For each company in the input list, determine if they have raised funding within the lookback window.

Input Contract

companies: [
  {
    name: string          # Required
    domain: string        # Required
    industry?: string     # Optional, helps qualification
    size?: string         # Optional
    location?: string     # Optional
  }
]
lookback_days: integer    # From config (default: 30)

Process

For each company (or in batches):

1. Search for funding announcements using the configured signal_tool:

   • Web search: Query "{company_name}" AND ("raised" OR "funding" OR "Series") AND "2026" for each company
   • Apollo: Use company enrichment endpoint to pull funding data
   • Crunchbase: Query funding rounds API filtered by date
   • Any other tool: Must return the same output contract

2. Extract funding details from results:

   • Did they raise? (yes/no)
   • How much?
   • What stage? (Seed, A, B, C, D+)
   • When? (exact date or approximate)
   • Who led the round? (investors)
   • Source URL (for verification)

3. Filter: Drop companies with no funding signal detected.

Output Contract

funded_companies: [
  {
    name: string
    domain: string
    industry: string
    funding_amount: string        # e.g. "$15M"
    funding_stage: string         # e.g. "Series A"
    funding_date: string          # ISO date or "March 2026"
    lead_investors: string[]      # e.g. ["Sequoia", "a16z"]
    source_url: string            # Link to announcement
    confidence: "high" | "medium" # High = multiple sources or official PR
    original_company_data: object # Pass through all original fields
  }
]

Human Checkpoint

Present results as a table:

Found funding signals for X of Y companies:
 
| Company | Amount | Stage | Date | Investors | Confidence |
|---------|--------|-------|------|-----------|------------|
| Acme    | $15M   | Series A | 2026-02-15 | Sequoia | High |
| ...     | ...    | ...   | ...  | ...       | ...        |
 
Proceed with qualification? (Y/n)

Step 2: Qualify & Prioritize

Purpose: Given funded companies + your company context, rank them by outreach priority. This step is pure LLM reasoning — inherently tool-agnostic.

Input Contract

funded_companies: [...]           # From Step 1 output
your_company: {
  description: string             # From config
  pain_point: string              # From config
  buyer_personas: string[]        # From config
  proof_points: string[]          # From config
  price_tier: string              # From config
}

Process

For each funded company, evaluate:

Scoring

Assign each company a priority tier:

• Tier 1 (Act Today): Stage fit + industry relevance + funded within 14 days
• Tier 2 (Act This Week): Two of three criteria met, or funded 15-30 days ago with strong fit
• Tier 3 (Queue): Marginal fit or funding 30+ days old. Worth reaching out but not urgent.
• Drop: No relevance to your product/market. Remove from pipeline.

For each qualified company, generate:

• Relevance reasoning: 1-2 sentences on why this company would care about your product right now
• Outreach angle: The specific hook connecting their funding to your product's value
• Recommended approach: Direct pain-point, aspirational growth, or operational efficiency framing

Output Contract

qualified_companies: [
  {
    ...funded_company_fields,
    priority_tier: "tier_1" | "tier_2" | "tier_3"
    relevance_reasoning: string
    outreach_angle: string
    recommended_approach: string
    estimated_team_size: string    # Post-raise estimate
  }
]
dropped_companies: [
  {
    name: string
    drop_reason: string
  }
]

Human Checkpoint

Present qualified companies grouped by tier:

## Qualification Results
 
### Tier 1 — Act Today (X companies)
| Company | Stage | Amount | Angle | Why |
|---------|-------|--------|-------|-----|
| ...     | ...   | ...    | ...   | ... |
 
### Tier 2 — Act This Week (X companies)
| ... |
 
### Tier 3 — Queue (X companies)
| ... |
 
### Dropped (X companies)
| Company | Reason |
|---------|--------|
| ...     | ...    |
 
Approve this list before we find contacts? You can promote, demote, or drop any company.

Step 3: Find Relevant People

Purpose: For each qualified company, find the right people to contact based on your buyer personas.

Input Contract

qualified_companies: [...]        # From Step 2 output
buyer_personas: [                 # From config
  {
    title_patterns: string[]      # e.g. ["VP Sales", "Head of Revenue", "CRO"]
    department: string            # e.g. "Sales", "Engineering"
    seniority: string             # e.g. "VP+", "Director+", "Manager+"
    role_type: "buyer" | "champion" | "user"
  }
]
max_contacts_per_company: integer # Default: 3-5

Process

For each qualified company, use the configured contact_tool:

1. Search for people matching buyer personas:

   • Apollo: People search with company domain + title filters
   • LinkedIn Sales Nav: Company page → filter by title/seniority
   • Clearbit: Prospector API with role filters
   • Web search: site:linkedin.com/in "{company}" "{title}" queries
   • Any other tool: Must return the same output contract

2. For each person found, collect:

   • Full name
   • Current title
   • Email (if available from the tool)
   • LinkedIn URL
   • Role type classification (buyer / champion / user)

3. Prioritize contacts within each company:

   • Buyers first (decision-makers who control budget)
   • Champions second (mid-level who feel the pain daily)
   • Users third (end-users who can advocate bottom-up)

4. Cap at max_contacts_per_company — typically 3-5 people per company to avoid carpet-bombing.

Output Contract

contacts: [
  {
    person: {
      full_name: string
      first_name: string
      last_name: string
      title: string
      email: string | null
      linkedin_url: string | null
      role_type: "buyer" | "champion" | "user"
    }
    company: {
      name: string
      domain: string
      funding_amount: string
      funding_stage: string
      funding_date: string
      priority_tier: string
      outreach_angle: string
      relevance_reasoning: string
    }
  }
]
contacts_without_email: [...]     # Same structure, flagged for manual lookup

Human Checkpoint

Present contacts grouped by company:

## Contacts Found
 
### Acme Corp (Tier 1 — Series A, $15M)
| Name | Title | Role Type | Email | LinkedIn |
|------|-------|-----------|-------|----------|
| Jane Doe | VP Sales | Buyer | jane@acme.com | linkedin.com/in/janedoe |
| John Smith | Sales Manager | Champion | john@acme.com | linkedin.com/in/johnsmith |
 
### Beta Inc (Tier 1 — Series B, $40M)
| ... |
 
Total: X contacts across Y companies (Z without email)
 
Approve before we draft emails?

Step 4: Draft Personalized Emails

Purpose: For each contact, draft a personalized email sequence that connects the funding signal to your product's value. This step is pure LLM reasoning — inherently tool-agnostic.

Input Contract

contacts: [...]                   # From Step 3 output
your_company: {                   # From config
  description: string
  pain_point: string
  proof_points: string[]
}
sequence_config: {
  touches: integer                # Default: 3
  timing: integer[]               # Default: [1, 5, 12] (days)
  personalization_tier: 1 | 2 | 3 # Default: 2
  tone: string                    # Default: "casual-direct"
  cta: string                     # Default: "15-min call"
}

Process

1. Select framework based on signal type:

   • Funding signal → Signal-Proof-Ask (reference the raise, show proof, soft ask)
   • If the funding is for the exact problem you solve → BAB (before/after framing)

2. Build personalization context per contact:

   Field	Source	Example
   Signal reference	Step 1	"Congratulations on the $15M Series A"
   Company context	Step 2	"As you scale the sales team post-raise..."
   Role-specific pain	Step 3 role_type	Buyer → budget/ROI, Champion → daily friction, User → workflow
   Proof point	Config	"Companies like [peer] use us to..."
   Outreach angle	Step 2	"Scale fast with fresh capital"

3. Generate emails following email-drafting skill rules:

   • Touch 1: 50-90 words. Hook with funding signal + proof + soft CTA.
   • Touch 2: 30-50 words. New angle (different proof point or asset offer).
   • Touch 3: 20-40 words. Social proof drop or breakup.
   • All hard rules from email-drafting apply (no filler, no "just checking in", one CTA per email, etc.)

4. By personalization tier:

   • Tier 1: One template per touch with merge fields. Same for all contacts.
   • Tier 2: One template per (role_type + priority_tier) combination. Swap pain points and proof.
   • Tier 3: Unique email per contact. Reference their specific title, company's specific funding context.

Output Contract

email_sequences: [
  {
    contact: { full_name, email, company_name, ... }
    sequence: [
      {
        touch_number: integer
        send_day: integer
        subject: string
        body: string               # With merge fields resolved or ready
        framework: string
        word_count: integer
      }
    ]
  }
]

Human Checkpoint

Present 3-5 sample email sequences (one per tier if Tier 2, one per contact if Tier 3):

## Sample Emails for Review
 
### Contact: Jane Doe, VP Sales @ Acme Corp (Tier 1, Series A $15M)
 
**Touch 1 — Day 1**
Subject: Before the Series A hiring sprint
> Hi Jane — congrats on the raise. As Acme scales the sales team...
> [full email]
 
**Touch 2 — Day 5**
Subject: How [peer company] handled post-raise scaling
> [full email]
 
**Touch 3 — Day 12**
Subject: One last thought
> [full email]
 
---
 
Approve these samples? I'll generate the rest in the same style.
Iterate? Tell me what to change (tone, length, angle, CTA).

After approval, generate remaining emails and output the full set.

Step 5: Handoff to Outreach

Purpose: Package the contacts + email sequences for the configured outreach tool. This step adapts its output format to the tool.

Input Contract

email_sequences: [...]            # From Step 4 output
outreach_tool: string             # From config
outreach_channels: string         # From config

Process

Based on outreach_tool from config:

If outreach_channels includes LinkedIn:

• Chain to linkedin-outreach skill for LinkedIn message sequences
• Output CSV for LinkedIn automation tool (Dripify, Expandi, etc.)

Output Contract

campaign_package: {
  tool: string
  file_path: string               # Path to CSV or campaign ID
  contact_count: integer
  sequence_touches: integer
  estimated_send_days: integer
  next_action: string             # "Upload to [tool]" or "Campaign created, activate when ready"
}

Human Checkpoint

## Campaign Ready
 
Tool: Smartlead (or CSV export, etc.)
Contacts: 23 people across 8 companies
Sequence: 3 touches over 12 days
File: skills/composites/funding-signal-outreach/output/{campaign-name}-{date}.csv
 
Ready to launch? (This is the final gate before emails are sent or files are created)

Execution Summary

Total human review time: ~15-20 minutes to go from "here are my target companies" to "outreach is live."

Tips

• Run weekly — funding signals have a 1-3 week outreach window before the company is flooded with vendor pitches
• Tier 1 companies should be contacted within 48 hours of the funding announcement for maximum impact
• 3-5 contacts per company is the sweet spot. More than that and you risk the "we're being carpet-bombed" effect
• Signal-Proof-Ask framework works best for funding signals because the signal itself is the hook
• Don't mention the funding amount in the email unless it's public and impressive. Focus on what the funding means for them (growth, hiring, new tools), not the number itself