Everyone Has React and TypeScript. Almost Nobody Has React and Rust.

We have now written the single-technology version of this post three times (TypeScript, Python, React), and every time the same objection came back at us from our own data: naming one technology tells you almost nothing.

Python appears in 5,869 of the 14,106 open roles we can read a stack from. That is not a skill, that is a pulse. "I know Python" narrows the field by roughly nothing, which is a strange thing for us to admit given we published a whole post counting Python companies.

So this time we counted pairs instead, and the pairs turned out to be the interesting part.

The pair that stopped being a pair

Start with the combination everyone reaches for. React and TypeScript appear together in 1,400 roles. That is 70% of every role that names React.

Sit with that for a second. If a job post says React, it says TypeScript more than two times out of three. The pair is not a combination anymore, it is one skill wearing two names. Listing both on your CV is closer to writing "HTML" than to telling anyone something they didn't assume.

The same goes for a few other pairings that feel like credentials and aren't. 85% of the roles naming Next.js also name React (that one is basically a tautology, Next.js being a React framework). 68% of Node.js roles name TypeScript.

None of this means the skills are worthless. It means they are not signal. Everybody in the room has them.

What an actual cluster looks like

To find the real pairs we used lift, which is a boring word for a simple question: do these two show up together more often than chance would predict? A lift of 1.0 means the two technologies ignore each other completely. A lift of 19 means that when you see one, you are nineteen times more likely than random to see the other.

Grafana and Prometheus is the cleanest example on the platform. 75% of Grafana roles name Prometheus, and 81% of Prometheus roles name Grafana. They are not two tools that happen to get along, they are one job with two logos.

These clusters are what the market actually hires. Not "a data engineer", but specifically the Airflow-dbt-Snowflake shape, or the Databricks-Spark shape, which are different jobs that a job board would file under the same title.

Except some of those "clusters" are a sentence, not a stack

Before you trust that table, look at what happens when we run the same measure on frontend frameworks.

Vue and Angular score 23.9, higher than every pair in the table above. It's also obviously nonsense: nobody runs Vue and Angular and React together. All 51 of the roles naming Vue and Angular name React too.

What those postings say is "experience with React, Vue or Angular". One sentence, three logos, and our extractor faithfully records all three. The pair isn't a stack, it's the word or.

This is the thing that nearly took the whole post down, and it generalises. The same shape shows up in the clouds (95% of roles naming Azure also name AWS), and in PyTorch and TensorFlow (lift 24.8, higher still). Those aren't teams running three clouds or two deep-learning frameworks. They're a hiring manager writing "cloud experience" and "you know a DL framework" in the only vocabulary a job post has: brand names. Unity, Godot and Unreal in one post doesn't mean three engines, it means game dev.

So the honest version of the lift table above is: lift cannot tell you whether two technologies belong together or are alternatives to each other. It only counts co-occurrence. Vue+Angular (23.9) and Grafana+Prometheus (20.2) look identical to the arithmetic and mean opposite things. The only thing separating them is knowing that Vue and Angular are the same kind of thing, and Grafana and Prometheus aren't.

We threw the clouds, the DL frameworks and the frontend frameworks out of the cluster table for that reason. Everything left in it pairs across categories, which is what a real stack looks like: a language and its runtime, a warehouse and its transform tool, a metrics store and its dashboard.

The walls are the useful part

Here is where it gets more interesting than "things that go together go together". Some very common technologies almost never appear in the same role.

React is in 1,990 roles. Spark is in 1,008. If the two were independent you would expect them to collide by accident about 142 times. They manage 34. A lift of 0.24 means the pair is four times rarer than random chance, which takes effort.

So there is a wall between the browser and the data platform, and it is a tall one. There is another between systems programming and the frontend (C++ and TypeScript, lift 0.33). Kotlin and Python barely acknowledge each other despite both being enormous.

Nobody planned these walls. They are just what happens when 868 companies independently write down what they need, and it turns out the industry has quietly sorted itself into a handful of neighbourhoods that don't visit.

What we would do with this

Two honest readings, and they point in opposite directions, which is why we are giving you both instead of a rule.

Pick a cluster and go deep. If you are already in the Airflow-dbt-Snowflake world, the next tool in that cluster is worth more to you than a fashionable one outside it, because the roles that want one want the others. Your stack is not a list, it is a position on a map, and the map has dense parts.

Or cross a wall on purpose. Only 65 roles want React and Rust together. That is a rounding error, and it cuts both ways: it might mean nobody wants that person, or it might mean the handful of teams who do want that person have almost no one to call. We genuinely cannot tell you which from this table. The tell would be how long those 65 roles stay open, and that is a question we can answer, just not in this post. It's the next one. If someone tells you confidently that rare combinations always pay more, they are guessing too.

What the data does say plainly is that the expected combination has no information in it. React plus TypeScript is the industry's way of saying "a frontend developer". If you want a stack that means something specific, it has to be a stack that not everyone has.

Where this data is soft

The honest section, because you should know what you are reading.

We read technologies out of job-post text, so a tag means a company mentioned it, not that it is definitely in production. A post that says "some exposure to Rust is a plus" counts the same as one built on Rust.

The alternative-set problem above is the big one, and it means every number here required a judgement call about which co-occurrences are real. We made those calls by hand. Somebody else would draw a couple of the lines differently, and we would not argue very hard.

We also dropped concept tags (AI, LLM, machine learning, SQL, Git, HTML). They are real in the data, but they are not skills you can meaningfully pair. "Python and SQL" is not a cluster, it is a job description.

Raw tags are messy underneath. The stored data has "Go" and "Golang" as separate strings, which would make one language look like two with contradictory numbers. Everything above is normalised through the same registry that powers our technology pages, so Go is Go.

We are also not the first to count this. IT Jobs Watch has published co-occurring-skill tables for UK job ads for about twenty years, and they are worth your time if you want the British version with a longer history. What we can add is a different slice: global rather than UK, tech companies specifically, and the walls rather than the top pairs.

And the universe is ours, not the world's: as of July 22, 1,073 tech companies we track, 868 of them currently hiring, 14,106 roles with a readable stack out of 15,160 open. (Those totals drift by the week, so if you open the market page and find they have moved a little, that is the board turning over rather than a typo here.) That is a real slice of the market, not the whole of it, and it skews toward companies that publish an honest careers page.

Go look at your own cluster

Every technology above has a page with the companies hiring for it: remoet.dev/tech. If you would rather ask than browse, you can connect your agent and have it check your own stack against the map.

We are still unsure about the rare-combination question, and it is the one we care most about. If you are one of the 65 React-and-Rust people, we would like to know whether that has made your search easier or harder, because our data can see the roles but not what happens to you when you apply.

Come argue with us on Discord, especially if your neighbourhood is missing from the map.