-
Landing Page
-
Streamlit App
Inspiration
The spark for HireMind came from a deeply frustrating and surprisingly universal experience: sending out dozens of polished, carefully crafted resumes and hearing nothing back — not even a rejection. No feedback, no explanation, just silence. After digging into how modern hiring actually works, the reality was sobering. Over 75% of resumes are automatically rejected by Applicant Tracking Systems (ATS) before a human recruiter ever sees them. These aren't bad candidates they're just people who don't know the invisible rules of the machine reading their resume. Keywords in the wrong format, skills listed but never validated against real projects, bullet points that lack quantifiable impact the ATS filters them all out silently. The problem isn't talent. It's information asymmetry. Recruiters and large companies have sophisticated tools to filter candidates at scale. Job seekers have... a Word document and a prayer. HireMind was built to close that gap to give every job seeker the same X-ray vision into their own resume that the hiring systems have, and then tell them exactly how to fix it.
What it does
HireMind is a full-stack, AI-driven resume intelligence platform that does what no simple keyword checker can: it understands your resume the way both an ATS bot and a senior recruiter would.
Upload your resume (PDF or DOCX). Paste a job description. Get a complete analysis in seconds.
The final overall score is a weighted composite:
$$\text{Score} = 0.40 \cdot S_{kw} + 0.30 \cdot S_{content} + 0.15 \cdot S_{format} + 0.15 \cdot S_{ats}$$
Where each sub-score $S_i$ is normalized to a 0–100 scale from its raw component maximum, and the final result is bounded:
$$\text{FinalScore} = \min\left(100,\ \max\left(0,\ \text{Score} + \sum B_i - \sum P_j\right)\right)$$
with $B_i$ representing bonuses (e.g., perfect grammar, high skill validation) and $P_j$ representing penalties (e.g., missing JD keywords, privacy risks, formatting issues).
Beyond the score, HireMind delivers:
Semantic JD Match — a cosine similarity score measuring how well your resume's meaning aligns with the job description Skill Gap Analysis — which required skills are missing vs. validated Privacy Risk Detection — flags exposed street addresses, zip codes, and excessive location data Actionable LLM Feedback — a qualitative, paragraph-level review powered by Groq's LLM inference engine Exportable PDF Report — a styled, publication-grade analysis report generated dynamically via WeasyPrint
How we built it
HireMind was architected as a three-layer system: an NLP/ML engine, a FastAPI backend, and a Streamlit frontend — each chosen deliberately for performance and fit.
🧠 The ML Core — Semantic Understanding The heart of HireMind is semantic similarity scoring using Hugging Face sentence-transformers (all-MiniLM-L6-v2). Rather than naive keyword counting, it encodes both resume text and job description into high-dimensional vector embeddings and computes cosine similarity:
$$\text{sim}(\mathbf{A}, \mathbf{B}) = \frac{\mathbf{A} \cdot \mathbf{B}}{|\mathbf{A}| \cdot |\mathbf{B}|}$$
This means "Python developer with 3 years of FastAPI experience" will correctly match against "senior backend engineer proficient in RESTful APIs" — even with zero keyword overlap.
For skill extraction and Named Entity Recognition, I used spaCy (en_core_web_md) which provides tokenization, POS tagging, and NER in a single pipeline pass. Keyword normalization is handled by RapidFuzz with an 80-point token sort ratio threshold, catching typos and minor variations.
🔧 The Skill Validation Engine One of HireMind's most novel features is cross-referencing listed skills against actual project descriptions and work experience. A skill that appears in the skills section but has zero semantic presence in any project or experience entry is flagged as "unvalidated" — a signal that recruiters are increasingly watching for. The validation score scales linearly:
$$S_{\text{validation}} = \frac{|\text{Validated Skills}|}{|\text{Total Skills}|} \times 15$$
⚙️ Backend — FastAPI + Async Architecture The backend is built on FastAPI with async lifecycle management, structured as a modular service layer:
resume_parser.py — PDF/DOCX extraction via pdfplumber, PyPDF2, and python-docx ats_scorer.py — the full scoring pipeline jd_matcher.py — job description comparison and semantic alignment feedback_engine.py — structured feedback generation recommendation_engine.py — prioritized, actionable improvement suggestions report_generator.py + pdf_export.py — dynamic PDF compilation via WeasyPrint + Jinja2 groq_parser.py — LLM integration via Groq API for qualitative review 🖥️ Frontend — Streamlit Dashboard The UI is a rich, multi-tab Streamlit application that renders score breakdowns, skill gap visualizations, matched/missing keywords, and the full LLM feedback — all in a live, interactive analytical dashboard.
☁️ Infrastructure — AWS EC2 + Systemd Deployment runs on an AWS EC2 t3.micro Ubuntu instance with a systemd background daemon for 24/7 uptime. To handle the ~800MB–1.2GB RAM footprint of PyTorch + spaCy + WeasyPrint, I configured 2GB of virtual SSD swap space, effectively giving a budget server the headroom to run production ML workloads reliably and at zero hosting cost.
Data persistence (user auth, resume history logs) is handled via Supabase (PostgreSQL + Auth).
Challenges we ran into
The Memory Wall The single biggest technical challenge was RAM. PyTorch with sentence-transformers alone consumes ~500MB at inference time. Add spaCy's medium model (~200MB) and WeasyPrint's rendering dependencies, and the total active memory footprint consistently exceeded 1GB — instantly ruling out every free hosting tier (Render, Railway, Fly.io all cap at 512MB). The solution was strategic: move to AWS EC2 and provision swap space as a safety buffer for initial model loading. It was a lesson in the real-world cost of building with proper ML infrastructure.
Skill Validation False Negatives Early versions of the skill validator had a precision problem — semantically vague project descriptions would fail to match against concrete skills, producing false "unvalidated" flags for candidates who genuinely had the experience. Solving this required careful tuning of the cosine similarity threshold (0.6) and layering fuzzy matching as a fallback, alongside combining both the projects and experience sections as validation corpus.
ATS Simulation Accuracy Real ATS systems are black boxes. Building a scoring rubric that genuinely reflects their filtering logic — rather than just counting keywords — required research into how enterprise tools like Taleo, Greenhouse, and Workday actually parse documents. Privacy detection (street addresses, zip codes) emerged from this research as an often-overlooked factor in ATS rejection rates.
PDF Parsing Inconsistency Multi-column resumes, tables, and custom fonts in PDFs are notoriously difficult to extract cleanly. I ended up chaining three parsers (pdfplumber → PyPDF2 → fallback) with a validation layer that checks extracted content for coherence before passing it downstream.
Accomplishments that we're proud of
🎯 End-to-end semantic matching that goes far beyond keyword stuffing — using real transformer embeddings to measure contextual alignment between resumes and job descriptions. 🔍 Skill validation engine — a genuinely novel feature that cross-references skills against project evidence, catching the credibility gap that human recruiters instinctively catch but ATS tools have never tried to address. 🔒 Privacy risk detection using a three-method approach: spaCy NER, regex for street addresses, and regex for zip codes — flagging real candidates to real risks of over-sharing personal location data. 📄 Dynamic PDF report generation that produces publication-grade, styled analytical feedback documents — not just a score printout, but a comprehensive guide a job seeker can act on immediately. ☁️ Production deployment at $0 — achieving enterprise-grade availability on AWS Free Tier through intelligent use of swap space and systemd daemon management, proving that proper ML systems don't have to cost money to run reliably.
What we learned
Semantic similarity is not optional keyword matching alone produces so many false positives and negatives that it's nearly useless for real resume evaluation. The cosine similarity formulation over transformer embeddings is what makes HireMind's matching feel intelligent rather than mechanical. Infrastructure is a first-class concern in ML-adjacent projects. Ignoring RAM budgets and deployment constraints until the end leads to last-minute architectural pivots. We learned to model memory costs alongside feature costs from the beginning. Feedback quality matters as much as score accuracy early user testing revealed that a high score with vague feedback was less useful than a moderate score with precise, numbered, actionable steps. This shifted significant development effort into the recommendation and feedback engine. LLM integration amplifies, it doesn't replace Groq's LLM layer works best when structured prompts are grounded in real extracted data (skills, keywords, experience entries) rather than asking the model to freeform evaluate a raw resume. The hybrid approach (ML extraction → LLM synthesis) produces dramatically better output.
What's next for HireMind
The current version is a strong analytical foundation. The next phase turns it into an active career co-pilot:
🎯 Fine-tuned BERT model — the ml_model/finetuned-bert directory already houses early work on a domain-specific fine-tune of BERT trained on resume-JD pairs, which will replace all-MiniLM-L6-v2 for significantly higher domain accuracy. 📊 Industry benchmarking — compare your resume scores against aggregated, anonymized percentile distributions by role, industry, and experience level (e.g., "Your keyword score is in the top 30% for ML Engineering roles"). 🔄 Real-time editing mode — a live editor where score updates as you type, with inline suggestions highlighting exactly which sentence or section needs work. 🧩 Browser extension — scan any job posting on LinkedIn, Indeed, or Glassdoor and instantly see your match percentage without leaving the page. 🌍 Multi-language support — extending NLP pipelines to support Spanish, French, German, and Mandarin resume formats for global job markets. 🤝 Recruiter-side dashboard — a complementary interface for hiring managers to batch-analyze applicant pools against a job description, giving both sides of the market the same transparency.
Log in or sign up for Devpost to join the conversation.