Recruiting intelligence platform with hybrid search, asynchronous resume ingestion, and graph-based skill expansion.
TypeScript · Next.js · PostgreSQL + pgvector · Neo4j · Redis · BullMQ · better-auth
Recruiters and candidates describe the same skills in different language.
A recruiter searches for a Machine Learning Engineer. The candidate's profile says Python, PyTorch, MLOps, Docker, Statistics. Keyword search never connects them. GetFinalOffer is built around closing that gap: every query is expanded through a skill taxonomy graph before retrieval, and every stage of the pipeline is measured, cached, and circuit-broken so the graph can fail without taking search down with it.
Two sides use it:
- Candidates build a profile, upload a resume, and record verified interview progress at partner companies — with document-backed claims and per-organisation visibility control.
- Recruiters at partner organisations search a hybrid index and reach out with invites, seeing verified signals before they spend a screen.
- Tiered hybrid retrieval. Exact cache, then semantic cache, then the Redis live index, then pgvector — each tier falls back to the next, so a cache miss never becomes an outage.
- Query understanding. Conversational queries ("backend wizard") are expanded into concrete technical terms by an LLM step before retrieval.
- Graph expansion. A Neo4j skill taxonomy expands role and skill seeds through role/skill/alias traversal, scored with IDF weighting, depth penalties, and per-seniority top-k.
- Cross-encoder reranking. A local ONNX model scores query/passage pairs with a hard timeout, falling back to baseline order if the model cannot load in time.
- AI relevance notes. The strongest matches carry a one-line evaluation rationale, so a score is never just a number.
- Stealth enforcement. A candidate who blocked a recruiter's organisation is invisible in every retrieval path — live, semantic, browse, and direct profile access all return the same not-found.
- Asynchronous pipeline. A resume upload flows through a BullMQ chain: LLM skill extraction with confidence scoring, chunking, batched embeddings, then index publication — the request never waits on it.
- Interview progress. Per-entry history with verification states; an edit only resets verification when a substantive claim actually changed.
- Content-hash dedupe. Re-uploads skip re-embedding unchanged text, keeping OpenAI spend proportional to what actually changed.
- Auth. Email/password accounts with candidate and recruiter roles. Roles are server-owned: signup always creates a candidate, and the only promotion path is a recruiter flow that verifies the work-email domain server-side. Sign-in and sign-up are rate-limited in shared storage, so limits hold across serverless instances.
- Verification. Documents land in private storage; reviewers see short-lived signed links, and every decision writes an append-only audit row.
- Analytics. Client events batch to Redis, drain to Postgres through a worker, and failed rows go to a dead-letter queue instead of vanishing.
- Graph telemetry. Per-minute metrics flush to Postgres; alert rules watch fallback and zero-expansion rates; rollout snapshots record every flag change.
- Observability. Sentry error tracking and OpenTelemetry tracing hooks throughout.
- The search API verifies the caller is a recruiter and applies a rate limit.
- Page-one queries consult the exact cache, then the semantic cache.
- The live Redis index and the vector path retrieve the baseline pool.
- When both come up empty, the browse path returns recently indexed candidates.
- Execution is feature-flagged —
off,shadow, oron, with a traffic-percentage hash for gradual ramps. - The query and the expanded keywords become deterministic graph seeds: exact match first, contains fallback second.
- Neo4j returns related skills via traversal, cached with a configurable TTL.
- Graph scores blend into the baseline ranking in
onmode; inshadowthey are recorded but never applied. - A circuit breaker and per-stage fallbacks keep the baseline path available whenever Neo4j is slow or unreachable.
Cached graph expansion runs at roughly p50 ~40ms, p95 ~50ms; uncached at p50 ~430ms, p95 ~855ms, with a 0% fallback rate on the tested benchmark set. These numbers are environment-specific — re-measure in your own environment before ramping traffic.
| Path | What lives there |
|---|---|
app/ |
App Router pages and API routes |
features/ |
Feature modules: data access (server), repositories (client fetchers), use-cases, DTOs, UI |
lib/ |
Infrastructure: queue, Redis, search engine, graph, agents, reranker, caches, alerts |
workers/ |
BullMQ workers and interval processors, one entrypoint |
scripts/graph/ |
Taxonomy import, build, validation, sync, and benchmark tooling |
db/ |
Drizzle schema, migrations, and the hybrid-search RPC |
data/skill-graph/ |
Committed taxonomy sources |
e2e/ |
Playwright specs |
Near-term — graph quality dashboarding for fallback and zero-expansion trends; alias coverage improvements; taxonomy QA automation.
Mid-term — uncached latency reduction through regional infrastructure; multilingual skill normalization; recruiter-facing explainability for individual graph matches.
MIT License — see LICENSE.
Built by Sandeep Bist sandeepbist.vercel.app · LinkedIn · GitHub · Email






