Hiring Signals API for GTM Teams: Turn Job Postings into Pipeline

Hiring Data Is the Best Intent Signal You're Not Using

Your ideal customer is about to buy. How do you know? They just posted three data engineering roles requiring the exact tool category you sell. Or they hired a VP of Security last month, and the five security infrastructure roles that followed are still open. Or they're expanding into EMEA and the six regional sales roles posted in the last two weeks make that unmistakable.

Job postings are a real-time window into company priorities, budget allocation, and technology investment. Unlike web traffic or content downloads, they represent irreversible commitment — you don't write a job description for a $200k role you're not planning to fill. For GTM teams who know how to read them, hiring patterns are among the highest-signal intent data available.

This article covers how to operationalize hiring signals — what to track, how to extract the signal from the API, and how to wire it into the workflows your team actually uses.

The Four Signal Types That Drive Pipeline

1. Technology Investment Signals

A company posting roles that require your category of product is the most direct buying signal. A security tools vendor should track companies posting security roles that mention "SIEM", "EDR", "SOAR", or "zero trust". A data observability company should track postings mentioning "data quality", "pipeline monitoring", or "dbt".

Unlike most intent data, this signal is grounded in real organizational commitment — they're spending $200k/year on a headcount to use or manage something. That's not a blog post read; it's a budget decision.

2. Expansion and Growth Signals

Hiring velocity is a proxy for growth-stage and available budget. A company that posts 5 jobs in Q1 and 25 in Q2 is in an expansion phase — typically the period when new vendor relationships are established. Specific patterns:

• Geographic expansion: "Sales Manager, APAC" signals new market entry
• Function buildout: First marketing ops, revenue ops, or legal hire — new function = new vendor needs
• Leadership change: New VP/Director often means evaluating the existing vendor stack

3. Pain Point Signals

Job descriptions describe problems, not just requirements. "We need to improve our data pipeline reliability" is a pain point in disguise. "Migrating from monolith to microservices" signals a multi-year infrastructure project. Parsing these requires NLP, but for the most valuable categories — data quality, cloud migration, security incidents, compliance gaps — keyword extraction works reasonably well.

4. Competitive Displacement Signals

A company posting roles that explicitly require your competitor's product is a warm prospect. They have budget, a proven use case, and potentially growing frustration with the incumbent. "3+ years experience with [Competitor]" in 10 job descriptions is a strong signal worth investigating.

The API Architecture

Building a hiring signals pipeline has three stages: data collection, signal extraction, and delivery. Here's the architecture in code.

Stage 1: Continuous Data Collection

// Poll for new job postings from your target account list
async function collectHiringSignals(accounts: string[]) {
  const signals = [];

  for (const company of accounts) {
    const res = await fetch(
      `https://api.jobdatalake.com/v1/jobs?company=${encodeURIComponent(company)}&limit=100`,
      { headers: { 'X-API-Key': process.env.JDL_API_KEY! } }
    );
    const { jobs } = await res.json();

    // Only process jobs posted in the last 7 days to avoid re-triggering
    const recentJobs = jobs.filter((j: any) => {
      const postedAgo = Date.now() - j.posted_at; // posted_at is Unix ms
      return postedAgo < 7 * 24 * 60 * 60 * 1000;
    });

    signals.push({ company, jobs: recentJobs });
  }

  return signals;
}

Stage 2: Signal Scoring

interface SignalConfig {
  targetSkills: string[];      // Skills that indicate your ICP
  targetTitles: string[];      // Titles that signal buying committee
  competitorNames: string[];   // Competitors mentioned in descriptions
}

function scoreCompanySignal(jobs: any[], config: SignalConfig) {
  let score = 0;
  const detectedSignals: string[] = [];

  for (const job of jobs) {
    const skills = (job.required_skills ?? []).map((s: string) => s.toLowerCase());
    const title = job.title.toLowerCase();
    const desc = (job.description ?? '').toLowerCase();

    // Technology fit signals
    const matchedSkills = config.targetSkills.filter(s =>
      skills.includes(s.toLowerCase()) || desc.includes(s.toLowerCase())
    );
    if (matchedSkills.length > 0) {
      score += matchedSkills.length * 15;
      detectedSignals.push(`Hiring for ${matchedSkills.join(', ')}`);
    }

    // Buying committee signals (decision makers)
    if (config.targetTitles.some(t => title.includes(t.toLowerCase()))) {
      score += 20;
      detectedSignals.push(`Hiring ${job.title}`);
    }

    // Salary indicates budget seriousness
    // salary_min_usd is stored in thousands (150 = $150k)
    if (job.salary_min_usd && job.salary_min_usd >= 150) {
      score += 10;
    }

    // Competitor displacement signals
    const competitorMentioned = config.competitorNames.find(c =>
      desc.includes(c.toLowerCase())
    );
    if (competitorMentioned) {
      score += 25;
      detectedSignals.push(`Mentions ${competitorMentioned}`);
    }
  }

  // Velocity bonus
  score += Math.min(jobs.length * 3, 30);

  return { score, signals: [...new Set(detectedSignals)], jobCount: jobs.length };
}

Stage 3: Delivery to CRM and Sequences

High-scoring signals should reach your team immediately. Here's an example Salesforce CRM enrichment:

async function enrichSalesforceAccount(accountId: string, signal: CompanySignal) {
  // Update the Salesforce account with signal data
  await salesforce.sobject('Account').update({
    Id: accountId,
    JDL_Signal_Score__c: signal.score,
    JDL_Active_Roles__c: signal.jobCount,
    JDL_Signal_Summary__c: signal.signals.join('; '),
    JDL_Signal_Date__c: new Date().toISOString(),
  });

  // If score exceeds threshold, trigger a sales sequence
  if (signal.score >= 50) {
    await salesforce.sobject('Task').create({
      Subject: `High-intent hiring signal: ${signal.company}`,
      Description: `Score: ${signal.score}. Signals: ${signal.signals.join(', ')}`,
      WhatId: accountId,
      Priority: 'High',
      Status: 'Not Started',
    });
  }
}

For Slack notifications on high-intent signals:

async function postSignalToSlack(signal: CompanySignal) {
  if (signal.score < 40) return; // Only surface high-signal accounts

  await fetch(process.env.SLACK_WEBHOOK_URL!, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      text: `🔥 *Hiring signal: ${signal.company}* (score: ${signal.score})`,
      blocks: [{
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `*${signal.company}* is actively hiring (${signal.jobCount} new roles).
Signals: ${signal.signals.join(' · ')}`
        }
      }]
    })
  });
}

Building Your Target Skills Dictionary

The quality of your signals depends on the quality of your target skills list. For each product category, the skills to watch are different:

• Data tools: dbt, Airflow, Spark, Kafka, Snowflake, Databricks, Fivetran, data quality
• Security: SIEM, EDR, SOC, zero trust, SOAR, cloud security, IAM, vulnerability management
• DevOps/platform: Kubernetes, Terraform, Datadog, observability, SRE, platform engineering
• Sales/revenue ops: Salesforce, HubSpot, revenue operations, sales enablement, Outreach, Gong

Use JobDataLake's get_filter_options endpoint to discover the most common skills in your target job function — this gives you a data-driven starting point rather than guessing.

Respecting the Signal Without Creeping Out Prospects

The most effective hiring-signal-based outreach doesn't reveal the signal directly. Saying "we saw you posted 5 data engineering roles on LinkedIn" feels invasive. Using the signal to understand the business context and leading with relevant value feels helpful:

"Companies scaling their data infrastructure often run into [specific problem your product solves]. Given your growth, I thought this might be relevant timing to connect."

The signal tells you when to reach out and why it's relevant. It doesn't become the subject line.