The Uncomfortable Truth About ATS and Resume Design

You’ve heard the warnings: Applicant Tracking Systems (ATS) will shred your beautifully designed resume, spitting out a garbled mess of text that dooms your application before a human ever sees it. But you’ve also seen the sleek, modern resumes that land six-figure jobs—resumes that look more like a designer’s portfolio than a sterile Word document. So which is it? Do you optimize for the machine or the human?

The answer is neither. Or rather, both. The real challenge isn’t choosing between ATS compatibility and design—it’s mastering the art of dual optimization. This isn’t about dumbing down your resume or stuffing it with keywords. It’s about understanding how ATS parses information, where it fails, and how to exploit those gaps without sacrificing the visual hierarchy that makes your resume compelling to a hiring manager.

How ATS Actually Works (And Where It Breaks)

Before you can outsmart an ATS, you need to understand its limitations. Most ATS platforms—whether it’s Workday, Greenhouse, or the clunky legacy systems still used by Fortune 500 companies—rely on a few core technologies to parse your resume:

Optical Character Recognition (OCR): This is the same tech that scans a printed document into editable text. If your resume is a PDF (or worse, a JPG), the ATS first runs it through OCR. This is where things go wrong. Fancy fonts, icons, tables, and even some bullet points can turn into gibberish. A single misplaced line or border can cause the OCR to misread your job title as part of your company name, or worse, skip entire sections.
Keyword Matching: The ATS doesn’t “read” your resume like a human. It scans for exact or near-exact matches to keywords from the job description. If the job posting mentions “Python” and “Django,” but your resume only says “backend development with modern frameworks,” the ATS might not make the connection. This is why generic resumes fail—ATS is literal, not intuitive.
Structural Parsing: The ATS tries to map your resume into a standardized format (e.g., “Work Experience,” “Education,” “Skills”). If your resume uses creative section headers like “Where I’ve Made an Impact” instead of “Work Experience,” the ATS might not recognize it as a section at all. Similarly, if your dates are formatted as “Jan 2020 – Present” instead of “01/2020 – Present,” the ATS might misalign your roles.
Contextual Scoring: Some advanced ATS platforms (like Eightfold or HireVue) use AI to assess the context of your experience. They don’t just look for keywords—they try to understand whether you’ve used those skills in a relevant way. For example, if the job requires “project management,” the ATS might score you higher if you mention “led cross-functional teams” than if you just list “project management” in your skills section.

The problem? Most advice about ATS optimization focuses on avoiding the OCR and keyword-matching pitfalls, but ignores the structural and contextual parsing. This leads to resumes that are technically ATS-friendly but fail to impress humans—or worse, fail to get past the ATS because they’re too rigid.

The Three Pillars of ATS-Design Harmony

To create a resume that works for both ATS and humans, you need to balance three competing priorities:

Parsability: The ATS must be able to accurately extract and categorize your information.
Readability: A human must be able to scan your resume in 6 seconds and grasp your value.
Design: Your resume must stand out visually without relying on elements that break ATS parsing.

Here’s how to achieve all three.

Pillar 1: Parsability (Without Looking Like a Template)

File Format: The PDF vs. Word Debate

For years, the advice was to submit your resume as a Word document (.doc or .docx) because ATS could parse it more reliably. This is outdated. Modern ATS platforms handle PDFs just fine—if the PDF is properly formatted. The real issue isn’t the file type; it’s how the text is embedded in the PDF.

When saving your resume as a PDF, use the “Save As” or “Export” function in Word, Google Docs, or a design tool like Canva or Adobe InDesign. Avoid “Print to PDF,” as this can sometimes rasterize the text, making it unreadable to OCR. Test your PDF by selecting text with your cursor—if you can’t highlight individual words, the ATS won’t be able to either.

If you’re using a design tool, ensure the text is not converted to outlines or images. In InDesign, for example, use the “Create Outlines” option sparingly—only for decorative elements, never for body text. In Canva, avoid the “Flatten” option when exporting.

Fonts: The Safe List (And the Ones to Avoid)

ATS struggles with custom fonts, decorative fonts, and even some common ones. Stick to these ATS-safe fonts, which are also clean and professional for human readers:

Arial
Helvetica
Calibri
Times New Roman
Georgia
Garamond
Verdana

Avoid:

Script fonts (e.g., Brush Script, Lobster)
Display fonts (e.g., Impact, Bebas Neue)
Fonts with thin strokes (e.g., Avenir Light, Futura Light)
Custom or Google Fonts (e.g., Montserrat, Roboto—unless you’re embedding them in a PDF, which is risky)

Font size matters, too. Body text should be 10-12pt. Headers can go up to 14-16pt, but avoid anything larger than 18pt—some ATS platforms flag oversized text as “graphics” and ignore it.

Section Headers: The ATS Recognition Hack

ATS looks for standard section headers to parse your resume. If you get creative with your section names, the ATS might not recognize them. For example:

✅ Standard: “Work Experience,” “Education,” “Skills”
❌ Creative: “Where I’ve Thrived,” “My Journey,” “Core Competencies”

But here’s the hack: you can visually differentiate your section headers while keeping the text ATS-friendly. For example:


  WORK EXPERIENCE
   (Where I’ve Made an Impact)

This way, the ATS sees “WORK EXPERIENCE” as the header, but the human sees a more engaging subtitle. You can do the same with icons—place them next to the text, not instead of it. For example:


  🎓 EDUCATION

Dates and Locations: The ATS Alignment Trick

ATS expects dates and locations to follow a specific format and placement. If they’re misaligned or formatted inconsistently, the ATS might associate the wrong dates with the wrong roles. Here’s how to format them for maximum parsability:

Dates: Use the MM/YYYY format (e.g., “01/2020 – 06/2023”). Avoid “Jan 2020 – Jun 2023” or “2020 – 2023,” as some ATS platforms struggle with these.
Locations: Use “City, State” (e.g., “San Francisco, CA”) or “City, Country” for remote roles. Avoid abbreviations like “SF, CA” or “NYC, USA.”
Placement: Place dates and locations on the same line as the job title or company name, aligned to the right. Avoid placing them in a separate column or below the job description, as this can confuse the ATS.

Example of ATS-friendly formatting:


  
    
      Senior Product Manager, Acme Corp
    
    
      San Francisco, CA | 01/2020 – 06/2023

Pillar 2: Readability (Without Sacrificing ATS Parsing)

The 6-Second Rule and Visual Hierarchy

Hiring managers spend an average of 6 seconds scanning a resume before deciding whether to read it in full. Your resume must pass this test while still being ATS-friendly. Here’s how to create a visual hierarchy that guides the reader’s eye without breaking ATS parsing:

Prioritize the Top Third: The first 3-4 inches of your resume (the “above the fold” section) should include your name, title, contact info, and a summary or key skills section. This is where the hiring manager’s eyes land first. Make it count.
Use Bold and Italics Strategically: Bold your job titles, company names, and key achievements. Italicize less critical information, like locations or dates. Avoid underlining—it can interfere with OCR.
Leverage White Space: Dense blocks of text are hard to scan. Use line breaks, bullet points, and margins to create breathing room. Aim for 0.5–1 inch margins and 1.15–1.5 line spacing.
Bullet Points Over Paragraphs: Bullet points are easier to scan than paragraphs. Keep them concise—no more than 2 lines each. Start each bullet with a strong action verb (e.g., “Led,” “Designed,” “Optimized”).
Limit Colors: Stick to 1-2 colors max. Use them sparingly—for section headers, icons, or dividers. Avoid light colors (e.g., yellow, pastels) that may not print well or scan poorly in OCR.

The Summary Section: Your Elevator Pitch

A well-crafted summary section can make or break your resume’s readability. It’s the first thing a hiring manager reads, and it sets the tone for the rest of your resume. But many summaries fail because they’re either too generic or too vague. Here’s how to write one that works for both ATS and humans:

Keep it short: 3-4 lines max. Any longer, and the hiring manager will skip it.
Include keywords: Pull 2-3 key skills or job titles from the job description and weave them into your summary. For example, if the job posting mentions “full-stack development” and “cloud architecture,” your summary might start with: “Full-stack developer with 5+ years of experience designing scalable cloud architectures.”
Highlight your value: Don’t just list your skills—explain how you’ve used them to drive results. For example: “Drove a 30% increase in user engagement by redesigning the onboarding flow for a SaaS platform.”
Avoid first-person pronouns: Write in a telegraphic style (e.g., “Led a team of 5 engineers” instead of “I led a team of 5 engineers”). This saves space and keeps the focus on your achievements.

Example of a strong summary:

Senior UX Designer with 7+ years of experience crafting intuitive digital experiences for enterprise SaaS products. Specialized in user research, wireframing, and prototyping, with a track record of improving usability metrics by 20-40%. Adept at collaborating with cross-functional teams to align design with business goals. Proficient in Figma, Sketch, and Adobe XD.

Achievements Over Responsibilities

Hiring managers don’t care about your responsibilities—they care about what you achieved. Yet most resumes read like job descriptions, listing duties instead of outcomes. Here’s how to reframe your experience to highlight achievements while keeping it ATS-friendly:

Use the STAR method: For each bullet point, structure it as Situation, Task, Action, Result. For example:
- Before: “Managed a team of developers to build a new feature.”
- After: “Led a cross-functional team of 5 developers to design and launch a new payment processing feature, reducing cart abandonment by 15% and increasing revenue by $2M annually.”
Quantify everything: Numbers stand out and make your achievements concrete. Use percentages, dollar amounts, time saved, or other metrics to quantify your impact. For example:
- “Optimized database queries, reducing load times by 40%.”
- “Automated reporting processes, saving 10 hours per week.”
- “Increased customer retention by 25% through targeted email campaigns.”
Tailor to the job description: Mirror the language and priorities of the job posting. If the job description emphasizes “scalability,” highlight projects where you scaled systems or teams. If it mentions “customer satisfaction,” include metrics like NPS scores or retention rates.

Pillar 3: Design (Without Breaking ATS)

Icons, Graphics, and Dividers: The ATS-Safe Approach

Icons and graphics can make your resume stand out, but they can also break ATS parsing. Here’s how to use them safely:

Icons: Use simple, monochrome icons from libraries like Font Awesome or Material Icons. Place them next to text, not instead of text. For example, use a phone icon next to your phone number, but don’t replace the word “Email” with an envelope icon.
Dividers: Use thin horizontal lines (1px) to separate sections. Avoid decorative dividers (e.g., dotted lines, zigzags) or thick lines, as these can confuse OCR.
Graphics: Avoid charts, graphs, or infographics. If you must include them, place them in a separate “Projects” or “Portfolio” section and label them clearly (e.g., “See portfolio for full case study”).

Columns: The ATS Landmine

Columns are a common design choice, but they’re a nightmare for ATS. When an ATS parses a resume with columns, it often reads the text left-to-right, top-to-bottom, mixing up the information. For example:

| Job Title       | Company Name   | Dates          |
|----------------|----------------|----------------|
| Senior Designer| Acme Corp      | 01/2020 – 06/2023 |
| Junior Designer| Beta Inc       | 03/2017 – 12/2019 |

An ATS might read this as: “Senior Designer Acme Corp 01/2020 – 06/2023 Junior Designer Beta Inc 03/2017 – 12/2019,” which is nonsensical.

Instead, use a single-column layout. If you want to create a visual separation between sections, use white space, dividers, or subtle background colors (e.g., a light gray bar behind your skills section).

Background Colors and Images: Proceed with Caution

Background colors and images can make your resume pop, but they can also interfere with OCR. Here’s how to use them safely:

Background colors: Use light, neutral colors (e.g., light gray, soft blue) for section backgrounds. Avoid dark colors or gradients, as these can make text hard to read and may not print well.
Background images: Avoid them entirely. If you must use one, ensure it’s very light (e.g., a subtle watermark) and doesn’t interfere with text readability.
Text over images: Never place text over an image or colored background. OCR struggles with this, and it’s hard to read. If you want to overlay text, use a solid color block behind the text to ensure contrast.

Templates: The Good, the Bad, and the Ugly

Not all resume templates are created equal. Some are ATS-friendly; others are disasters waiting to happen. Here’s how to evaluate a template:

Good: Single-column layout, standard section headers, minimal graphics, and clean typography. Examples include the “Modern” or “Classic” templates in Microsoft Word or Google Docs.
Bad: Multi-column layouts, creative section headers, excessive icons or graphics, or templates that rely on text boxes (which ATS often ignores).
Ugly: Templates with background images, decorative fonts, or complex layouts (e.g., circular or infographic-style resumes). These are guaranteed to fail ATS parsing.

If you’re using a template from a site like Canva or Etsy, test it with an ATS scanner (more on this later) before applying. Better yet, start with a blank document and build your resume from scratch, using the principles outlined here.

Testing Your Resume: The ATS Litmus Test

You’ve formatted your resume for ATS and design. Now it’s time to test it. Here’s how to ensure your resume will pass muster:

1. The Manual Test

Open your resume in a text editor (e.g., Notepad or TextEdit). Copy and paste the entire resume into the editor. If the text is garbled, misaligned, or missing, your resume will fail ATS parsing. Fix any issues and retest.

2. The OCR Test

Print your resume (or save it as a JPG) and run it through a free OCR tool like OnlineOCR or NewOCR. Compare the extracted text to your original resume. If the OCR misreads any information (e.g., “Senior Designer” becomes “Senior Des1gner”), go back and simplify the formatting.

3. The ATS Scanner Test

Use a free ATS scanner like Jobscan or ResumeWorded to test your resume against a job description. These tools will flag parsing errors, keyword gaps, and other issues. Pay attention to:

Parsing errors: If the scanner can’t extract your job titles, dates, or skills, the ATS won’t either.
Keyword matches: Aim for at least 80% keyword match with the job description. If you’re below this threshold, tweak your resume to include more of the job posting’s language.
Readability score: Some scanners (like ResumeWorded) give your resume a readability score. Aim for 80% or higher.

4. The Human Test

Ask a friend or colleague to review your resume. Give them 6 seconds to scan it, then ask:

What’s my current job title?
What’s my most impressive achievement?
What skills do I have?

If they can’t answer these questions quickly, your resume lacks visual hierarchy. Go back and adjust the formatting to make key information stand out.

The Final Checklist: ATS + Design Perfection

Before you hit “submit,” run through this checklist to ensure your resume is optimized for both ATS and human readers:

File Format: Saved as a PDF (not a JPG or PNG) with selectable text.
Fonts: ATS-safe fonts (Arial, Helvetica, Calibri, etc.) at 10-12pt for body text, 14-16pt for headers.
Section Headers: Standard headers (e.g., “Work Experience,” “Education”) with optional subtitles or icons.
Dates and Locations: Formatted as MM/YYYY and “City, State,” aligned to the right.
Layout: Single-column, no text boxes, no columns, no tables.
Icons and Graphics: Simple, monochrome icons placed next to text, not replacing it. No charts or infographics.
Colors: 1-2 colors max, used sparingly for headers or dividers. No dark backgrounds or light text.
Bullet Points: Concise (1-2 lines), achievement-focused, and quantified where possible.
Keywords: Mirrored from the job description, woven naturally into your summary and experience.
Summary: 3-4 lines, tailored to the job, with 2-3 key skills or job titles.
Testing: Passed the manual text test, OCR test, ATS scanner test, and human test.

Beyond the Resume: The ATS Ecosystem

Your resume isn’t the only thing an ATS evaluates. Many systems also parse your LinkedIn profile, cover letter, and even your online portfolio. Here’s how to ensure these elements work in harmony with your resume:

LinkedIn: The ATS-Friendly Profile

Many ATS platforms pull data from your LinkedIn profile to fill in gaps in your resume. To ensure consistency:

Job Titles and Dates: Match your LinkedIn profile exactly to your resume. Even small discrepancies (e.g., “Senior Software Engineer” vs. “Sr. Software Engineer”) can cause issues.
Skills Section: List the same skills on LinkedIn as you do on your resume. Use the exact wording (e.g., “Project Management” vs. “PM”).
About Section: Treat this like your resume summary. Include keywords from the job description and highlight your value proposition.
Experience Section: Use bullet points (not paragraphs) and quantify achievements where possible. LinkedIn’s “Featured” section is a great place to link to portfolio pieces or projects.

The Cover Letter: ATS’s Silent Partner

Some ATS platforms parse cover letters for keywords and context. To optimize yours:

Mirror the Job Description: Use the same keywords and phrases from the job posting, but weave them into a narrative. For example, if the job posting mentions “agile methodologies,” your cover letter might say: “In my current role, I’ve led agile teams to deliver projects 20% faster than industry benchmarks.”
Keep It Structured: Use clear paragraphs with headings (e.g., “Why I’m Excited About This Role,” “How My Experience Aligns”). Avoid creative formatting (e.g., columns, images).
Save as a PDF: Just like your resume, save your cover letter as a PDF with selectable text. Name it clearly (e.g., “John_Doe_Cover_Letter.pdf”).

Portfolio and Projects: The ATS Workaround

ATS can’t parse your portfolio or GitHub repos, but you can still use them to your advantage. Here’s how:

Link Strategically: Include a link to your portfolio or GitHub in your resume’s contact section. Use a URL shortener (e.g., bit.ly) if the link is long, but avoid generic shorteners like “tinyurl.com.”
Describe Projects on Your Resume: Don’t just link to your portfolio—describe 1-2 key projects in your resume’s “Projects” or “Work Experience” section. Include metrics and outcomes (e.g., “Built a React-based dashboard used by 10K+ users, reducing support tickets by 30%”).
Use Keywords: If the job posting mentions specific tools or technologies (e.g., “React,” “AWS”), include them in your project descriptions.

The Bottom Line: Dual Optimization Is Non-Negotiable

The days of choosing between a “pretty” resume and an “ATS-friendly” one are over. Today’s job market demands a resume that excels at both. By understanding how ATS parses information—and where it fails—you can design a resume that passes the machine’s test while still wowing the human on the other side.

Remember: ATS is a gatekeeper, not the final decision-maker. Your goal isn’t to trick the system—it’s to ensure your resume makes it into the hands of a hiring manager in a form that’s both accurate and compelling. When you master the art of dual optimization, you don’t just get past the ATS—you set yourself up to land the interview.