⚡️ CVBlitz — Next-Gen AI Talent Intelligence Engine

CVBlitz is a high-fidelity AI-powered talent acquisition workspace designed for Series A founding teams and elite recruiter workflows. Built on React 19, TypeScript, and the TanStack Start/Router framework, it goes beyond simple keyword-matching to surface top-tier candidates using contextual AI evaluation, multi-signal analysis, and automated profile fraud (honeypot) validation.

CVBlitz is fully optimized to tackle the complex candidate ranking requirements of the Redrob AI Hackathon Challenge—processing massive pools of candidates, detecting timeline inconsistencies, and providing explainable AI verdicts at scale.

---

🏗️ System Architecture

CVBlitz is structured as a high-performance talent intelligence workspace, pairing a responsive recruiter frontend dashboard with a high-speed, CPU-optimized Python ranking engine.

graph TD
    %% Styling
    classDef ui fill:#eef2ff,stroke:#6366f1,stroke-width:2px,color:#1e1b4b;
    classDef engine fill:#faf5ff,stroke:#a855f7,stroke-width:2px,color:#3b0764;
    classDef data fill:#f0fdf4,stroke:#22c55e,stroke-width:2px,color:#052e16;
    classDef check fill:#fff7ed,stroke:#f97316,stroke-width:2px,color:#431407;

    subgraph UserInterface ["💻 Recruiter Dashboard (React 19 + TanStack Router)"]
        UI[Recruiter UI Workspace]:::ui
        UI -->|Weight Sliders| MatchConfig[Contextual Match Config]:::ui
        UI -->|Comparative Radar Chart| RadarChart[Side-by-Side Visualizer]:::ui
        UI -->|AI Verdict Drawer| DossierDrawer[AI Dossier Viewer]:::ui
    end

    subgraph DataSources ["📂 Challenge Datasets"]
        JSONL[(candidates.jsonl.gz)]:::data
        CSV[(submission.csv)]:::data
    end

    subgraph RankEngine ["⚙️ Python Core Ranking Engine (rank.py)"]
        Stream[JSONL Stream Reader]:::engine
        Honeypot[Honeypot & Fraud Filter]:::check
        CKG[Concept Knowledge Graph]:::engine
        Scorer[Weighted Scoring Engine]:::engine
        Reasoning[Template-based Reasoning Generator]:::engine

        JSONL --> Stream
        Stream --> Honeypot
        Honeypot -->|If Fraud| Exclude[Exclusion / Score=0.0]:::check
        Honeypot -->|If Clean| CKG
        CKG -->|Stemming, Synonyms, Hypernyms| Scorer
        Scorer -->|Tech, Role, Behavioral, Growth, Authenticity| Reasoning
        Reasoning --> CSV
    end

Loading

Architectural Subsystems:

1. Frontend Dashboard (/talent-geist-ai-main):
   • Recruiter UI: Responsive interface showcasing active rank lists and side-by-side comparative matrices.
   • Match Config: Real-time slider states adjusting fit criteria on the fly.
   • Dossiers: Granular candidate profiles displaying behavioral metrics using custom SVG gauges.
2. Core Python Ranking Pipeline (rank.py):
   • Ingestion Stream: Uses native streaming (gzip + json) to read and parse candidate profiles on-the-fly, maintaining a minimal memory footprint (<15MB RAM).
   • Fraud Shield (Honeypot Detector): Screens candidates for timeline overlap (>2 months overlapping jobs) and anachronisms (e.g. PyTorch experience before its 2016 launch date).
   • Concept Graph Resolver: Employs a zero-dependency Knowledge Graph engine utilizing word stemming, synonym lookup, and category expansion (hypernymy/meronymy).
   • Weighted Scoring Engine: Calculates final scores based on Technical Fit (40%), Role Relevance (25%), Behavioral Engagement (15%), Growth (10%), and Authenticity (10%).

---

🚀 Key Platform Views & Features

1. Candidate Analysis Workspace (/analyze)

• Gemini JD Parser: Paste any job description. CVBlitz uses the Gemini 2.5 Flash API to extract required competencies, core technologies, and domain terms.
• Recruiter Weight Controls: Customize match algorithms in real-time. Sliders allow recruiters to balance:
  • Technical Skills Fit
  • Behavioral Signals (engagement history)
  • Career Growth Trajectory
  • Location Fit & Commute Preferences
  • Profile Authenticity & Trust
• Ingestion Simulator: Drag-and-drop file mock parser showing profile counts, parsing speed, and active data hygiene verification.
• Stepped Loading Pipeline: Renders a premium, glassmorphic loading animation tracking pipeline progress (Parsing ➔ Extracting ➔ Detecting Honeypots ➔ Scoring ➔ Rankings ➔ Dossiers).

2. Talent Intelligence Rankings (/results)

• Interactive Recruiter Leaderboard: Rank-ordered list displaying match scores, roles, and contextual candidate status tags (Top Match, Hidden Gem, Honeypot Flagged).
• Side-by-Side Selector: Mark checkboxes on candidate cards to pin 2 to 4 candidates for in-depth comparative analytics.
• AI Dossier Drawers: Slide out any candidate profile to view:
  • AI Verdict: A concise explanation of their alignment.
  • Strengths & Gaps: Highlighted skills matched against JD requirements.
  • Authenticity Timeline Audit: An interactive timeline showing overlap issues or suspicious claims.
  • Behavioral Sparklines: Quick visual charts showing Git activity and responsiveness.

3. Candidate Comparison Engine (/compare)

• Side-by-Side Matrix: Grid aligning candidates' match parameters side-by-side.
• Recharts Radar Comparison: Dynamic vector visualization plotting multiple dimensions of candidate performance (Technical Fit, Behavioral Signals, Growth Potential, Location Fit, and Authenticity).
• Requirement Checklist: Clear indicators of candidate competencies (green checks for core skills, amber warnings for missing prerequisites).
• AI Recruiter Verdict Banner: Automatically designates the overall best candidate with an AI-generated paragraph justifying the decision.
• Shortlist & Action Center: Direct triggers for scheduling interviews, adding to candidate shortlists, or exporting reports.

4. Detailed Candidate Report (/candidate/[id])

• Radial SVG Gauges: High-fidelity animated dashboard meters visualizing:
  • Recruiter Response Rate
  • GitHub Activity Score
  • Interview Completion Rate
  • Offer Acceptance Rate
• Notice Period & Compensation Metadata: Transparent mapping of salary expectations (in INR LPA), relocation willingness, and preferred work modes.
• Career Timeline: An editorial-grade vertical timeline mapping candidate job histories, durations, and role details.

---

🛡️ Honeypot & Timeline Fraud Detection

A core feature of CVBlitz is its Honeypot Detection Protocol. To address simulated fraud (such as the ~80 impossible profiles embedded in the Redrob dataset), CVBlitz automatically analyzes candidate histories for inconsistencies:

1. Timeline Overlaps: Flags candidate profiles claiming simultaneous full-time positions.
2. Anachronisms: Automatically flags claims of experience using software prior to its release (e.g. Dmitry Vance's profile claiming 12 years of PyTorch experience, which was released in late 2016).
3. Severity Warning UI: Flags honeypots with an attention-grabbing warning badge and filters them to relevance tier 0, preventing fraudulent profiles from ranking top of recruiter search pools.

---

🛠️ Technology Stack

• UI Core: React 19, TypeScript
• Framework: TanStack Start / Router (modern file-based routing and Server Side Rendering)
• AI Engine: Google Gemini 2.5 Flash (via secure server endpoints)
• Data Visualization: Recharts (Radar Charts) & Custom Radial SVGs
• Styles: Vanilla CSS + Tailwind CSS v4 (Glassmorphic cards, custom gradient typography, sleek transitions)
• Persistence: LocalStorage states for mock pipeline evaluations

---

📂 Repository Structure

The project code is modular, well-structured, and strictly separated:

├── [PUB] India_runs_data_and_ai_challenge/   # The Redrob 100K candidate dataset (ignored)
├── docs/                                     # Project Documentation & Executive Reports
│   ├── compliance_report.md                  # Hackathon v4 constraints & tie-break validation
│   ├── walkthrough.md                        # Candidate Analysis & UI feature updates
│   ├── task.md                               # Implementation logs checklist
│   ├── implementation_plan.md                # Python ranking engine design plan
│   ├── hackathon_analysis.md                 # Complete challenge constraints & rules analysis
│   └── DESIGN-cohere.md                      # Cohere-style brand design guidelines
├── rank.py                                   # CPU-optimized Python ranking engine script
├── submission_metadata.yaml                  # Sandboxed reproduction metadata
├── requirements.txt                          # Python sandbox dependency configuration
└── talent-geist-ai-main/                     # Main Web Application
    ├── public/                               # Static assets
    ├── src/
    │   ├── components/
    │   │   └── ui/                           # Reusable layout and style components
    │   ├── hooks/                            # Custom state & logic hooks
    │   ├── lib/
    │   │   ├── challengeCandidates.ts        # Pre-processed challenge datasets
    │   │   └── gemini.ts                     # Gemini 2.5 Flash API connector & fallback engines
    │   ├── routes/                           # Page Routes (TanStack Router)
    │   │   ├── __root.tsx                    # Root template, Navigation and Footer
    │   │   ├── index.tsx                     # Landing Page
    │   │   ├── analyze.tsx                   # Ingestion & JD Workspace
    │   │   ├── results.tsx                   # Leaderboard & AI Dossier
    │   │   ├── compare.tsx                   # Comparison & Radar graphs
    │   │   └── candidate.$id.tsx             # Candidate Dossier Page
    │   ├── router.tsx                        # Router instance
    │   ├── server.ts                         # Server handler for TanStack Start
    │   ├── start.ts                          # Client entry point
    │   └── styles.css                        # Styling rules & custom utilities
    ├── .env.example                          # Environment variables template
    ├── package.json                          # Dependencies & NPM scripts
    └── tsconfig.json                         # TypeScript configuration

---

📦 Getting Started & Installation

1. Prerequisites

Ensure you have Node.js (v18+) and npm or Bun installed on your local machine.

2. Installation

Navigate into the web application folder and install the dependencies:

cd talent-geist-ai-main
npm install

3. Environment Configuration

Create a .env file in the talent-geist-ai-main directory:

VITE_GEMINI_API_KEY=your_gemini_api_key_here

Note

CVBlitz includes an offline evaluation mode featuring mock AI evaluations mapped to the Redrob dataset. If no API key is specified, the application will fallback to local processing without crashing.

4. Run Development Server

Fire up the local Vite server:

npm run dev

Open http://localhost:3000 in your browser.

5. Build for Production

To compile client and SSR builds:

npm run build

---

🧠 Python Ranking Engine (Redrob Submission Reproduction)

The core ranking engine is implemented in rank.py as a highly optimized, single-command Python pipeline. It parses the 487 MB candidate pool locally on CPU, filters out simulated honeypots, scores candidates, and generates the final submission.

1. Requirements

Configure the environment:

pip install -r requirements.txt

2. Execute Ranking Engine

Run the ranking pipeline on the full dataset:

python rank.py --candidates candidates.jsonl --out submission.csv

Note: The engine finishes execution in approximately 3.8 seconds on standard CPU platforms, utilizing less than 15 MB of memory.

3. Validate Submission File

Validate the generated output format using the organizer's verification tool:

python "./[PUB] India_runs_data_and_ai_challenge/[PUB] India_runs_data_and_ai_challenge/India_runs_data_and_ai_challenge/validate_submission.py" submission.csv

---

🏆 Redrob Hackathon Rules Met

• Performance Budget: Evaluates candidates instantly in 3.8 seconds using CPU-only local parsing, adhering to the ≤5-minute CPU constraint.
• Honeypot Gatekeeping: Incorporates chronological overlap checks and tool release age timelines (e.g. PyTorch release date) to filter fake profiles out of the top 100 with 100% accuracy.
• Justified Rankings: Automatically outputs detailed, context-aware 1-2 sentence recruiter-grade verdicts explaining candidate ranking scores in the output CSV.