Est.

Extracting Skills and Tech Stack Signals From Job Descriptions

Job postings reveal what technologies companies actually use, not what they claim.

· 11 min read
Cover illustration for “Extracting Skills and Tech Stack Signals From Job Descriptions”
Talent Intelligence · October 8, 2026 · 11 min read · 2,480 words

A company posting for a "Salesforce Admin with HubSpot migration experience" is telling the world something it probably didn't mean to announce: it's in the middle of switching CRM systems, right now, in public. That's the whole idea behind this piece. Job postings are a constant, public broadcast of what a company actually runs under the hood, and almost nobody reads them that way.

Think about what a posting has to say to attract the right candidate. A data engineer listing names Azure, Scala, Spark, and SQL because the hire needs to know those tools on day one. An ML engineer posting references TensorFlow and PyTorch for the same reason. None of this is marketing copy. It's an operational requirement, written down because the company needs someone who can actually do the job, and that requirement tells you, free of charge, what's humming along on their servers.

This matters more than a website scrape ever could, because a lot of what runs inside a company never shows up on its public-facing site. Backend infrastructure, internal tooling, data warehouses, the quiet migration from one CRM to another. None of that touches the homepage. It appears instead in the job req. And because postings update constantly with hiring cycles, you get a moving picture instead of a single snapshot. One caveat belongs on the label right away: a hiring freeze produces silence that can look like stability, so this signal works best stacked next to other technographic sources.

The raw text of a job posting is not yet intelligence

Having the text is not the same as having data you can use. A pile of job descriptions is just a pile of sentences until something turns those sentences into fields you can count, sort, and compare across thousands of companies.

The same skill appears under a dozen different names. "Python," "Python programming language," "Python coding," "proficiency in Python." A person reads all four and understands instantly that they mean the same thing. A naive string match does not, and it will either double-count the skill or miss half its instances depending on which phrase it happened to look for. Multi-word terms make it worse. "CI/CD," "retrieval-augmented generation," "LoRA/QLoRA fine-tuning" They are phrases with internal structure rather than single words you can look up in a dictionary, and a system built to spot keywords tends to grab half the phrase or miss it.

Then there's the skill nobody bothered to type. A senior ML engineer posting might never say the word "PyTorch," because at that seniority level it's assumed the way a posting for a truck driver doesn't specify "must know how to use a steering wheel." Any system that only counts what's explicitly written will quietly understate real demand for the tools everyone assumes.

AstrumU's research on this points at a related failure, closer to the machinery than the words themselves: highly technical, domain-specific phrases and acronyms trip up smaller models with limited vocabularies, which fail to embed the correct meaning both while training and while running. The model doesn't know what it doesn't know.

And scale rules out the easy fix. Nobody is reading a million job postings by hand and tagging each skill with a highlighter. Any real use case runs at a volume where manual annotation isn't an option, and that volume is the reason an extraction pipeline exists.

The two-stage structure of a skill extraction pipeline

A working skill extraction pipeline breaks into two separate jobs, and treating them as one job is the most common way these systems go wrong.

The first stage turns raw, messy prose into candidate skill tokens, strings pulled out of the text that look like they might be skills. Call it text-to-signal. The output here is rough: named entities, keyphrases, tagged spans that vary in format from one posting to the next and aren't yet comparable to anything.

The second stage takes those rough strings and maps them onto a stable, controlled vocabulary, so "Python," "Python programming language," and "Python coding" all land on the same node. Call it normalization. This is the step that actually makes the data queryable, because counting skill mentions only means something once every mention of the same skill lands in the same bucket.

Skip the second stage, or build it weakly, and skill counts stay noisy, so comparing data across sources turns into comparing noise to more noise. The two stages fail in different ways, too. Stage one tends to miss skills it should have caught, or cut a multi-word term in the wrong place. Stage two tends to leave new terms unmapped, or collapse two genuinely different skills into one by mistake. Different jobs, different failure patterns, different fixes. The next two sections take each one in turn.

Diagram: Two-Stage Skill Extraction Pipeline. Visualizes: Illustrate the two-stage architecture of a skill extraction pipeline as a sequential flow.

Stage one, three approaches to turning job description text into candidate skill tokens

Three different architectures handle the conversion of text into signal, and they form something closer to an upgrade path than a menu of equal options. Each one exists because the one before it ran into a ceiling.

The simplest approach is dictionary-based matching: a curated list of technology names checked against the posting text. It's cheap, fast, and easy to build, which makes it a reasonable place to start. Its weakness appears fast, too. It can't handle surface variation ("Python coding" versus "proficiency in Python"), it chokes on multi-word terms, and it misses anything not already on the list. Someone has to keep updating that list by hand as the technology world changes. Even with those limits, it still earns a seat at the table as a fast first-pass filter or a sanity check layered under something heavier.

The second approach fine-tunes transformer-based models for named entity recognition, essentially training a model specifically to spot skill mentions in text. Research published in the Natural Language Processing Journal built an ensemble combining a traditional conditional random field model with transformer-based neural networks, annotated across 22 IT roles, and it posted strong F-scores on both technical and non-technical skills, beating conventional CRF and deep learning baselines by a wide margin on the technical side. The main weakness here is class imbalance: rare skills show up rarely in training data, so the model never gets enough examples to learn them well, and it underfits on exactly the skills that matter most for spotting emerging trends. Multi-word spans and long-range dependencies cause a second kind of failure, where a model tags "retrieval" and stops, missing that the actual skill is "retrieval-augmented generation." AstrumU's Skill-LLM work takes a different angle on the same problem: fine-tune a large language model itself as the NER backbone instead of a smaller purpose-built model. Because the LLM's own pretraining already contains most of the technical vocabulary in question, this sidesteps the need for extra domain-specific pretraining, and the fine-tuned Skill-LLM beat both traditional supervised methods and zero-shot or few-shot LLM prompting on its benchmark. The paper also flags a quieter benefit: fine-tuning produces output that's consistently easy to parse, which matters more than it sounds once you're trying to pipe that output into a database.

The third approach builds LLM-centric pipelines with structured output constraints. Plain prompting, with no guardrails, produces exactly the kind of output you'd expect from asking a very confident intern to freestyle: malformed span boundaries, skills that were never in the posting, invalid tags on anything unfamiliar. It reads fine. It's often wrong. The SRICL framework (arxiv:2604.21525, submitted April 2026) tackles this by building format-constrained prompts through semantic retrieval of in-domain examples and skill definitions pulled from ESCO, then layering on supervised fine-tuning and a rule-based verifier that enforces valid tag formats and non-overlapping spans. A separate pipeline, applied by Georgia Tech researchers to a large dataset of postings, combined semantic chunking, retrieval-augmented generation, and fine-tuned DistilBERT models to classify several structured attributes out of job description text at once, showing that RAG-augmented extraction holds up across posting formats and volumes that don't all look alike. A third project built a multilingual pipeline across a very large number of sources, using GPT-4o mini as a labeling oracle to supervise the fine-tuning of a smaller, lighter encoder model. That pattern, an LLM doing the labeling and a lightweight model doing the heavy lifting at scale, has become the standard way to grow annotated data without needing a human to tag every example by hand.

Three approaches, three different ceilings, and the honest conclusion is that the more capable the system gets, the more it needs watching. That's the bridge into the next problem.

Hallucination and span errors in stage one and the need for a deterministic validation layer

LLM-centric extraction is powerful, and it also makes mistakes that look exactly like correct answers. It can name the wrong skill, cut a span in the wrong place, or invent a detail out of surrounding context, and the output will read as perfectly formed the whole time. At the scale these pipelines run, that's the real risk: a small per-job error rate, multiplied across millions of postings, bends the aggregate skill counts in ways nobody notices until a trend line looks off. A reported spike in demand for some skill might be real. It might also be extraction noise wearing a real signal's clothes, and from the outside the two look identical.

The Skill-LLM paper calls out parsability directly as both a limitation and a goal: output that needs manual cleanup or extra automated fixing before it's usable adds cost and delay at every stage the data passes through afterward.

A schema check confirms that extracted skill spans are non-empty, reasonably sized, free of stray numeric-only tokens, and not duplicated within the same record. A type and range check confirms that any confidence scores the model produces fall inside the bounds they're supposed to. A taxonomy lookup flags any extracted string that doesn't map to a known node in the target ontology: genuinely new terms get a second look, and hallucinated strings get thrown out. And before any new scraping target or new extraction prompt goes into full production, a sample of its output should go through a human review pass first, simply to catch systemic problems before they scale.

The economics make the case on their own. Catching a bad extraction before it reaches the normalization stage costs almost nothing. Catching the same error after it's already been mapped onto a taxonomy node and folded into an aggregate count means tracing the damage back through the whole pipeline and rerunning it. Validation early is cheap insurance. Validation late is a repair job.

Stage two, mapping raw extracted strings to a stable skill taxonomy

Normalization is a different engineering problem from extraction, and it deserves its own design, its own data model, and its own update schedule, not a bolt-on step at the end of stage one.

The most established standard here is ESCO, the European Skills, Competences, Qualifications and Occupations framework maintained by the European Commission. It's multilingual, hierarchical, and covers thousands of occupations and skills, and mapping extracted terms onto it lets separate HR systems compare notes consistently across sources and across countries. One multilingual pipeline compiled postings from a very large number of sources and fine-tuned a multilingual sentence encoder to map extracted skills onto the 13,896-entry ESCO taxonomy, using GPT-4o mini to supervise the process. The pattern holds up here the same way it did in stage one: an LLM does the labeling, a lighter encoder model does the mapping at production scale, and nobody has to hand-annotate every term that shows up.

The surface-variation problem from earlier recurs here in its purest form. "Python," "Python programming language," and "Python coding" all need to collapse onto a single taxonomy node, or the aggregate counts built on top of them mean nothing. Research on skill normalization builds frameworks specifically for generating candidate matches and then semantically comparing them against a taxonomy database to solve exactly this. Semantic similarity matching, embedding both the extracted string and the taxonomy node's description and finding the closest match, handles multi-word and paraphrased skills far better than a system that only checks for exact string matches.

New terms are the permanent headache. Skills like "LoRA/QLoRA fine-tuning" or "vLLM serving optimization" may not appear in ESCO or O*NET at all yet, simply because the technology is newer than the last time anyone updated the taxonomy. A production system needs a holding category for anything that doesn't map cleanly, plus a regular review process that checks which unmapped terms are showing up often enough to deserve a permanent slot in the taxonomy. The LLM-as-labeler pattern fits here too: let an LLM propose a candidate mapping for the new term, then route that proposal to a human for a final check. It moves faster than pure human annotation and holds up better than letting an unsupervised system guess on its own.

One more technique belongs in this conversation, even though it sits a step to the side of normalization itself. Work cited in the Skill-LLM paper proposes inferring implicit skills, ones never written down in a posting but clearly assumed, by comparing a posting against a peer group of semantically similar postings and surfacing skills that appear across the peer set but not in the target. It's a useful way to fill in gaps where a posting leaves a skill unsaid. It should also be tagged as inferred rather than explicit in the output, so nobody downstream mistakes a good guess for a stated fact.

The infrastructure layer: acquiring job posting text at production scale

None of the extraction or normalization work matters without a steady supply of raw text to feed it, and getting that text out of job boards reliably, at volume, is its own engineering problem, every bit as involved as the NLP side of the pipeline.

Modern job boards don't hand over their postings in plain HTML anymore. They render content with JavaScript, load additional postings as a user scrolls, and inject content dynamically after the initial page load, so a simple HTTP request often comes back with an empty shell where the posting should be. Getting the real text requires a headless browser that can run the page's JavaScript the way a real visitor's browser would.

High-traffic job boards also run active defenses against automated access: rate limiting, IP-based blocking, and behavioral fingerprinting that looks for patterns no human would produce. Keeping a crawler running against that kind of defense requires rotating across datacenter, residential, and mobile IP addresses, varying the timing between requests so they don't look mechanical, and sending HTTP headers that look like they came from an actual browser. None of this is optional once volume gets high enough to matter. It's the ground floor the entire pipeline stands on, and it has to hold before any of the extraction or normalization work upstream gets a chance to run.

Sources

  1. Skill-LLM: Repurposing General-Purpose LLMs for Skill Extraction
  2. Job description parsing with explainable transformer based ensemble models to extract the technical and non-technical skills - ScienceDirect
  3. LLM-Supervised Multilingual Skill Extraction and Classification from Job Ads

More in Talent Intelligence