What ATS Resume Parsers Actually Look For

Most resume advice on the internet is either wrong, outdated, or aimed at applicant tracking systems that barely exist anymore. Here's what modern ATS parsers actually do with your resume — and how to write one that makes it through without any tricks.

What an ATS actually is

ATS stands for Applicant Tracking System — the software recruiters use to manage job applications. The major ones you'll encounter in tech:

• Greenhouse — used by most startups, many Fortune 500 tech companies (Stripe, Airbnb, Reddit, OpenAI, Anthropic, most crypto protocols)
• Workday — used by most enterprise companies (Salesforce, Adobe, Netflix, NVIDIA, Visa, PayPal)
• Lever — mid-size and startup favorite (Compound, Wintermute, Decentraland)
• Ashby — newer, gaining share fast (Ethereum Foundation, Lido, Uniswap, Sky Mavis)
• iCIMS, Taleo, SmartRecruiters, Jobvite — various enterprise deployments

Despite what ads for "ATS optimization tools" claim, these systems have evolved a lot. The primitive keyword-counting ATS of 2015 barely exists anymore. Modern systems do real NLP — they understand that "React" and "React.js" are the same thing, that "Senior Software Engineer" and "Sr. SWE" are the same role, and that years of experience can be inferred from date ranges.

What happens when you hit "apply"

Walking through the technical flow:

1. PDF or document extraction. Your file gets parsed into plain text. This is where most broken resumes break — two-column layouts, text inside images, or unusual fonts can scramble the extraction.
2. Section detection. The parser tries to identify standard sections: Contact, Summary, Experience, Education, Skills. It uses common headings as anchors.
3. Entity extraction. Companies, job titles, dates, skills, schools, and credentials get pulled out as structured data. This is where NLP does the heavy lifting.
4. Scoring / ranking. Your extracted profile is compared against the job requirements. Match scoring combines keyword overlap, years of experience, and (increasingly) embedding-based semantic similarity.
5. Recruiter review. Most ATS systems show the recruiter a ranked list. The top 10-20 get human eyes. The rest might or might not, depending on volume.

Format: what parses well, what doesn't

Works reliably

• Single-column layouts, left-aligned
• Standard section headings (Experience, Education, Skills) — even if you get creative elsewhere
• Common fonts (Helvetica, Arial, Georgia, Calibri, Times)
• Plain bullet points (• or hyphens)
• Dates in month-year format (Jan 2023 – Mar 2026)
• Text-selectable PDFs

Breaks parsers frequently

• Two-column layouts (50%+ of Canva templates have this problem)
• Text inside images, icons, or decorative graphics
• Headers/footers with key info (some parsers skip them entirely)
• Text boxes (especially nested ones)
• Tables for layout (as opposed to actual tabular data)
• Exotic fonts that don't embed cleanly
• Scanned PDFs (image-only, no selectable text)

The acid test

Open your resume PDF and try to select all the text, then paste it into a plain text editor. Is everything there? Is it in the right order? If yes, your resume will parse fine almost anywhere. If no — especially if the order is scrambled — the ATS will see the same scrambled mess.

Content: what the parsers actually read

Skills section

Most parsers pull heavily from a dedicated skills section. Keep it clean: 10-20 truly relevant skills, not everything you've ever touched. Group them logically (Languages, Frameworks, Tools, Cloud). Don't list soft skills here — "communication" and "teamwork" don't match against job requirements.

Job titles

Every role needs a recognizable title. If your official title is internal jargon ("Technical Director of Experiences"), include a parenthetical: "Technical Director of Experiences (Senior Product Engineer)". Parsers match titles heavily.

Company names

Spell out the full name. "Senior Eng at G" won't match "Senior Engineer at Google" well, but it will match "Senior Engineer at Gumroad" and various other G-starting companies.

Dates

Always include start and end dates in a consistent format. "Current" or "Present" as an end date is fine. Roles without dates frequently get dropped or mis-ordered by parsers.

Bullet points

Each bullet should mention specific nouns — technologies, tools, metrics, methodologies. "Led team to ship features" = zero signal. "Led 4-engineer team shipping billing infrastructure using Stripe, TypeScript, and PostgreSQL" = five signals.

Years of experience

Modern parsers compute your years of experience per skill by looking at which roles mention that skill and how long those roles ran. So if you want "Python, 5 years" to parse correctly, "Python" should appear in the bullets of roles that total 5 years. Burying it only in a skills section can lead to "Python, 0 years" on the parser side.

The keyword optimization question

People ask whether they should "keyword optimize" their resume for each job. The honest answer: tailoring is worth it, keyword-stuffing is not.

Worth doing: Before applying, scan the job posting for technologies and responsibilities you've actually done but didn't emphasize on your resume. If the role stresses Kafka and you used Kafka at a previous job, make sure Kafka is in your bullets for that role. This is just honest reframing.

Not worth doing: Adding skills you don't have, repeating the same keyword 12 times, using hidden white text, or copy-pasting the job description into your resume in size-1 font. These either don't work (modern parsers de-weight repeated keywords) or get caught and hurt you.

A tested resume structure

Here's a structure that parses well across every major ATS. Nothing fancy — but fancy doesn't help here.

[Your Name]
your@email.com · City, State · linkedin.com/in/you · github.com/you

Summary
Senior backend engineer, 8 years, specialized in high-throughput payment systems. Built and operated services handling $1B+ annual volume at two companies.

Experience
Senior Software Engineer · Stripe · Mar 2023 – Present
• Built and operated payment routing service handling 100K+ TPS using Go, PostgreSQL, and Kafka
• Reduced p99 latency by 40% through read replica sharding and query optimization
• Led migration from monolithic payments service to 6 microservices, coordinating 4 teams

Software Engineer · Square · Jun 2020 – Feb 2023
• Designed fraud detection pipeline processing 50M+ transactions daily (Python, Spark, ML)
• [...]

Skills
Languages: Go, Python, TypeScript, SQL
Infrastructure: AWS (EC2, RDS, Lambda), Kafka, Redis, PostgreSQL, Docker, Kubernetes
Practices: Distributed systems, microservices, CI/CD, on-call operations

Education
B.S. Computer Science · University of Washington · 2020

This parses cleanly in Greenhouse, Workday, Lever, Ashby, and every other major system we've tested. It's not pretty, but pretty resumes that don't parse are worse than plain resumes that do.

What to check before sending

1. PDF is text-selectable. Try to copy-paste — you should get clean text in the right order.
2. Contact info is visible. Keep it in the body, not a header/footer.
3. Dates on every role. Month/year format.
4. Titles are recognizable. Jargon titles get parenthetical translations.
5. Skills section exists and is accurate. 10-20 items, grouped.
6. Each role has 3-5 bullets with specific nouns. No vague "ownership of stuff."
7. Consistent formatting. Same font, same bullet style, same date format throughout.

That's it. Most ATS optimization advice is trying to outsmart a system that's smarter than it used to be. What actually works in 2026 is writing a clean, specific resume that would also work for a human reader — then making sure it parses.