Six layers. Nine axes. Every point you see has its receipts.
Jobscan, Teal and Rezi each rely on a single shallow keyword match or a one-pass AI score. JobFitAI runs your resume through six independent layers — a file inspector, a nine-vendor ATS parser simulator, a deterministic evidence pipeline, semantic matching, four specialist analysis passes in parallel, and a synthesis step that must cite every evidence source it uses. If it can't cite, it can't score. Every axis includes an AI-generated rationale so you know exactly why you landed where you did.
Six layers, one score
Byte-level file inspection to multi-agent reasoning — all of it in a single orchestrated run.
Each layer runs in parallel (Promise.allSettled). If one fails — say semantic matching is temporarily unavailable — the rest still ship, and the synthesis step sees which layers succeeded so it can weight them accordingly.
File inspection
Byte-level PDF + DOCX
- Scanned-image vs digital PDF detection (no more silent 0% parses).
- Multi-column detection, table + image counts, header/footer text.
- White-on-white and tiny-font text recovery — catches keyword stuffing.
- Hyperlink extraction so JD 'portfolio URL required' checks actually work.
- Uses pdfjs-dist + mammoth; never ships your file off your account.
ATS parser simulator
9 vendors · per-field fidelity
- Emulates how Workday, Greenhouse, Lever, Taleo, iCIMS, SmartRecruiters, Ashby, SAP SuccessFactors, BambooHR will actually parse your resume.
- Per-field extraction table: 'Workday: Company = Acme, Role = (missing — 2-column layout).'
- Cross-vendor heatmap with a parse-fidelity % per vendor — click any tile for the full field breakdown.
- Synthesis v6 ATS checks are evidence-bound: every check must map to a VENDOR_SIM warning or FILE_REPORT signal — no invented checks.
Deterministic evidence
~80 ms, always on
- 445+ canonical skills + aliases, implication graph (React → ReactJS, PyTorch → Deep Learning).
- Per-stack YoE: 'JD wants 4y React, your resume supports 2y React.'
- Bullet analysis: STAR completeness, quantification ratio, weak phrasing, passive voice.
- Tenure + employment gap + job-hopping detection.
- Certifications ontology (AWS tiers, Azure, GCP, PMP, CPA, CFA, CISSP, Six Sigma, ITIL, SHRM) with tier-gap math.
- Keyword stuffing + date-format consistency checks.
Semantic matching
Meaning-based matching, cached
- Bullet × requirement similarity matrix — matches meaning, not exact words.
- Title similarity (your last role vs the JD title).
- Industry classification via nearest-centroid over 20+ curated archetypes.
- Worst-covered JD requirements are surfaced directly in the fix list.
- Results cached per text hash in Postgres so the second run is instant.
Four specialist analysis passes
Parallel AI analysis
- ATS Parse Reviewer — judges fidelity of the vendor simulations + file report.
- Content Fit Reasoner — scores skill, metric, and action-verb fit vs the JD.
- Seniority + Domain Judge — matches titles, tenure, and industry signal to the JD seniority.
- Red-Flag Hunter — surfaces integrity + stuffing + date-consistency issues.
- Each specialist emits Zod-validated JSON citing evidence IDs from layers 1–4.
Synthesis pass
Evidence-grounded, self-checked, per-axis rationale
- Receives the full Evidence Packet — not the raw resume text.
- Must reconcile the four specialists with deterministic evidence before emitting a number.
- Evidence-bound ATS checks: every check must map to a VENDOR_SIM or FILE_REPORT signal.
- Per-axis rationale: one-clause evidence citation for every axis — 'Strong React + TypeScript but Kubernetes missing.'
- Unified 9-axis weight formula: prompt self-check and client min-cap use the same formula so the displayed overall is always correct.
- Retries at temperature 0 + fixed seed if schema validation fails, then hard-errors.
- Result persisted with full packet so any score can be replayed or audited.
Nine axes · industry-tuned
Every axis has a source. Every source has an evidence ID.
Each axis is scored, weighted, and constrained by evidence-derived hard caps (e.g. missing a must-have skill caps the overall at 87). Every axis also ships a one-clause AI rationale so you know exactly why it landed where it did. Industry detection adjusts the blend.
Skills & keywords (25%)
JD-weighted taxonomy match with implication graph + synonym expansion. Evidence: matched / missing skill lists + hard cap from must-have gaps.
Experience fit (18%)
Per-stack YoE diff, title similarity, seniority trajectory. Hard cap applied when YoE gap exceeds JD requirement.
Quantified metrics (10%)
% of bullets with numbers / % / $. Deterministic count is the floor; AI cross-checks the excerpt for spelled-out numbers.
Action verbs (8%)
Strong verb starts, passive-voice flags, weak-phrase count ('responsible for', 'worked on') — all from the deterministic bullet analysis layer.
ATS format (12%)
Fidelity across nine ATS vendor simulations (Workday, Greenhouse, Lever, Taleo, iCIMS, SmartRecruiters, Ashby, SAP SuccessFactors, BambooHR) + file inspector signals. Evidence-bound — every check maps to a real signal.
Seniority (7%)
Title/level match vs JD seniority expectation. Exact match → 90+, three levels off → 30-55.
Domain / industry (5%)
Industry/domain background vs JD context. Meaning-based centroid + JD keyword overlap.
Semantic coverage (10%)
% of JD requirements with a resume bullet at strong semantic similarity. Anchored to the matching layer; gracefully falls back to taxonomy when semantic matching is unavailable.
Title fit (5%)
Most-recent title vs target role title. Contributes independently — not collapsed into 'experience' so the model can surface title-only mismatches.
What competitors ship
Jobscan ships layer 3. Teal ships layer 6. JobFitAI ships all six.
Per-vendor ATS parse heatmap
Open the analysis dialog and you see a grid: Workday 92%, Greenhouse 88%, Lever 64% (warn), Taleo 71%, iCIMS 58% (fail). Click any tile for the per-field extraction with detected warnings. No other tool shows the simulated fidelity per vendor.
Every score is clickable
Every axis, every check, every number opens an Evidence drawer showing the raw analysis that produced it. 'Why is my bullets score 62?' Click. You see the totals, the weak phrases, the passive-voice count, the STAR completion rate.
Impact ÷ effort fix planner
The fix list isn't just 'add keyword X'. Every action carries an estimated point lift AND an effort tier (≤2 min, 15 min, 60+ min). Sorted by impact/effort ratio so you always see the biggest lever first.
Evidence-cited synthesis with per-axis rationale
Our synthesis pass is not allowed to invent a check — every ATS check must map to a VENDOR_SIM or FILE_REPORT signal. Every axis ships a one-clause rationale ('Strong React + TypeScript but Kubernetes missing'). A unified 9-axis weight formula is shared between the prompt self-check and the client min-cap so the displayed overall is always accurate.
AI lift projection
Every missing must-have skill comes with an AI-projected point delta: 'add Kafka → +4 pts.' Grounded in the exact same Evidence Packet that produced your score — not a generic benchmark. Competitors flag misses; only JobFitAI quantifies the payoff.
AI-parsed everything
Resume structure, JD keywords, industry label, seniority — all extracted by the same cached evidence schema. No brittle regex, no one-size-fits-all weights. Parsing confidence ships with the packet so the synthesis step can temper the score when the source was ambiguous.
Replayable runs
Every score is persisted with its full Evidence Packet so you can see what drove it. Our bench harness (npm run bench:score) gates regressions on per-axis MAE.
The fine print
Why this score is trustable.
- Your resume file is stored in your private Supabase bucket. File inspection runs server-side against your own storage; we never forward your file to a third-party ATS grading service.
- Specialist analysis and synthesis run on our servers with rate limiting and abuse protection. Semantic coverage uses cached meaning-based matching and falls back to taxonomy when needed.
- Saved scores stay tied to the evidence that produced them — when we ship scoring updates, historical runs remain interpretable.
- Our bench harness runs on every pull request with per-axis mean absolute error gating. We ship regressions loudly, not quietly.