Track Startup Hiring Velocity with Career Site Data (2026)

Published April 27, 2026 · 1520 words · For growth

Thirdwatch's Career Site Job Listing Scraper makes hiring velocity a live data signal at $0.003 per job — daily snapshot every Lever, Greenhouse, Workday, BambooHR, Keka, Ashby, and Recruitee career page on your watchlist, diff to detect ramping companies, alert your sales or investing team before they show up in newsletters. Built for growth ops, sales prospecting, and venture-investing teams who want to see hiring spikes the day they happen.

Why track startup hiring velocity

Open headcount is one of the cleanest leading indicators of growth. A startup that goes from 5 open roles to 25 open roles in 90 days is preparing to spend at scale — they almost certainly raised, are about to raise, or are profitable enough to self-fund a hiring sprint. According to a 2025 Crunchbase analysis of Series A through C startups, the median company that 5x'd its open-role count in a quarter announced a funding round within the following six months. The signal is stable across vintages and verticals.

For a sales prospecting team, hiring velocity tells you when an account is in the buying window. For a venture investor, it lets you find ramping companies before TechCrunch does. For a competitive intelligence team, it tells you which competitors are doubling down on which functions. The common job-to-be-done is structured: snapshot every company's career page daily, compute deltas, alert on velocity thresholds. The Career Site Scraper is built specifically for this loop because it normalises across all major ATS platforms — without that, a watchlist of 500 mixed-ATS companies is a six-week scraper engineering project.

How does this compare to the alternatives?

Three options for getting startup hiring velocity into a CRM or alerting system:

The big SaaS players in headcount tracking are charging four-to-six figure annual contracts for what is fundamentally daily diff math on public career pages. The Career Site Scraper actor page gives you the raw structured feed at pay-per-result pricing; the velocity logic is forty lines of pandas. The trade-off is you build the analytics layer yourself — fine when the alternative costs more than your sales team's commission budget.

How to track startup hiring velocity in 4 steps

Step 1: How do I authenticate against Apify?

Sign in at apify.com (free tier, no credit card), open Settings → Integrations, and copy your personal API token. Every example below assumes the token is in APIFY_TOKEN:

export APIFY_TOKEN="apify_api_xxxxxxxxxxxxxxxx"

Step 2: How do I snapshot the open roles for a watchlist daily?

Pass your full watchlist of company career page URLs in careerPageUrls. For velocity tracking you do not need full descriptions — just the count and metadata per role.

import os, requests, json, datetime, pathlib

ACTOR = "thirdwatch~career-site-job-scraper"
TOKEN = os.environ["APIFY_TOKEN"]

watchlist = pathlib.Path("watchlist.txt").read_text().splitlines()

resp = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={
        "careerPageUrls": watchlist,
        "scrapeDescriptions": False,
        "maxJobsPerSite": 500,
    },
    timeout=900,
)
jobs = resp.json()
today = datetime.date.today().isoformat()
pathlib.Path(f"snapshots/{today}.json").write_text(json.dumps(jobs))
print(f"Snapshot {today}: {len(jobs)} jobs")

For a 200-company watchlist averaging 15 open roles each, this is 3,000 jobs at $0.003 each = $9 per daily snapshot. Schedule on Apify's scheduler at midnight UTC.

Step 3: How do I compute hiring velocity per company?

Aggregate snapshots by date and company, then compute a 30-day rolling delta:

import pandas as pd, glob, json

frames = []
for f in glob.glob("snapshots/*.json"):
    date = pathlib.Path(f).stem
    for j in json.loads(pathlib.Path(f).read_text()):
        frames.append({"date": date, "company": j["company_name"], "apply_url": j["apply_url"]})
df = pd.DataFrame(frames)
df["date"] = pd.to_datetime(df["date"])

daily_count = df.groupby(["company", "date"])["apply_url"].nunique().reset_index(name="open_roles")
daily_count = daily_count.set_index("date").groupby("company").resample("1D").last().ffill().reset_index(level=0)

velocity = daily_count.groupby("company")["open_roles"].apply(
    lambda s: s.iloc[-1] / s.iloc[-31] if len(s) >= 31 and s.iloc[-31] > 0 else None
).dropna().sort_values(ascending=False)

print(velocity.head(20))

Companies with velocity > 3.0 are ramping fast. Add a floor of open_roles_today >= 5 to filter out single-digit noise.

Step 4: How do I alert a sales or investment team in real time?

Wire the velocity output to whatever your team lives in — Slack, Salesforce, Notion. Forward only newly-flagged companies (companies that crossed the threshold today but not yesterday):

import requests

def flag(s):
    return s >= 3.0

flagged_today = set(velocity[velocity.apply(flag)].index)
yest_velocity = pd.read_parquet("velocity-yesterday.parquet")["velocity"]
flagged_yest = set(yest_velocity[yest_velocity >= 3.0].index)
new_flags = flagged_today - flagged_yest

for company in new_flags:
    requests.post(
        "https://hooks.slack.com/services/.../...",
        json={"text": f":rocket: *{company}* hiring velocity 3x+ over 30d. Roles open: {int(daily_count[(daily_count.company==company)].open_roles.iloc[-1])}"},
    )

velocity.to_frame("velocity").to_parquet("velocity-yesterday.parquet")

This same alert structure feeds Salesforce as a custom signal field, Apollo as an account list, or HubSpot as a workflow trigger.

Sample output

Each row from the underlying actor looks like this. Velocity is computed across many such snapshots, not from one row.

{
  "title": "Series A Founding Engineer",
  "company_name": "Watershed",
  "department": "Engineering",
  "location": "San Francisco, CA",
  "job_type": "Full-time",
  "apply_url": "https://jobs.ashbyhq.com/watershed/abc-123",
  "ats_platform": "ashby"
}

A two-month velocity table for one company looks like this — drop into a chart and the spike is visible at a glance:

5 → 28 over 60 days is a ~5.6x velocity — the kind of curve that almost always corresponds to a closed or imminent funding round.

Common pitfalls

Three things go wrong in production velocity-tracking pipelines. Re-listing noise — some companies refresh postings by closing and re-opening them under new apply URLs, which inflates apparent velocity; smooth with a 7-day rolling average rather than reading single-day deltas. Department concentration matters — a 30-role spike that's all sales hires means a different thing than 30 engineering hires; always tag the alert with department breakdown. Funding-window false positives — a company that just announced a raise will spike for 30-60 days then plateau; don't double-count the post-raise spike as new signal if you already had the raise in your CRM.

Thirdwatch's actor returns department and ats_platform on every record so you can branch alerts by team and by data quality (first-class ATS rows are higher signal than ats_platform: "generic" rows). The actor is stable enough to schedule unattended for months — daily snapshots build up the time series automatically.

Related use cases

• Scrape Greenhouse jobs for ATS enrichment
• Scrape Lever jobs for a recruiter sourcing pipeline
• Build a multi-company jobs aggregator from career pages
• The complete guide to scraping job boards
• All Thirdwatch use-case guides

Frequently asked questions

Why is hiring velocity a useful sales or investment signal?

Open headcount is one of the cleanest leading indicators of company growth. A startup that grew its open-roles count from 5 to 25 in 90 days is preparing to spend, almost certainly raised, and is in the buying window for tools that touch the hiring process. Velocity is more predictive than absolute headcount because it captures the change.

How often should I refresh the data to detect velocity changes?

Daily snapshots are the standard. Daily granularity catches hiring spikes within 24 hours and weekly aggregations smooth single-day noise. Hourly only matters for recruiter-side workflows; for sales and investment signals, daily is the right cadence and costs trivially with this actor.

What's a meaningful velocity threshold to alert on?

A useful default is a 3x increase in open roles over a 30-day rolling window, with a floor of 5+ new postings. Smaller thresholds produce noise; larger ones miss the signal. Tune per vertical — early-stage startups normally ramp from single-digit to double-digit role counts, while public companies move in absolute terms.

Can I separate engineering hiring from go-to-market hiring?

Yes. Filter on the department field — Engineering, Product, Design vs. Sales, Marketing, Customer Success. A startup spinning up GTM hiring (Sales + Marketing growing 5x) is in a very different lifecycle stage than one spinning up engineering hiring, and both are buying signals for different categories of vendors.

How do I correlate hiring velocity with a funding event?

Cross-reference the company's last raise date — Crunchbase or PitchBook export — against your time series. Most fundraises are followed by a 30-90 day hiring spike. A spike without a recent raise is the more interesting signal: it usually means the company is profitable enough to self-fund growth or a raise is imminent.

Does this work for non-startup companies?

Yes, but the velocity baseline is different. Public companies and large privates hire continuously, so absolute deltas matter more than percentage increases. The same daily snapshot loop works; just adjust the alert threshold and group by department or location to catch geographic or org-level expansion signals.

Run the Career Site Job Listing Scraper on Apify Store — pay-per-job, free to try, no credit card to test.