DEV Community: Benedict Mendoza

Job Postings Are the Most Underused B2B Intent Signal (And You Don't Even Need to Scrape)

Benedict Mendoza — Thu, 20 Aug 2026 23:31:53 +0000

A funding announcement tells you a company has money. A job posting tells you exactly where they're about to spend it — and it's published weeks before the pain becomes a purchase.

If a target account just opened its first platform-engineer role, they're about to have infrastructure problems. First "Head of Demand Gen"? Marketing budget incoming. Three sales roles in a month? They found product-market fit and every vendor selling to sales teams should already be in their inbox. Job postings are, I think, the most underused intent signal in B2B — and unlike most intent data, they're public, structured, and free to read.

This post covers the mechanics: where the data actually lives, why you don't need to "scrape" in any painful sense, and how to turn it into an alerting system.

The secret: almost nobody hosts their own job board

Most companies' careers pages are a skin over an ATS (applicant tracking system) — Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, and a few others. And the big ones expose public JSON endpoints per company, no auth required:

https://boards-api.greenhouse.io/v1/boards/{company}/jobs
https://api.lever.co/v0/postings/{company}?mode=json
https://api.ashbyhq.com/posting-api/job-board/{company}

That's not scraping; that's a GET request. When I tested this, stripe on Greenhouse returned 576 open roles and openai on Ashby returned 734, each with title, location, and apply URL, in a couple of seconds. No headless browser, no proxies, no anti-bot war — companies want this data distributed.

The two actual problems are less obvious:

1. Discovery — which ATS does a given company use? You can probe: normalize the company name into slug candidates and try each ATS endpoint until one answers. It works surprisingly often. For stragglers, the careers link on their website gives it away instantly (jobs.lever.co/... in the href).

2. Newness — for intent purposes you don't care about the 576 open roles; you care about the 3 that appeared this week. That means state: store the job IDs you've seen per company, diff on each run, and emit only the delta. This is the step everyone skips and then regrets, because without it your "alerts" are the same 576 jobs every morning.

The architecture

Input: a list of target companies (your dream accounts, competitors, whoever)
Resolve: detect each company's ATS and fetch its board as JSON
Normalize: six ATS formats into one schema — title, department, location, remote flag, employment type, URL, posted date
Diff: compare against the stored seen-set; keep only new postings
Filter: keyword match on titles ("sales", "engineer", whatever maps to your product) and locations
Alert: push the delta to a webhook (n8n/Make/Zapier) or straight into Slack

Run it daily on a schedule and you get a morning message like "Acme just posted: Head of RevOps (Remote)" — which for the right seller is worth more than any purchased lead list, for the same reason fresh beats stale everywhere in sales.

Who actually uses this

Sales/GTM: hiring in your category = budget + timing. The trigger beats the list.
Recruiters: watch competitor postings to know who's growing and what talent they're fighting for.
Job seekers (underrated): monitor your 20 dream companies directly instead of refreshing aggregators that lag by days.
Analysts/founders: a competitor's job board is their roadmap, published voluntarily. Watch what they hire for.

If you'd rather not build the plumbing

I packaged this whole loop as an Apify Actor: Job Postings Monitor. Disclosure: mine. You give it company names (it auto-detects the ATS — typing stripe is enough), flip on monitor mode, and schedule it; it remembers what it's seen, returns only new postings, and can hit your webhook or Slack directly. Pay-per-job-returned, and in monitor mode you only pay for the new ones — watching 50 quiet companies costs cents.

But honestly, if you're comfortable with a cron job, the endpoints above plus a key-value store get you a working version in an afternoon. The moat isn't the code — it's actually running it every day, which is exactly the part people stop doing by week three. (That's the real argument for scheduling it on managed infrastructure, whether mine or your own.)

One closing thought

Most intent data is inferred: someone visited a page, downloaded a whitepaper, matched a lookalike model. Job postings are declared intent — the company wrote down what it's investing in and posted it publicly, with a date on it. It's the difference between guessing someone is hungry and watching them book a table.

Feature requests (more ATS platforms — Workday and BambooHR are the common asks) land in the Actor's Issues tab and genuinely shape what I build next.

Company Enrichment Without the Per-Credit Tax: Website to Firmographics JSON With an LLM

Benedict Mendoza — Wed, 19 Aug 2026 22:08:44 +0000

Most of what B2B enrichment vendors sell is information companies publish about themselves, for free, on their own websites. What you're paying per-credit prices for is mostly the reading.

I noticed this while burning through enrichment credits on accounts that turned out to be obvious non-fits — agencies when I needed SaaS, enterprise when I needed SMB. The data that would have disqualified them in seconds (what they sell, who they sell to, how they price) was sitting on their homepages the whole time. No vendor needed. Just reading.

So I did the obvious thing: pointed an LLM at company websites and made it fill out a fixed schema. This post covers what that looks like, what it costs (spoiler: about a cent per company), and the failure modes I hit building it into a production tool.

What you can extract from a website alone

More than you'd guess. From the homepage plus three or four key pages (/about, /pricing, /careers, /contact), reliably:

Identity: name, one-line description, industry
Business model: B2B SaaS vs. ecommerce vs. agency vs. marketplace — the single most useful ICP filter
Who they sell to: an ICP summary inferred from their own positioning
Pricing model: freemium / subscription / usage-based / "book a demo" — and visible tiers. "Book a demo" vs. self-serve alone tells you a lot about deal size
Tech stack hints: integrations and technologies they mention
Hiring signals: careers page contents — hiring roles are spend commitments, which makes them intent data
Contacts and socials: generic emails (info@, sales@), phone numbers, social links
Firmographics: HQ location, founded year, a size estimate

Here's a real extraction — I ran it against apify.com as a test:

{
  "domain": "apify.com",
  "companyName": "Apify",
  "industry": "Technology",
  "businessModel": "B2B SaaS",
  "pricingModel": "subscription",
  "icpSummary": "Individuals, startups, and large enterprises looking for web data solutions and automation tools.",
  "employeeCountEstimate": "51-200",
  "hqLocation": "Prague, Czech Republic",
  "isHiring": true,
  "contactEmails": ["hello@apify.com"],
  "techStackHints": ["Python", "JavaScript", "TypeScript"],
  "confidence": 0.9
}

Every field came from their own pages. Nothing purchased, nothing stale.

The architecture (it's short)

Fetch the homepage. Plain HTTP — most marketing sites don't need a headless browser.
Parse internal links and pick the useful pages by URL pattern: about, pricing, careers, contact, product.
Strip the HTML to text, concatenate with page labels, truncate to a sane token budget.
One LLM call with a strict JSON schema and a hard rule: never invent — use null/"unknown" when absent.
Validate the JSON, attach the source URLs, done.

With a small model (gpt-4o-mini class) the LLM step costs a fraction of a cent; with fetches included you land around a cent per company. Compare that to the $0.75–1.50 per row that credit-based AI enrichment effectively costs on paid plans.

Failure modes worth knowing before you build this

Hallucinated firmographics. Rare but real — the model occasionally "remembers" a company instead of reading the page. The strict schema plus explicit permission to answer "unknown" kills most of it; keeping a confidence score exposes the rest.
JS-only websites. Some sites render nothing without a browser. Accept the miss or add a headless fallback; I chose to accept the miss (error rows, clearly marked) to keep speed and cost down.
Personal data temptation. Scraping personal emails puts you in GDPR territory for no good reason. Restrict extraction to generic company addresses (info@, sales@) — the compliance surface drops to almost nothing and, honestly, generic inboxes are where cold email belongs anyway.
Redirect chains and www quirks. Boring, but half your early failures will be URL normalization.

If you'd rather not maintain it

I packaged mine as an Apify Actor: AI Company Enrichment. Disclosure: I built it, pay-per-company, and everything above is how it works internally — so if you want to own the pipeline, this post is the spec.

Called via API:

curl -X POST "https://api.apify.com/v2/acts/benedictmendoza~ai-company-enrichment/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["stripe.com", "notion.so", "yourprospect.com"]}'

It slots into the usual places: a Clay table's HTTP enrichment column (do the cheap firmographic pass first, spend real credits only on accounts that pass ICP fit), an n8n/Make workflow between "new lead" and "score lead," or just a CSV in, CSV out.

The general principle

Split your enrichment bill in two: data that genuinely requires a vendor (verified emails, direct dials, funding data) and data that's self-published on the prospect's website. Pay vendors for the first category. Read the second one yourself — with an LLM, "yourself" now costs a cent and takes eight seconds.

If you try the Actor and want extra fields extracted, the Issues tab reaches me directly — field requests are cheap to ship.

How to Track Your Brand's Visibility in ChatGPT, Perplexity & Gemini (GEO Monitoring, With Code)

Benedict Mendoza — Wed, 19 Aug 2026 12:51:14 +0000

This week I ran a simple test. I asked ChatGPT, Perplexity, and Gemini the same question — "what is the best note-taking app for teams?" — and compared how they treated the brands in the answer.

ChatGPT flat-out recommended Notion, by name, ten times in one answer. Perplexity refused to pick a winner ("there is no single best note-taking app for teams") but still mentioned Notion three times and cited ten sources. Gemini mentioned it eight times and name-dropped Obsidian once. Evernote — a brand that owned this category for a decade — got two mentions across all three engines combined.

If you're Evernote, nobody sends you a report about this. There's no Search Console for ChatGPT. A growing share of product research now happens inside AI assistants, the answers steer real purchase decisions, and most brands have no idea what's being said.

The practice of measuring and improving this is getting called GEO (Generative Engine Optimization). Fancy name, but the underlying job is plain: figure out what the AI engines say when your buyers ask about your category, and track how it changes. Here's how to do it with actual data instead of vibes.

What's worth measuring

While building the tracker, I settled on four numbers per prompt, per engine:

Mention — does the answer name your brand at all?
Position — first name in the answer, or an afterthought behind three competitors?
Share of voice — across your whole prompt set, how often do you appear vs. each competitor?
Citations — which pages did the engine cite, and is your site one of them?

The citations one is underrated. Engines with web search build answers from a small pool of pages they trust. In my Notion test, the sources were things like Zapier's "best note-taking apps" listicle. If the engines keep citing the same three roundups for your category, getting into those roundups probably moves your AI visibility more than anything you publish on your own domain. Citations are the new backlinks, basically.

The problem is doing this every week

Checking by hand works exactly once. Open each engine, ask, read, tally mentions in a spreadsheet. For three prompts that's twenty minutes. For a real setup — say 25 prompts across 3 engines, weekly, because answers drift with every model update — it's hours of tedium that nobody sustains past week two.

There are SaaS tools for this now (Otterly, Peec, Profound, Ahrefs Brand Radar), and some are good, but pricing runs from $29 to over $800 a month with seat licenses and prompt quotas. For an agency juggling ten client brands, or a solo founder who wants one weekly number, the economics are annoying.

What I built instead

I made an Apify Actor that does single prompt-checks and charges per check rather than per month: AI Search Visibility Tracker. Disclosure: I'm the author, so weigh that however you like — the methodology below works whether or not you use my tool.

You give it a brand, aliases, competitors, and the prompts your buyers actually ask. It runs every prompt through ChatGPT, Perplexity, and Gemini with live web search and returns a structured row per prompt-engine pair:

{
  "prompt": "What is the best note-taking app for teams?",
  "engine": "chatgpt",
  "brandMentioned": true,
  "brandMentionCount": 10,
  "brandRank": 1,
  "competitorsMentioned": { "Obsidian": 0, "Evernote": 2, "Coda": 0 },
  "brandCited": true,
  "citations": [{ "url": "https://zapier.com/blog/best-note-taking-apps/" }],
  "answerText": "..."
}

plus a run summary with overall visibility %, per-engine breakdown, and share of voice. Those numbers at the top of this post came straight out of it.

Automating the weekly run

One run is a snapshot; the value is the trend line. The whole loop via API:

curl -X POST "https://api.apify.com/v2/acts/benedictmendoza~ai-search-visibility-tracker/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d @tracking-config.json

Or in JavaScript:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('benedictmendoza/ai-search-visibility-tracker').call({
    brandName: 'YourBrand',
    competitors: ['CompetitorA', 'CompetitorB'],
    prompts: yourPromptList,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

The lazy-but-solid production setup: an Apify Schedule every Monday morning, dataset auto-exported to Google Sheets. After four Mondays you have a trend line per engine, and the data starts saying interesting things.

Picking prompts (don't invent them)

Bad prompt sets produce useless dashboards. Mine yours from places where real phrasing lives:

your highest-converting search queries, reworded as questions
"best X for Y" patterns in your category — these dominate AI product recommendations
questions your sales team actually gets asked on calls
"[competitor] alternative" phrasings

Twenty well-chosen prompts beat two hundred generic ones, and they cost 10x less to track.

Reading the results

A few patterns I've already seen and what they mean:

You're invisible, competitors aren't. Go read the citations field before touching your own site. The pages the engines trust for your category are your outreach hit-list.

Mentioned, but always last. The engines know you exist and don't prefer you. Diff the answerText descriptions of you vs. the leader — the gap is usually positioning or recency of third-party coverage, not product.

Great on Perplexity, absent on ChatGPT. Normal. They cite different source pools. Start with whichever engine your audience actually uses.

brandCited: false even when you're mentioned. The engines describe you from other people's pages. Structured comparison content on your own domain tends to move this one first.

Start the clock now

Whatever tooling you choose, the thing that matters is starting the time series. AI answers about your category are drifting right now, quietly, and you can't retroactively measure last quarter. Fixed prompt set, three engines, weekly cadence — the trend line does the rest.

If you try the Actor and want another engine (Google AI Overviews is next on my list), sentiment scoring, or Slack alerts — the Issues tab is the fastest way to reach me. I answer fast.