ATS Resume Generator: Build ATS-Friendly Resumes That Score Before You Send

TL;DR: ATS Resume Generator is a free, open-source desktop app that builds ATS-friendly resumes and scores them 0–100 before you send them. A heuristic engine checks word count, measurable results, action-verb usage, contact completeness, and weak-word replacements; a role-keyword library covers software engineering, data science, product, marketing, project management, and HR. Export to PDF, DOCX, or TXT. No account, no cloud, no uploads — your resume never leaves your machine. github.com/Shivay00001/ats_resume_generator.

The problem: your resume dies before a human sees it

Most large employers filter applications through Applicant Tracking Systems before any recruiter reads a word. Resumes fail this filter for boring, fixable reasons: no parseable contact block, fancy templates the parser can't read, vague bullets with no numbers, passive language, missing role keywords. Meanwhile the tools that promise to fix this are cloud-based, subscription-priced, and require uploading your personal data to someone else's server.

The ATS Resume Generator takes the opposite approach: a local desktop tool that both builds the resume in an ATS-safe format and scores it with an explainable heuristic engine, giving you specific feedback ("Found only 1 measurable result — aim for 3–5") instead of a mysterious black-box grade.

What it does

• Desktop GUI builder (tkinter): fill in contact info, summary, skills, experience, projects, education, certifications.
• ATS score 0–100 with itemized feedback on every deduction — you always know why points were lost.
• Export to PDF, DOCX, and TXT via fpdf2 and python-docx, using ATS-safe formatting: standard Arial fonts, conventional section order, no text boxes or graphics.
• Role-keyword suggestions for six job families, so your skills section speaks the parser's language.
• Docker support for running it anywhere.

How it works: the scoring engine

The heart of the repo is ats_logic.py and its calculate_ats_score() function. It starts every resume at 100 and deducts points across five checks, returning both the score and a list of human-readable feedback strings:

1. Content length (±20 points)

The engine joins all resume text and counts words. Under 200 words costs 20 points ("Resume is too short. Add more detail to Experience and Projects."); over 1,200 words costs 10 ("might be too long — over 2 pages, condense bullet points"). The 200–1,200 band maps to the conventional one-to-two-page resume.

2. Measurable results (−15 points)

This is the check most resumes fail. A MEASURABLE_REGEX list in constants.py hunts for quantified achievements: percentages (\d+%), dollar amounts (\$\d+), magnitudes (\d+\s*k, \d+\s*M), and phrases like "increased…by", "reduced…by", "saved", "improved", "grew". Fewer than 3 matches costs 15 points, with feedback naming the exact count found and examples of what counts ("Increased sales by 20%", "Saved $10k").

3. Action verbs (−10 points)

constants.py ships a ~60-verb library organized into five categories — Management/Leadership ("Spearheaded", "Orchestrated"), Technical ("Architected", "Refactored", "Automated"), Analysis ("Quantified", "Modeled", "Forecasted"), Communication ("Negotiated", "Authored"), and Achievement ("Exceeded", "Streamlined", "Generated"). Fewer than 5 distinct verbs in the resume costs 10 points.

4. Contact completeness (−25 points)

Missing email or phone: −20 ("Missing critical contact information"). Missing LinkedIn: −5 ("recommended for better visibility"). Brutal, but correct — a resume the parser can't contact anyone through is worthless.

5. Weak-word replacements (−2 each)

A WEAK_WORDS dictionary maps flabby phrasing to strong replacements: "responsible for" → "Spearheaded", "helped" → "Facilitated", "worked on" → "Implemented", "tried" → "Attempted", "good at" → "Skilled in", "hard worker" → "Dedicated", "team player" → "Collaborative". Each hit costs 2 points, and the feedback lists the specific swaps.

Role keywords and text hygiene

get_role_keywords() matches your target role against six keyword sets — software engineer (Python, System Architecture, Microservices, CI/CD…), data scientist (TensorFlow, PyTorch, A/B Testing…), product manager, marketing manager, project manager, and HR — for auto-suggestion. And refine_text_with_ats_rules() strips non-ASCII characters (emojis are a classic parser-killer), standardizes quotes, and capitalizes sentence starts.

Code tour

The formatting constants are deliberately conservative — Arial body text, a fixed seven-section order (Contact → Summary → Skills → Experience → Projects → Education → Certifications), and inch-based margins. That conservatism is the ATS strategy: parsers handle boring layouts perfectly and choke on creative ones.

How to run it

Prerequisites: Python 3.10+ with tkinter (standard on most Linux distributions and macOS; on Debian/Ubuntu you may need python3-tk).

git clone https://github.com/Shivay00001/ats_resume_generator.git
cd ats_resume_generator
pip install python-docx fpdf2
python main.py

To verify the engine without the GUI:

python test_core.py   # scores a sample resume, generates test_resume.docx + test_resume.pdf

The repo ships its own sample outputs (test_resume.docx, test_resume.pdf) so you can inspect the formatting before building your own.

Honest status and roadmap

Status: working. The README records a verified boot on Python 3.12 under Linux (2026-09-24) with the window initializing cleanly, and the test script exercises both scoring and document generation end to end. This is a real, usable desktop tool — not a mockup.

The honest caveat, which the code itself implies: the score is a heuristic proxy, not a real ATS verdict. No parser from Workday, Greenhouse, or Lever actually runs your resume here; different vendors weight things differently. What the engine gives you is directionally-correct, explainable feedback on the factors that every major ATS cares about — which is far more useful than a fake-precise "92% match" from a black box.

Roadmap (sensible next steps):

• Import existing resumes (PDF/DOCX parsing) and score them — meet users where they are.
• Job-description matching: paste a JD, get keyword-gap analysis against the posting.
• LLM-assisted bullet rewriting (local model, keeping the no-cloud promise).
• More layout templates, all parser-safe.
• PyInstaller binaries so non-technical users can double-click to run.

Who should look at this repo

• Job seekers who want a free, private, no-account way to build and check a resume.
• Python developers interested in a clean tkinter + python-docx + fpdf2 document-generation example with a real test script.
• Career coaches who need an explainable scoring rubric they can walk clients through line by line.

A worked example: scoring a sample resume

The repo's own test_core.py doubles as documentation. It scores a sample resume for "John Doe" — email and phone present, one experience entry reading "Developed a new feature using Python. Increased efficiency by 20%." — and prints the score plus every feedback line. Walking through the engine's math on this input shows how the checks compose:

• Length: well under 200 words → −20, with the "too short" feedback.
• Measurable results: "20%" matches \d+% → 1 measurable result found, below the 3–5 target → −15.
• Action verbs: "Developed" matches the verb library → 1 verb, below 5 → −10.
• Contact: email + phone present → no deduction; LinkedIn absent → −5.
• Weak words: "track record of success" contains no weak-word hits → no deduction.

Final: 100 − 20 − 15 − 10 − 5 = 50, with five specific, actionable feedback lines. The test then generates both test_resume.docx and test_resume.pdf from a second sample profile and asserts the files exist — so the whole pipeline, score to document, is verified in one script run.

The GUI experience

main.py builds the whole interface with tkinter — no web dependencies, no Electron, just the standard library. The form walks you through each resume section in the canonical order defined in constants.py, with the ATS score recalculated as you type. Because the scoring functions are pure (data in, score + feedback out), the GUI stays thin: it collects dictionaries and hands them to ats_logic and generator. That separation is what makes the engine testable without a display server — and what would let a future web frontend reuse the exact same scoring code.

One more practical note: because the score is deterministic — same input, same score, every time — you can use it as a regression test for your resume. Edit a bullet, re-run the scorer, and watch the number move. That tight feedback loop is what turns resume writing from guesswork into iteration, and it's the single best reason to keep a local tool like this open while you apply.

Frequently asked questions

The bottom line

The ATS Resume Generator won't get you the job — but it will stop your resume from dying for stupid, fixable reasons before a human ever sees it. The scoring engine's real virtue is explainability: every deduction comes with the specific sentence you need to fix. For a free, local, open-source tool, that's a genuinely useful thing to have open next to your job applications.