CV Screener

At a Glance

The Problem

Job seekers send CVs blindly and never know why they're rejected. Recruiters process hundreds of applications manually with no objective ranking. Existing ATS tools give a score but no explanation — candidates can't act on "68%". CV Screener was built to surface exactly which dimension is dragging the score down and give users a concrete next step to fix it.

The Solution

A fixed three-component weighted hybrid score: Text Similarity via a TF-IDF model (trained on 9.4 MB of real job descriptions, exported to ONNX, inferred in .NET — no Python in production); Skills Score via a curated taxonomy of 50 canonical skills with alias mapping; Experience Score via regex year extraction with a continuous ratio formula. Every result shows all three scores separately, a Matched/Partial/Missing skill breakdown, and a personalized learning path for every gap.

Architecture

• →Backend: .NET 8 Web API with strict Clean Architecture — Core → Infrastructure → API. Zero external NuGet packages in Core. DI registered entirely in Program.cs.
• →Frontend: Next.js 14 (App Router), TypeScript, Tailwind CSS, Clerk authentication. All API calls routed through a typed Axios lib layer.
• →Database: PostgreSQL via Supabase with raw Npgsql SQL — intentionally no ORM. RLS enabled for row-level security.
• →ML Pipeline: Python scikit-learn TF-IDF trained on 9.4 MB corpus → skl2onnx ONNX export (166 KB, 5000-word vocabulary) → Microsoft.ML.OnnxRuntime Singleton inference in .NET.
• →Infrastructure: Vercel (frontend), Railway (backend .NET API), Supabase (PostgreSQL), Clerk (JWT auth + user management).
• →Score labels (Poor / Below Average / Average / Good / Excellent) computed server-side to prevent client-side manipulation.

Key Features

• ✓Hybrid AI scoring: TF-IDF semantic similarity (50%) + Skills Taxonomy (35%) + Experience rules (15%) — three-dimensional, not a black box
• ✓PDF CV upload with PdfPig text extraction — file never stored, only extracted text persists (privacy by design)
• ✓Three-tier skill classification: Matched / Partial / Missing against a curated 50-canonical-skill taxonomy with alias expansion
• ✓Personalized learning path generated for every missing skill — targeted Doc/Course resources to close identified gaps
• ✓Public share links via UUID — no auth required to view a shared analysis report
• ✓Analysis history (last 50 per user) with score progression tracking
• ✓User dashboard with aggregate metrics: total analyses, average score, best score achieved
• ✓Role-based onboarding (Job Seeker / Recruiter) with Clerk JWT authentication
• ✓ONNX ML inference running inside .NET as a Singleton — no Python runtime in production
• ✓Strict Clean Architecture: Core → Infrastructure → API, with zero external NuGet packages in Core

Screenshots

Code Highlight

// MatchingService orchestrates all three engines and persists the result.
// Weights are fixed: Text 50% + Skills 35% + Experience 15%
public async Task<AnalysisResult> AnalyzeAsync(string cvText, string jdText, Guid userId)
{
    var cleanedCv = TextCleaner.Clean(cvText);
    var cleanedJd = TextCleaner.Clean(jdText);

    // Three independent engines — run in any order
    var textSimilarity = await _tfIdfService.ComputeSimilarityAsync(cleanedCv, cleanedJd);
    var skillsResult   = _skillsEngine.Evaluate(cleanedCv, cleanedJd);
    var expResult      = _experienceEngine.Evaluate(cleanedCv, cleanedJd);

    // Fixed hybrid formula — prevents single-dimension gaming
    var overallScore = (int)Math.Round(
        (0.50 * textSimilarity +
         0.35 * skillsResult.Score +
         0.15 * expResult.Score) * 100
    );

    var result = new AnalysisResult
    {
        UserId          = userId,
        OverallScore    = overallScore,
        ScoreLabel      = ScoreLabel.FromScore(overallScore), // Server-side always
        TextSimilarity  = textSimilarity,
        SkillsScore     = skillsResult.Score,
        ExperienceScore = expResult.Score,
        MatchedSkills   = skillsResult.Matched,
        PartialSkills   = skillsResult.Partial,
        MissingSkills   = skillsResult.Missing,
        ExperienceData  = expResult,
        AnalysisVersion = "v2"
    };

    await _analysisRepository.SaveAsync(result);
    return result;
}

Challenges & Solutions

Tech Stack

What I Learned

• 💡ONNX is the right bridge between Python ML training and .NET production inference — training stays in Python's rich ecosystem while inference stays in a type-safe, dependency-free runtime.
• 💡A curated taxonomy beats raw keyword matching: alias expansion dramatically reduces false negatives where a skill is present but named differently.
• 💡Explainability is a feature, not an afterthought — surfacing each dimension separately makes the product trustworthy and actionable, not a black box.
• 💡Clean Architecture's payoff is most visible at integration points: swapping the ONNX model version required changing only OnnxInferenceService, with zero changes to MatchingService, controllers, or DTOs.

Links