Deep dive · 10xJobs · live
10xJobs: search optimisation with segmentation
Matching jobs to profiles like a hash table: both are reduced to segment keys, so each job is only compared with the profiles in its bucket instead of every profile.
Problem
The naive matcher compares every new job with every published profile: N jobs × M profiles, and each comparison checks role, seniority, arrangement, places, contract and a whole tech stack. Most of those comparisons are pointless, a senior backend profile in Europe will never match a junior iOS job in the US, but they still cost time and, when a model is involved, money. The cost grows with both sides at once.
Constraints
- Exact results: the optimisation must never drop a job that the full comparison would have matched.
- Cheap updates: users edit profiles and new jobs arrive constantly; the index must update per record, not by rebuilding.
- Multi-valued profiles: a profile can accept several seniorities, places or arrangements.
The hashing analogy
A hash table does not search every slot: it computes a key from the item and goes straight to one bucket, and only items in that bucket are compared for equality. Matching works the same way.
- Hash function → segmentation. The fields that must match exactly (role family, seniority, arrangement, region, contract) are reduced to a segment key, for example
ai-engineer | senior | remote | eu. - Buckets → segments. A profile is registered in every segment its answers allow; a profile accepting mid and senior lives in both buckets. A job, once its fields are extracted, lands in its segment.
- Lookup → candidate set. A new job only looks at the profiles in its bucket: a direct lookup instead of a scan.
- Collisions → the full check. Sharing a bucket only means “possibly a match”. The precise comparison (every answer, the rated tech stack) runs only on that small candidate set, the way a hash table still compares keys inside a bucket.
- Incomplete posts get their own bucket. A post with one or more fields “Not stated”, such as seniority, goes to a dedicated bucket for incomplete posts, so it can still reach the profiles that accept it instead of vanishing from every bucket.
Architecture
Each job carries a job key and its post URL, which are used to merge the same job when it appears on several sources.


Key decisions
- Segment on the fields that must match exactly. Only hard filters go into the key; graded signals like the tech-stack ratings stay in the full check, so segmentation never changes the result, only the work.
- Pay at write time, not at read time. A profile is placed in its buckets when it is saved, so each new job costs one lookup plus a handful of comparisons, instead of M comparisons.
- Coarse keys over perfect keys. Like choosing a hash function: a key that is too fine fragments the search into many small, overlapping queries, while a coarse key groups them so the same search is not run twice.
- Keep the exact check. The bucket narrows; it never decides. That is what keeps the optimisation safe.
Results
Numbers to come.