AI Powered Resume Analyzer
Solo Developer
A full stack web app that matches a candidate's resume against job descriptions using AI embeddings and vector search, returning a match score and a plain language explanation of why each role fits.
Overview
About the project
Job seekers lose hours manually comparing their resume against dozens of job postings, guessing which roles actually fit their experience. Plain keyword matching misses the point, because two descriptions can use completely different wording for the same skill. What was missing was a tool that understands meaning rather than just text, and that can explain its reasoning instead of returning an opaque score.
I built the application end to end with ASP.NET Core and a Blazor WebAssembly front end. Uploaded resumes and job descriptions are converted into numerical embeddings with the OpenAI API, capturing their semantic meaning rather than exact keywords. Those vectors are stored in Pinecone, which performs fast similarity search to surface the closest matching roles. For every match, the app then generates a short, human readable explanation of why the resume fits, so the score is transparent rather than a black box.
The result is a working tool that turns a slow, manual comparison into a few seconds of work. It ranks roles by genuine semantic relevance and gives each candidate clear reasoning behind every match score.
System Overview
At a glance
A full stack web application that compares a candidate's resume against job descriptions semantically rather than by keyword. ASP.NET Core sits at the centre, calling OpenAI for embeddings, Pinecone for similarity search, and routing the results back to a Blazor WebAssembly front end that explains why every match scored the way it did.
How It Works
System Architecture
Blazor WebAssembly UI
Front end for uploading resumes and viewing ranked matches
ASP.NET Core API
Backend that orchestrates embedding, search, and explanations
OpenAI Embeddings
Turns resume and job text into vectors that capture meaning
Pinecone
Vector database that powers fast similarity search
Process Flow
How the project moves from start to finish, step by step.
Upload
A candidate uploads a resume along with the job descriptions to compare against.
Embed
The API sends each document to OpenAI and receives a semantic embedding.
Match
Pinecone runs similarity search to rank the closest job descriptions.
Explain
The app generates a plain language reason behind every match score.
System Breakdown
System Components
Each layer owns one job, so any one of them can be swapped out without rewriting the others.
Front End
Blazor WebAssembly
Handles uploads, surfaces ranked matches, and renders the per match explanation.
File Upload Controls
Accepts the candidate resume and a set of job descriptions to compare against.
Match View
Lists each role with its score and the short, written justification.
Backend Services
ASP.NET Core API
Orchestrates the embedding, search, and explanation pipeline.
REST Endpoints
Clean entry points the front end calls for upload, search, and explain.
Validation Layer
Sanity checks on input before anything reaches the AI services.
AI Services
OpenAI Embeddings
Turns resume and job description text into vectors that capture meaning.
Pinecone Vector DB
Stores the vectors and runs fast similarity search at scale.
Explanation Generation
Generates a short, plain language reason for every match.
Workflows
Match Pipeline
From upload to ranked, explained matches, in four steps.
Document Ingestion
Purpose: Get the input ready for semantic processing.
How it works
- Accept resume and job description uploads via the API.
- Validate format and extract the readable text.
- Normalise the text so embeddings reflect content, not noise.
Embedding Generation
Purpose: Translate text into a representation that captures meaning.
How it works
- Send each document to the OpenAI embeddings endpoint.
- Receive a vector representation per document.
- Tag every vector with the metadata needed for later retrieval.
Similarity Search
Purpose: Find the closest matching roles, fast.
How it works
- Upsert the new vectors into Pinecone.
- Run a similarity query for the candidate resume against the job vectors.
- Return ranked matches with a relevance score per role.
Explanation Generation
Purpose: Make every score readable rather than opaque.
How it works
- Pair each matched document with the candidate resume.
- Ask the model to summarise the overlap in a short paragraph.
- Return the score and the written reasoning together to the front end.
What It Does
Features & Capabilities
Semantic Matching
Compares the meaning of resumes and roles, not just shared keywords.
Explainable Scores
Every match comes with a written justification a person can read.
Fast Vector Search
Pinecone returns ranked roles in seconds, even as the data grows.
Full Stack Build
A complete app from Blazor UI through API to vector database.
Running It