ElasticFlow
AI SkillRun OutreachSalesby Gooseworks

Funding Signal Outreach — funded company → personalized sequence

Runs on
ClaudeClaudeChatGPTChatGPTOpenClawOpenClaw

End-to-end funding-triggered outbound with personalized sequences

  • Detects recent funding events for target companies
  • Qualifies each event against your ICP
  • Finds buyers, champions, and users at the funded company
  • Drafts personalized email sequences with funding hooks
  • Tool-agnostic — works with any outreach platform

Who this is for

SDR / BDR

Research done, emails drafted, meetings booked. These skills multiply your output without sacrificing personalization.

See skills for this role

What it does

Outbound on funding signal

Convert every funding announcement into a personalized outbound sequence within 48 hours.

Build a funding-driven SDR motion

Run weekly to fill SDR pipeline entirely from funding signals.

Land-and-expand on growth-stage accounts

Trigger outbound at the moment companies have budget and momentum to evaluate new tools.

How it works

1

Take ICP and target company list as input

2

Detect recent funding via the funding-signal-monitor source

3

Qualify ICP fit and find relevant contacts

4

Draft personalized 3-touch sequences referencing the funding

5

Hand off to outreach tool

Metrics this improves

Meeting Rate
More meetings booked from time-sensitive funding-signal outreach
Sales
Reply Rate
Higher reply rate when outreach references a fresh, specific funding event
Sales

Works with

Crunchbase
manual

Source funding round details

Apollo
API

Find contacts at funded companies

Similar skills

Auto-suggested by attribute overlap. Side-by-side comparison shows what differs.

Compare all 4 →

Disqualification Handling

by Gooseworks
↳funding-roundvsintent-data(Trigger signal)·one-to-onevssegment(Personalization depth)·meeting-bookedvsno-handoff(Handoff stage)

Get Qualified Leads from Luma Events

by Gooseworks
↳funding-roundvsevent-attendance(Trigger signal)·one-to-onevssegment(Personalization depth)·meeting-bookedvssql(Handoff stage)

Inbound Lead Qualification

by Gooseworks
↳BANTvsBANT, MEDDIC(Sales methodology)·funding-roundvsintent-data(Trigger signal)·meeting-bookedvssql(Handoff stage)
Sorted by attribute overlap × differentiation. Funding Signal Outreach shares 21+ attributes with each.
View on GitHub

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

QuestionOptionsStored As
Where does your company list come from?CSV file / Salesforce / HubSpot / Supabase / Manual listcompany_source
What fields identify a company?At minimum: company name + domain. Optional: industry, size, locationcompany_fields

Signal Detection Config

QuestionOptionsStored As
How should we detect funding signals?Web search (free) / Apollo / Crunchbase API / PitchBooksignal_tool
How far back should we look?7 / 14 / 30 / 60 / 90 dayslookback_days

Contact Finding Config

QuestionOptionsStored As
How should we find contacts at these companies?Apollo / LinkedIn Sales Nav / Clearbit / Web search / Manualcontact_tool
Do you have API access?Yes (provide key) / No (use free tier or web search)contact_api_access

Outreach Config

QuestionOptionsStored As
Where do you want outreach sent?Smartlead / Instantly / Outreach.io / Lemlist / Apollo / CSV exportoutreach_tool
Email or multi-channel?Email only / Email + LinkedInoutreach_channels

Your Company Context

QuestionPurposeStored As
What does your company do? (1-2 sentences)Qualification + email personalizationcompany_description
What problem do you solve?Email hookpain_point
Who are your ideal buyers? (titles, departments)Contact finding filtersbuyer_personas
Name 2-3 proof points (customers, metrics, results)Email credibilityproof_points
What's your product's price range? (SMB / Mid-Market / Enterprise)Funding stage qualificationprice_tier

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:

CriterionWeightHow to Assess
Stage fitHighDoes the funding stage match your price tier? Series A → SMB/mid-market tools. Series C → enterprise.
Industry relevanceHighIs their industry one where your product solves a real problem?
Timing urgencyMediumHow recent is the funding? <14 days = urgent window. 30-60 days = still viable. 60+ = cooling.
Size signalMediumPost-raise team size estimate. Do they have enough people to need your product?
Round sizeLowLarger rounds = more budget for tooling. But even small rounds trigger vendor evaluation.

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 | [email protected] | linkedin.com/in/janedoe |
| John Smith | Sales Manager | Champion | [email protected] | 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:

    FieldSourceExample
    Signal referenceStep 1"Congratulations on the $15M Series A"
    Company contextStep 2"As you scale the sales team post-raise..."
    Role-specific painStep 3 role_typeBuyer → budget/ROI, Champion → daily friction, User → workflow
    Proof pointConfig"Companies like [peer] use us to..."
    Outreach angleStep 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:

ToolAction
SmartleadChain to cold-email-outreach Phase 4 (Smartlead MCP automation)
InstantlyGenerate Instantly-format CSV
Outreach.ioGenerate Outreach-compatible CSV
LemlistGenerate Lemlist-format CSV
ApolloGenerate Apollo sequence import CSV
CSV exportGenerate generic CSV with all fields

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

StepTool DependencyHuman CheckpointTypical Time
0. ConfigNoneFirst run only5 min (once)
1. DetectConfigurable (web search, Apollo, etc.)Review funded company list2-5 min
2. QualifyNone (LLM reasoning)Approve/adjust tier rankings2-3 min
3. Find PeopleConfigurable (Apollo, LinkedIn, etc.)Approve contact list2-3 min
4. Draft EmailsNone (LLM reasoning)Review sample emails, iterate5-10 min
5. HandoffConfigurable (Smartlead, CSV, etc.)Final launch approval1 min

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