How to Build a Founder Discovery Engine

Teams we spoke with described the same bottleneck: checking profiles one by one, tabbing between databases, with no way to automate what they found or score it against their investment thesis. One corporate innovation team scouting early-stage partnerships put it plainly: they had to go to every single profile manually, across multiple tools, just to assess whether a founder was worth pursuing.

A founder discovery engine solves this by combining off-platform research, structured people search, automated enrichment, and webhook-based monitoring into a single pipeline that delivers scored founder candidates to your deal workflow.

This guide builds that engine in five layers:

1. Off-platform discovery for founders who don't appear in any database yet

2. Structured people search that turns founder signals into API queries

3. Enrichment and scoring that adds context and ranks candidates

4. Continuous monitoring with watchers that alert you when signals fire

5. Delivery into your deal pipeline, whether that's Airtable, Affinity, or a custom CRM

Each layer builds on the previous one. By the end, you'll have a working system that runs continuously and surfaces founders weeks before they show up in traditional databases.

How the engine fits together

Before building each component, it helps to see the full pipeline as a system. The five layers connect in sequence, with each one feeding output into the next:

Source layer. This is where candidates enter the pipeline. Two inputs run in parallel. Off-platform research (incorporation filings, patent databases, accelerator batch lists) produces a seed list of founder names and domains. Structured API search (people search with headline, social post, and liquidity-event filters) produces a broader candidate list from public professional profiles. Both feed into the enrichment layer.

Enrichment layer. Each candidate from the source layer gets enriched with full professional context: work history, education, skills, and company data for their current venture. This turns a name and headline into a structured profile with enough detail to score.

Scoring layer. A rule-based scoring function runs against the enrichment data. Prior founder experience, team growth velocity, investor backing, and other signals get weighted into a single score per candidate. The score determines whether a candidate enters the monitoring layer or gets deprioritized.

Monitoring layer. High-scoring candidates and their companies get added to watchers. These are persistent, webhook-based monitors that fire when something changes: a title update, a new hire, a funding event, a press mention. Instead of re-running searches manually, the system pushes alerts when new information appears.

Delivery layer. Webhook payloads from the monitoring layer route into your deal pipeline. That could be a new row in Airtable, a contact in Affinity or Attio, or a record in a custom database. The investor reviews new candidates on a regular cadence rather than reacting to every individual alert.

The rest of this guide builds each layer with working examples.

Off-platform discovery: finding founders who aren't in any database

The most valuable founders to find early are the ones who haven't created a company profile anywhere yet. They might have filed incorporation papers, registered a domain, or started committing code to a new repository, but they haven't updated their professional profiles or appeared in Crunchbase. These founders are invisible to every API-based tool, which makes manual research the only way to surface them.

This layer produces a seed list of names and domains that you'll feed into the structured search layer.

Incorporation records and trade registries

New business entity filings are public record in most jurisdictions. In the US, the Delaware Division of Corporations lets you search by officer name, incorporation date, and entity type. In the UK, Companies House publishes SH01 forms (share allotment notices) that can reveal stealth-stage funding activity before any press coverage. EU member states maintain trade registers searchable by founder name.

The useful search pattern is filtering new filings by people with prior startup or executive backgrounds. A first-time incorporation filing from someone who previously held a VP-level role at a funded startup is a stronger signal than a generic LLC registration. Cross-reference the officer name against professional profiles to confirm identity and assess background.

Patent filings and academic research

USPTO Patent Public Search and Espacenet index patent applications globally. The signal to watch for is a researcher or technical executive who stops publishing academic papers and files a provisional patent instead. That transition from research to applied IP often precedes a company formation by three to six months.

Search by inventor name if you're tracking specific people, or search by technology classification codes if you're monitoring a sector. Provisional patents (which are cheaper and faster to file) are particularly useful because they indicate early-stage work rather than corporate R&D.

Domain registrations

New domain registrations with WHOIS privacy protection, registered by someone with a known professional identity, are a reliable early signal. Services like DomainTools and SecurityTrails let you monitor new registrations by registrant patterns or by keyword in the domain name itself.

Look for domains that resolve to a "coming soon" page, a single-page site with a waitlist form, or nothing at all. When the registrant matches a known operator or the domain name maps to a technology sector you're tracking, that's a lead worth enriching.

Accelerator and incubator batch lists

Y Combinator publishes its batch companies on launch day, often before those companies have functional websites or any database presence. Techstars, 500 Global, and regional accelerators do the same. These lists are high-signal because the companies have already passed an external filter (the accelerator's selection process) but haven't yet entered the broader funding ecosystem.

Monitor these batch announcements as they happen. The companies that appear here without prior Crunchbase or PitchBook entries are exactly the ones your competitors haven't found yet.

GitHub activity

New repositories from people with strong professional backgrounds can signal early product development. The indicators that separate a real venture from a side project: a README that describes a product (not a tutorial or utility), multiple contributors joining within weeks, consistent commit velocity, and repository naming that suggests commercial intent rather than experimentation.

GitHub profiles also link to professional identities. A developer who recently left a senior role and starts pushing code to a new organization-level repository is worth flagging, especially if the repo is private (visible through contribution activity graphs even when code is hidden).

Conference speaker lists and hackathon results

Founders often speak at niche industry conferences before they announce publicly. DEF CON, NeurIPS, specific vertical conferences in fintech, biotech, or climate tech frequently feature speakers who are between roles or building something new. Hackathon winning teams, particularly from events like ETHGlobal or major university hackathons, occasionally transition directly into companies.

One way to partially automate this: track the social accounts of organizations that host hackathons and accelerator demo days. When they announce winners or graduating cohorts, you get a timestamped list of founding teams before those teams have built any public presence. Pair that with a people enrichment call on each team member to assess backgrounds immediately.

These sources are harder to fully automate than API-based searches, but high in signal quality. A quarterly sweep of upcoming conference speaker lists in your focus sectors can surface founders months before they appear anywhere else.

Structured people search: turning signals into API queries

Off-platform research produces a seed list. Structured people search expands it by querying professional profile data at scale, filtering for the specific combinations of title, background, and company characteristics that indicate founder activity.

The People Discovery API searches across 1B+ profiles with 60+ filters and nested boolean logic. Below are three searches that cover the highest-value founder discovery patterns, each with working API requests.

Search 1: Headline-based stealth detection

This search finds people whose current headline or title contains stealth-related keywords, filtered to the geography and seniority level that match your investment thesis.

Why this works: When someone updates their professional headline to include "founder," "stealth," "building something new," or removes their employer entirely, it's one of the earliest publicly visible signals of a new venture. The filter combination below narrows results to people who are likely building real companies rather than freelancing or between jobs.

Direct API path:

curl -X POST 'https://api.crustdata.com/screener/person/search' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {
          "filter_type": "current_title",
          "type": "(.) ",
          "value": ["founder", "stealth", "building"]
        },
        {
          "filter_type": "current_company_employee_count",
          "type": "<",
          "value": 50
        },
        {
          "filter_type": "region",
          "type": "in",
          "value": ["San Francisco Bay Area", "New York City Metropolitan Area"]
        }
      ]
    },
    "limit": 100
  }'

curl -X POST 'https://api.crustdata.com/screener/person/search' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {
          "filter_type": "current_title",
          "type": "(.) ",
          "value": ["founder", "stealth", "building"]
        },
        {
          "filter_type": "current_company_employee_count",
          "type": "<",
          "value": 50
        },
        {
          "filter_type": "region",
          "type": "in",
          "value": ["San Francisco Bay Area", "New York City Metropolitan Area"]
        }
      ]
    },
    "limit": 100
  }'

curl -X POST 'https://api.crustdata.com/screener/person/search' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {
          "filter_type": "current_title",
          "type": "(.) ",
          "value": ["founder", "stealth", "building"]
        },
        {
          "filter_type": "current_company_employee_count",
          "type": "<",
          "value": 50
        },
        {
          "filter_type": "region",
          "type": "in",
          "value": ["San Francisco Bay Area", "New York City Metropolitan Area"]
        }
      ]
    },
    "limit": 100
  }'

What comes back: Each result includes the person's name, current title, current company, location, profile URL, and headline. Scan the results for patterns: multiple people listing the same unknown company, titles that include "co-founder" paired with a company name you haven't seen before, or headlines describing a problem space rather than a role.

What to do with the results: Export the list of unique company names from the results. Any company that appears with two or more people claiming founder or C-suite titles is worth enriching immediately. Single-person results go into a watch list for monitoring (covered in the monitoring section).

MCP path: If you're running a Claude Code agent with Crustdata's MCP server configured, you can run the same search conversationally. Ask the agent: "Search for people with 'founder' or 'stealth' in their title, at companies with fewer than 50 employees, in the San Francisco Bay Area." The MCP server translates this into the same API call. This is useful for ad-hoc exploration before committing to a recurring automated search.

Search 2: Social post signals

This search finds people who are publicly signaling that they're starting something new, through their social posts rather than their profile fields.

Why this works: Founders often announce their plans in social posts before updating their formal profile. Posts like "excited to share what I've been building," "leaving [company] to pursue something new," or "looking for a founding engineer" are high-confidence signals that arrive days or weeks before any title change. A founder intelligence platform we spoke with tracks these posts at scale as one of their primary discovery signals, because the language in a social post is more revealing than a headline update.

Direct API path:

The Posts Keyword Search API searches social posts in real time by keyword, with optional filters for author industry and title:

curl -X POST 'https://api.crustdata.com/screener/linkedin_posts/keyword_search/' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "keyword": "leaving to start OR building something new OR founding a company",
    "limit": 50,
    "date_posted": "past-week",
    "filters": [
      {
        "filter_type": "AUTHOR_TITLE",
        "value": ["VP", "Director", "Head of", "Principal", "Staff"]
      }
    ]
  }'

curl -X POST 'https://api.crustdata.com/screener/linkedin_posts/keyword_search/' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "keyword": "leaving to start OR building something new OR founding a company",
    "limit": 50,
    "date_posted": "past-week",
    "filters": [
      {
        "filter_type": "AUTHOR_TITLE",
        "value": ["VP", "Director", "Head of", "Principal", "Staff"]
      }
    ]
  }'

curl -X POST 'https://api.crustdata.com/screener/linkedin_posts/keyword_search/' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "keyword": "leaving to start OR building something new OR founding a company",
    "limit": 50,
    "date_posted": "past-week",
    "filters": [
      {
        "filter_type": "AUTHOR_TITLE",
        "value": ["VP", "Director", "Head of", "Principal", "Staff"]
      }
    ]
  }'

What comes back: Each result includes the post text, author name, author headline, profile URL, date posted, and engagement metrics (reactions, comments, shares). Posts with high engagement from senior operators are the strongest signals, because the author's network is validating the move.

What to do with the results: Read the post text to determine what the person is building and how far along they are. Some posts are aspirational ("thinking about starting something") while others are concrete ("we just closed our first design partner"). Filter for the concrete ones. For each promising author, run a People Enrichment call to get their full background, then decide whether to add them to your monitoring layer.

MCP path: "Search social posts from the past week containing 'leaving to start' or 'building something new', filtered to authors with VP, Director, or Head of titles." The agent returns the posts with author details, and you can ask follow-up questions like "enrich the top 5 authors by engagement."

Search 3: Post-liquidity event departures

This search tracks people who leave a company shortly after that company experiences a liquidity event, which creates both the wealth and the motivation to start something new.

Why this works: When a company goes public, gets acquired, or runs an employee share buyback (secondary sale), employees who participated now have capital. Senior operators who leave within 6-12 months of a liquidity event are disproportionately likely to start companies. They have funding (personal wealth), credibility (track record at a successful company), and a network (former colleagues who may join them). This is one of the most reliable founder formation signals, and it's not covered by any existing article or tool.

Direct API path:

This is a two-step search. First, identify companies that recently had a liquidity event. Then search for senior people who left those companies in the months following.

Step 1: Find companies with recent liquidity events:

curl -X POST 'https://api.crustdata.com/screener/companydb/search' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "filters": {
      "op": "or",
      "conditions": [
        {
          "filter_type": "ipo_date",
          "type": ">",
          "value": "2025-06-01"
        },
        {
          "filter_type": "acquisition_status",
          "type": "=",
          "value": "acquired"
        }
      ]
    },
    "limit": 100
  }'

curl -X POST 'https://api.crustdata.com/screener/companydb/search' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "filters": {
      "op": "or",
      "conditions": [
        {
          "filter_type": "ipo_date",
          "type": ">",
          "value": "2025-06-01"
        },
        {
          "filter_type": "acquisition_status",
          "type": "=",
          "value": "acquired"
        }
      ]
    },
    "limit": 100
  }'

curl -X POST 'https://api.crustdata.com/screener/companydb/search' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "filters": {
      "op": "or",
      "conditions": [
        {
          "filter_type": "ipo_date",
          "type": ">",
          "value": "2025-06-01"
        },
        {
          "filter_type": "acquisition_status",
          "type": "=",
          "value": "acquired"
        }
      ]
    },
    "limit": 100
  }'

Step 2: For each company from step 1, search for people who previously worked there and now hold founder or stealth titles:

curl -X POST 'https://api.crustdata.com/screener/person/search' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {
          "filter_type": "past_company",
          "type": "(.) ",
          "value": ["RecentlyIPOdCompany"]
        },
        {
          "filter_type": "current_title",
          "type": "(.) ",
          "value": ["founder", "ceo", "cto", "stealth", "building"]
        },
        {
          "filter_type": "current_company_employee_count",
          "type": "<",
          "value": 20
        }
      ]
    },
    "limit": 100
  }'

curl -X POST 'https://api.crustdata.com/screener/person/search' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {
          "filter_type": "past_company",
          "type": "(.) ",
          "value": ["RecentlyIPOdCompany"]
        },
        {
          "filter_type": "current_title",
          "type": "(.) ",
          "value": ["founder", "ceo", "cto", "stealth", "building"]
        },
        {
          "filter_type": "current_company_employee_count",
          "type": "<",
          "value": 20
        }
      ]
    },
    "limit": 100
  }'

curl -X POST 'https://api.crustdata.com/screener/person/search' \
  --header 'Authorization: Token $AUTH_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
    "filters": {
      "op": "and",
      "conditions": [
        {
          "filter_type": "past_company",
          "type": "(.) ",
          "value": ["RecentlyIPOdCompany"]
        },
        {
          "filter_type": "current_title",
          "type": "(.) ",
          "value": ["founder", "ceo", "cto", "stealth", "building"]
        },
        {
          "filter_type": "current_company_employee_count",
          "type": "<",
          "value": 20
        }
      ]
    },
    "limit": 100
  }'

What comes back: People who recently left post-liquidity companies and now appear at very small, likely new ventures. These are high-quality candidates because they've already demonstrated they can operate at scale, and they now have the resources to build.

How to scale this: Maintain a rolling list of companies that have IPO'd, been acquired, or announced secondary sales in the last 12 months. Run the people search against each one monthly. The pattern is predictable: departures typically peak 3-6 months after a liquidity event, once vesting cliffs are cleared.

MCP path: "Find all companies that IPO'd after June 2025 or were recently acquired. Then for each one, find people who previously worked there and now have founder or CEO titles at companies with fewer than 20 employees."

Enrichment and scoring: adding context to raw candidates

The source layer gives you names, headlines, and company affiliations. The enrichment layer turns those into full profiles with enough context to decide whether a candidate is worth pursuing.

People enrichment

The People Enrichment API takes a profile URL and returns 90+ structured fields: full work history with dates, education, skills, languages, profile metadata, and optional business email.

curl -X GET 'https://api.crustdata.com/screener/person/enrich?linkedin_profile_url=https://www.linkedin.com/in/example-founder' \
  --header 'Authorization: Token $AUTH_TOKEN'

curl -X GET 'https://api.crustdata.com/screener/person/enrich?linkedin_profile_url=https://www.linkedin.com/in/example-founder' \
  --header 'Authorization: Token $AUTH_TOKEN'

curl -X GET 'https://api.crustdata.com/screener/person/enrich?linkedin_profile_url=https://www.linkedin.com/in/example-founder' \
  --header 'Authorization: Token $AUTH_TOKEN'

Fields that matter for founder scoring:

• Work history: How many previous roles, how long at each, whether they held leadership titles, and whether any previous employer was a funded startup or had a known exit. Serial founders with prior exits are the strongest signal.

• Education: Not a filter on its own, but combined with work history it helps distinguish a technical founder (CS degree + engineering roles) from a business founder (MBA + operations roles), which informs how to evaluate the venture.

• Skills and endorsements: Technical skills like "machine learning," "distributed systems," or domain-specific expertise help categorize the type of company they're likely building.

Company enrichment

When the founder's current company has even a minimal presence (a domain or a company page), the Company Enrichment API returns 250+ datapoints including headcount, funding history, web traffic, and founder backgrounds.

curl -X GET 'https://api.crustdata.com/screener/company?company_domain=example-stealth.com&fields=headcount,funding_and_investment,founders,founders.profiles,founders.founders_previous_companies' \
  --header 'Authorization: Token $AUTH_TOKEN'

curl -X GET 'https://api.crustdata.com/screener/company?company_domain=example-stealth.com&fields=headcount,funding_and_investment,founders,founders.profiles,founders.founders_previous_companies' \
  --header 'Authorization: Token $AUTH_TOKEN'

curl -X GET 'https://api.crustdata.com/screener/company?company_domain=example-stealth.com&fields=headcount,funding_and_investment,founders,founders.profiles,founders.founders_previous_companies' \
  --header 'Authorization: Token $AUTH_TOKEN'

The founders.profiles and founders.founders_previous_companies fields are particularly useful here. They return structured data on every founder associated with the company, including their prior employers and roles. This lets you assess the entire founding team in one call rather than enriching each person individually.

If the company is too new to be in the database, set enrich_realtime=true to trigger a live enrichment that resolves within 10 minutes. This costs 5 credits per company instead of 1, but for newly formed stealth-stage companies that don't exist in any database yet, real-time enrichment is the only option.

Building a scoring function

You don't need a machine learning model to score founder candidates. Two approaches work well, and you can use them together.

Approach 1: Weighted checklist. A rule-based scoring function applied to the enrichment fields. Fast, consistent, and easy to audit. Here's a rubric you can implement as a simple function:

Pull the enrichment JSON for each candidate, check each field against the scoring table, sum the points, and rank. Candidates scoring above 50 go into the monitoring layer. Candidates scoring 30-50 go into a watch list for periodic re-enrichment. Below 30, deprioritize.

Adjust the weights based on your thesis. If you invest exclusively in technical founders, increase the weight on engineering backgrounds and GitHub activity. If you focus on a specific sector, add a bonus for domain-relevant work history.

Approach 2: Claude as analyst. Instead of writing scoring logic yourself, pass the enrichment data to a Claude Code agent with your investment criteria described in natural language. For example: "Here are 40 enriched founder profiles. Our thesis focuses on B2B SaaS founders with prior experience at companies that reached $10M+ ARR, technical backgrounds, and teams of at least two co-founders. Rank these candidates by fit, and for each one, explain in two sentences why they do or don't match." The agent reads the enrichment JSON, applies your criteria with judgment (not just keyword matching), and returns a ranked list with rationale for each decision. This is particularly useful for criteria that are hard to express as numeric rules, like "does this person's career trajectory suggest they're a domain expert in the problem they're now tackling?"

You can combine both approaches: use the weighted checklist to filter down to a manageable list (say, the top 50 from a search of 500), then pass those 50 to Claude for deeper analysis and ranking.

Continuous monitoring with watchers: alerts instead of manual checks

A discovery engine that only runs when you trigger it misses founders who emerge between searches. The monitoring layer converts your one-time search into a persistent, event-driven system that fires alerts when tracked candidates or companies change.

People watchers

People watchers track specific individuals and notify you when their profile changes. Set these up for two groups:

1. High-scoring candidates from your search results who haven't incorporated yet but show strong founder signals. You want to know the moment they change their title, update their employer, or start posting about a new project.

2. Known serial founders and notable operators you've identified through off-platform research or industry knowledge. Track them persistently regardless of their current status.

When you create a people watcher through the Watcher API, you specify the profile URL and the types of changes you want to monitor: job title changes, employer changes, and profile updates. The watcher runs continuously and sends a webhook notification when any tracked change occurs.

Company watchers

Company watchers monitor stealth-stage companies for growth signals that confirm the venture is progressing from idea to real business. The signals worth monitoring:

• Headcount increases: A company going from 2 to 5 employees in a month is actively hiring and building.

• New job postings: Open roles confirm the company is real and growing, especially if the roles are technical or product-focused.

• Funding events: Any detected funding activity, even a small friends-and-family round, confirms the company is raising.

• Press mentions: Media coverage or blog mentions indicate the company is starting to go public.

Set up company watchers on every company from your search results that scored above your threshold. The watcher monitors all configured signal types and pushes a webhook notification when any of them fire.

Webhook configuration and payload handling

Each watcher delivers its alerts to a webhook URL you configure. The webhook payload is structured JSON containing the type of change, the before and after values, and the full enrichment record for the changed entity.

Here's what a typical job-change webhook payload looks like when a watched person updates their employer:

{
  "event_type": "person_job_change",
  "person": {
    "name": "Jane Smith",
    "linkedin_url": "https://www.linkedin.com/in/janesmith",
    "previous_title": "VP Engineering",
    "previous_company": "Previous Corp",
    "new_title": "Co-founder & CTO",
    "new_company": "Stealth Startup"
  },
  "timestamp": "2026-04-24T14:30:00Z"
}

{
  "event_type": "person_job_change",
  "person": {
    "name": "Jane Smith",
    "linkedin_url": "https://www.linkedin.com/in/janesmith",
    "previous_title": "VP Engineering",
    "previous_company": "Previous Corp",
    "new_title": "Co-founder & CTO",
    "new_company": "Stealth Startup"
  },
  "timestamp": "2026-04-24T14:30:00Z"
}

{
  "event_type": "person_job_change",
  "person": {
    "name": "Jane Smith",
    "linkedin_url": "https://www.linkedin.com/in/janesmith",
    "previous_title": "VP Engineering",
    "previous_company": "Previous Corp",
    "new_title": "Co-founder & CTO",
    "new_company": "Stealth Startup"
  },
  "timestamp": "2026-04-24T14:30:00Z"
}

Your webhook handler receives this payload and routes it to the delivery layer. A basic handler in Python:

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/webhook/founder-signal', methods=['POST'])
def handle_founder_signal(self):
    payload = request.json
    event_type = payload.get('event_type')

    if event_type == 'person_job_change':
        person = payload['person']
        new_title = person.get('new_title', '').lower()

        # Check if the job change indicates founder activity
        founder_keywords = ['founder', 'co-founder', 'ceo', 'stealth', 'building']
        if any(kw in new_title for kw in founder_keywords):
            # Route to deal pipeline (Airtable, CRM, or Slack)
            send_to_pipeline(person)

    return jsonify({'status': 'received'}), 200

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/webhook/founder-signal', methods=['POST'])
def handle_founder_signal(self):
    payload = request.json
    event_type = payload.get('event_type')

    if event_type == 'person_job_change':
        person = payload['person']
        new_title = person.get('new_title', '').lower()

        # Check if the job change indicates founder activity
        founder_keywords = ['founder', 'co-founder', 'ceo', 'stealth', 'building']
        if any(kw in new_title for kw in founder_keywords):
            # Route to deal pipeline (Airtable, CRM, or Slack)
            send_to_pipeline(person)

    return jsonify({'status': 'received'}), 200

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/webhook/founder-signal', methods=['POST'])
def handle_founder_signal(self):
    payload = request.json
    event_type = payload.get('event_type')

    if event_type == 'person_job_change':
        person = payload['person']
        new_title = person.get('new_title', '').lower()

        # Check if the job change indicates founder activity
        founder_keywords = ['founder', 'co-founder', 'ceo', 'stealth', 'building']
        if any(kw in new_title for kw in founder_keywords):
            # Route to deal pipeline (Airtable, CRM, or Slack)
            send_to_pipeline(person)

    return jsonify({'status': 'received'}), 200

One founder intelligence platform we spoke with built exactly this pattern at scale. They track stealth entry and exit events across millions of profiles, ingesting webhook payloads into a database for analysis. They monitor not just when someone adds "stealth" to their headline, but when they remove it, because removal means the company has either launched (worth reaching out) or been abandoned (remove from pipeline).

MCP path: For teams using a Claude Code agent with Crustdata's MCP server configured, you can create watchers conversationally: "Set up a people watcher on this profile URL and notify me via this webhook endpoint when their job title changes." The MCP server handles the watcher creation API call.

Connecting to your deal pipeline

The engine produces scored candidates and real-time alerts. The last step is getting them into whatever system your team uses to manage deal flow.

Airtable

One fund we spoke with manages their entire deal pipeline in Airtable, with over 50,000 rows of company and founder data. Their main frustration was that none of their existing tools could push enrichment or signals directly into Airtable, so everything required manual updates. To connect the engine, set up an automation (using Zapier, Make, or a direct Airtable API call from your webhook handler) that creates a new row when a founder signal fires.

Map the webhook payload fields to your Airtable columns:

Add a "Status" column with values like "New," "Reviewing," "Outreach Sent," and "Passed" to track each candidate through your process.

CRM (Affinity, Attio, HubSpot)

For teams on Affinity or Attio, the webhook handler can create contacts and companies directly through their respective APIs. Both CRMs support custom fields where you can store the founder score, signal type, and enrichment summary. Affinity in particular is built for relationship tracking in private capital, so founder signals fit naturally into its data model.

For HubSpot, create a custom object type for "Founder Candidates" with properties matching the enrichment fields. Use the HubSpot API to create records when webhooks fire, and set up a workflow to notify your sourcing team when new high-scoring candidates appear.

Custom pipeline

For teams building their own tools (which, based on the calls we've had, is more common in VC than most industries), the webhook payload is structured JSON that you can pipe directly into a Postgres or MongoDB database. From there, build whatever dashboard or notification system fits your workflow. The engine's output is clean, structured data. How you present and act on it is up to you.

Review cadence

Set a weekly review cadence rather than reacting to every individual alert. The engine's job is to surface candidates. Your job is to decide who to reach out to. A weekly review of new high-scoring candidates, sorted by score, gives you a clear action list without the noise of real-time alerts interrupting your day. For time-sensitive signals (a known serial founder just changed their title to "CEO, Stealth"), set up a separate high-priority Slack notification so you can act within hours.