🔭

TalentLens

Redrob Hackathon · 2026

Submission
Ruthvik Goud
Solo Entry
Submission Live · All Tests Passing

Explainable Multi-Signal
Candidate Ranking Engine

TalentLens ranks 100,000 candidates against a Senior AI Engineer job description using four weighted scoring engines — Career Evidence, Skill Relevance, Recruitability Index, and Semantic Match — producing ranked, explainable results in under 3 minutes on a standard CPU.

100K Candidates
<3 Min Runtime
4 Scoring Engines
Offline Demo Mode
XAI Explainable AI
🚀 Live Demo 📊 Interactive Dashboard ⬡ GitHub Repository 📖 Documentation 💼 LinkedIn ✉️ Contact
System Architecture
Four-Stage Ranking Pipeline

A deterministic, fully local pipeline — no API calls during inference. Every score is traceable back to specific signals in the candidate's profile.

📂

1. Data Ingest

JSONL / GZ stream loading with schema validation

candidates.jsonl job_description.txt
⚙️

2. Feature Extraction

Normalized skill matching, career history parsing, signal processing

extract_features() normalize_skill()
🧮

3. Multi-Signal Scoring

Career, Skills, Recruitability, TF-IDF Semantic + Honeypot Penalty

score_career() score_skills()
📊

4. Rank & Explain

Weighted aggregation, monotonic sort, human-readable reasoning output

submission.csv reasoning
Data Flow
candidates.jsonl (100K records)
→
extract_features(): 22 feature dimensions
→
TF-IDF fit (corpus + JD, 5K features)
→
4 scoring engines run in parallel
→
submission.csv (Top 100 ranked)
35%
Career Evidence & Trajectory
Rewards production deployments in retrieval/search/ranking. Penalizes consulting-only backgrounds (ratio-based) and non-domain roles (CV, Speech, Robotics).
prod_hits domain_hits exp_scale trajectory_mult consulting_penalty
25%
Recruitability Index
Weights recency (last active date), response rate, completion rate, notice period, open-to-work flag, GitHub activity, and profile completeness.
recency_mult resp_rate notice_days open_to_work github_score
25%
Explicit Skill Relevance
Separates 14 must-have skills (embeddings, FAISS, Weaviate, etc.) from nice-to-haves using proficiency tier and duration_months as quality signals.
is_skill_match() prof_mult dur_mult assessment_bonus
15%
Semantic Match (TF-IDF)
Single TF-IDF vectorizer fitted once across all 100K candidates + JD text. Cosine similarity captures vocabulary overlap missed by keyword matching.
TfidfVectorizer ngram (1,2) cosine_similarity sublinear_tf
Data Pipeline
Candidate Filtering Funnel

How TalentLens distills 100,000 raw applicants down to the top 10 best-fit finalists in under 3 minutes.

Stage 1
100K Candidates Scored
Initial ingestion from candidate database stream. Full corpus loaded and feature-extracted.
candidates.jsonl JSONL stream schema validation
▼
Stage 2
1K Semantic Matches
TF-IDF indexing & skill normalizer creates a rich matching pool from top semantic candidates.
normalize_skill() cosine_similarity TF-IDF 5K features
▼
Stage 3
100 Ranked Candidates
4-engine weighted scoring with honeypot contradiction detection and penalty application.
scoring_engine honeypot_detection 4 weighted signals
▼
Stage 4 · Final
10 🏆 Finalists
Top-tier finalists with full explainability, evidence-grounded reasoning and per-signal score breakdown.
submission.csv explainability_panel recruiter reasoning
Ranked Output
Top 100 Candidates

Monotonically ranked by weighted aggregate score. All scores normalized to 0–100.

🏆 Top 3 Finalists — The Podium

Gold · Silver · Bronze ranked by weighted multi-signal score

Showing 100 of 100,000 candidates · Top 100 selected
Rank Candidate ID Final Score Recruitability Recruiter Reasoning
System Architecture Note
Engineering Decisions

Key design choices made to maximize ranking quality and explainability.

⚡ Performance

  • Single TF-IDF fit across the entire corpus (not per-candidate) — prevents data leakage and reduces compute to O(N)
  • Streaming JSONL reader with GZ support — handles datasets too large for RAM
  • Vectorized scoring with NumPy; no deep learning inference at runtime
  • Full 100K pipeline completes in ~3 minutes on 4-core CPU, 16GB RAM

🎯 JD-Driven Design

  • Every penalty and reward maps to an explicit signal in the job description text
  • Consulting firm penalty is ratio-based (not binary) — partial consulting histories are scored proportionally
  • Skill ceiling set at 13.0 pts (not 25+) to prevent score compression and allow realistic top scores
  • Notice period scoring mirrors JD's stated preference: sub-30 days buyable, >90 days is a hard bar raise

🛡️ Anti-Honeypot Logic

  • Detects impossible claim/evidence contradictions: "claims 15+ years but zero career entries"
  • Flags AI/ML headline with zero technical description evidence (keyword stuffing)
  • Penalizes non-technical career histories with AI skill keywords
  • Penalties are bounded (max 100 pts) and applied as a multiplier (10%) on final score, not a hard disqualification — preserving explainability

📝 Explainability

  • Every candidate gets a two-sentence natural language reasoning string generated deterministically from their score components
  • Full component scores exported in full_output.csv for recruiter inspection
  • Skill normalization (hyphen, spacing, plural stripping) exposed via normalize_skill() — auditable
  • Test suite (test_app.py) verifies correct scoring on 3 archetypal candidate profiles
Weighted Score Formula
# Weighted aggregate — weights derived from JD signal priority weighted_score = ( score_career(feat) * 0.35 # Career Evidence & Trajectory + score_recruitability(feat) * 0.25 # Availability & Responsiveness + score_skills(feat) * 0.25 # Explicit Skill Relevance + tfidf_cosine_similarity * 0.15 # Semantic Match ) final_score = max(0.0, weighted_score - honeypot_penalty * 0.10)
Submission Declarations
Compliance & Reproducibility
✅
Original Work

All scoring logic is original. No pre-built matching libraries used. AI tools (Claude) used for architectural discussion and code review only — no candidate data was processed by any LLM.

🔁
Reproducible

Single command: python app.py. Place candidates.jsonl in directory. No pre-computation, no GPU, no internet required. Runtime: ~3 minutes on standard CPU.

🧪
Tested

Test suite in test_app.py validates three archetypal candidates: Perfect AI Engineer (must score >70), CV Specialist (must score <40), Consulting Developer (career <40).

🏛️
Spec Compliant

Output CSV has columns: candidate_id, rank, score, reasoning. Exactly 100 rows. Scores are monotonically non-increasing. Ties broken by candidate_id ascending.

🌐
No Network at Runtime

Zero external API calls during ranking. All computation is local: TF-IDF, skill matching, and scoring engines run entirely in-process with no internet dependency.

🔎
Honeypot-Aware

Contradiction detection engine identifies ~80 honeypot profiles via impossible claim-to-evidence ratios. Penalties are applied proportionally rather than as hard filters.

Team & Project Resources
Submission Details & Project Links

Explore resource repositories, developer contacts, final documentation, and hackathon project links.

👥
Team Profile

Ruthvik Goud — Sole Developer & AI Architect
GitHub: @ruthvikgoud16
LinkedIn: Ruthvik Goud Profile
Email: bathiniruthvik370@gmail.com

🔗
Project Resources

⬡ GitHub Repository
📖 Project Documentation
🏆 Submission Demo Viewer
📊 TalentLens Dashboard

📜
Acknowledgements

Developed for the Redrob Hackathon. Special thanks to the Redrob team and mentors for their guidance, test dataset, and evaluation schema.