Competitor hiring analysis: a query sequence, with the base rates to read it against

A competitor’s job postings are the most detailed public account of its plans that exists. They name the teams being built, the level being hired at, the cities, the tools and sometimes the pay, and they do it months before the results show up anywhere else. The problem is not getting the postings; it is reading them without over-interpreting. This how-to runs the sequence in order and gives the base rates that keep the reading honest.

What is competitor hiring analysis?

Competitor hiring analysis is the practice of reading a competitor’s job postings to infer its plans: which functions it is growing, at what seniority, in which locations, on which technologies, and how that compares with its peers and with your own hiring. It is a standard input to product strategy, recruiting plans and sales targeting.

The method is the same whether the reader is a founder watching two rivals, a recruiter deciding where a competitor will be poaching from, or a seller using the competitor’s customers as a target list. Six requests, all to POST /v1/jobs/search, using the company from the JobsPipe API docs so they run as written.

Step 1: pull every open and recently closed role

Start wide. status set to any returns open roles and roles closed within the retention window, and the partial-match filter catches naming variants across subsidiaries.

curl -X POST https://api.jobspipe.dev/v1/jobs/search \
  -H "Authorization: Bearer $JOBSPIPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "company_name_partial_match_or": ["Acme Robotics"],
    "status": "any",
    "limit": 100
  }'

Keep job_title, job_function, seniority, is_manager, cities, country_code, remote, technology_slugs, date_posted, status, closed_at and closed_reason from each record. That is the working table for everything below.

Step 2: read the mix by function and seniority

Tabulate open roles by job_function and seniority. Three readings come straight off the table. A function with several openings at entry and mid level and one at lead is a team being built under a leader already in place. A function with a single exec opening and nothing below it is a leader being hired before the team, and the team postings will follow the hire. A function with openings at every level at once is a new location or a new product line, and the cities field usually confirms which.

Add location as the third axis. Group the same records by cities and country_code, and mark the remote ones separately. A function that posts in one city only is a hub, and a hub that appears for the first time in the window is an office being staffed. A competitor that has moved a function from city-bound to remote postings has changed how it competes for those people, which matters if you hire the same profile. Stated pay, where min_annual_salary_usd is present, completes the row: the same title posted at two levels of pay in two cities is two different hiring plans.

Step 3: compare against the base rates

A count means nothing without the distribution it sits in. Across companies with an active posting on the ten boards JobsPipe collects, these are the shares showing each pattern.

So: a competitor with three open engineering roles is in a slice of about 2.2% of hiring companies, which is a strong statement of investment. A competitor hiring in three functions at once is in a 10.3% slice, which is notable. A competitor with one opening is with the 41.5% majority, and nothing should be read into it without a second signal. And because 77.7% of postings come from the 13.4% of companies with ten or more roles, always divide open roles by company_object.employee_count before comparing two competitors of different size.

Step 4: read the technologies and skills

Union the technology_slugs across the engineering records for the stack the competitor hires for. To ask the question the other way, which of several competitors is hiring for a given technology, filter on the skill and pass the whole competitor list.

curl -X POST https://api.jobspipe.dev/v1/jobs/search \
  -H "Authorization: Bearer $JOBSPIPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "company_name_or": ["Acme Robotics", "Globex", "Initech"],
    "skills_or": ["kubernetes", "terraform"],
    "posted_at_max_age_days": 90,
    "limit": 100
  }'

A technology that appears in a competitor’s postings for the first time is an adoption signal, and one that disappears from new postings while still in closed ones is a migration. The tech stack scanner confirms what a domain runs from its public surface, which is the other half of the same question.

Skills are the softer cousin of technologies and live in keyword_slugs. Where technologies tell you what the competitor builds on, skills tell you what it values in the people it hires, and a shift in the skills named across a function is often the earliest sign of a change in how the team works: a data team that starts naming a specific orchestration tool, or a sales team that starts naming account management over lead generation. Read both fields, and read them against closed postings as well as open ones, since what a company stopped asking for is as informative as what it started asking for.

Step 5: watch the closes and the new openings

Closed roles are half the story. A posting that closes within a few weeks with a closed_reason of closed was most likely filled or pulled; one that closes as stale after months was probably never a real vacancy or was quietly abandoned. A function whose postings all close without new ones appearing has stopped growing. To see only the change since your last read, pass the timestamp of that read as discovered_at_gte.

curl -X POST https://api.jobspipe.dev/v1/jobs/search \
  -H "Authorization: Bearer $JOBSPIPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "company_name_or": ["Acme Robotics", "Globex", "Initech"],
    "discovered_at_gte": "2026-09-08 00:00:00",
    "limit": 100
  }'

Step 6: automate it

The sequence above is a weekly job with a stored timestamp. If you would rather not run it, Signals saves the competitor list as a watch and delivers each new posting by email, Slack or signed webhook, and the hiring signals API page lists every filter the watch can use. For the full org-chart reading of a single company, the talent mapping guide goes step by step.

Whichever way you run it, store the record identifiers and the lifecycle fields on every run, not only the current snapshot. The analysis that matters most is the difference between two reads: which roles appeared, which closed and how, and whether the function mix moved. A weekly cadence is enough for strategy work, since postings change on a scale of weeks; a daily one is for sellers working the competitor’s customers, where the value is in reaching an account before the next vendor does.

What competitor hiring cannot tell you

Postings show what a company is trying to add, not what it has. A team that has not hired in the collected window is invisible, and a company that recruits through agencies shows up under the agency unless you filter on employer_type. Coverage is the ten boards JobsPipe collects, so a competitor that posts only on a careers site outside those systems is under-counted. And postings are plans: a role that closes as stale was a plan that changed, which is worth knowing, but not the same as a hire.