What Recruiters See in the First 10 Seconds of Your Resume

TL;DR

Recruiters scan in a predictable pattern. Most attention goes to the top third of the page.
Your name and contact info, your most recent title or project, and your tech stack get seen first.
A broken link, missing contact info, or vague header kills the scan in seconds.
The goal isn't a beautiful resume. It's a scannable one that answers three questions fast.
Most 3-second rejects are caused by the same handful of problems, all fixable.

Recruiters are not reading your resume. Not at first.

They are scanning it. There is a difference, and if you're writing your resume to be read rather than scanned, you're losing the first round of evaluation before you know you're in it.

Understanding exactly what a recruiter's eyes land on in those first 10 seconds is more useful than any advice about formatting or keyword optimization. It tells you what actually needs to be right.

The Anatomy of a Resume Scan

Eye-tracking research on resume reading (done by hiring software companies and career researchers over the years) consistently shows the same pattern: recruiters' eyes start at the top left, move right across the header, drop down the left margin, and then start picking out notable words in the body.

For a software engineering resume, the sequence looks roughly like this:

Your name
Your contact information (email, LinkedIn, GitHub)
The first line under your name (a headline, a summary, or your most recent job title)
The title of your most recent position or top project
The company name or project tech stack
The skills section (usually at a glance, looking for known tech)
Education (specifically: school name, degree, graduation year)

That entire sequence takes under 10 seconds. If something at any step breaks the scan or raises a question, the recruiter's attention either pauses to figure it out (which costs you goodwill) or stops entirely.

What Gets Checked in Each Zone

Your name and contact info

This sounds too obvious to mention, but it's where a surprising number of resumes cause friction.

Recruiters need to know who you are and how to reach you. If your email address is something like [email protected], that's a small red flag that signals you haven't thought about how you're presenting yourself professionally. Use a simple version of your name at Gmail.

Your phone number should be there. Many candidates leave it off because "they'll just email me." Recruiters often want to call for an initial screen.

Your LinkedIn and GitHub should be live links. This is non-negotiable for software roles. If a recruiter sees a LinkedIn URL that's a string of random numbers instead of your name, or a GitHub link that goes to a profile with no activity, that's a note against you.

One thing many candidates get wrong: the location field. You don't need a full address. City and state (or "Open to remote") is enough. But leaving location off entirely creates uncertainty, especially for companies that care about timezone.

The headline or summary line

Right below your name, most resumes have either a title, a summary statement, or nothing.

The title-style headline (like "Software Engineer | React, Node.js, PostgreSQL") works well. It tells the recruiter immediately what kind of engineer you are and what you work with. They can file you mentally before they read a single bullet point.

A summary paragraph at the top is riskier. Most of them are generic ("Motivated developer with a passion for building user-friendly applications...") and take up space without giving the recruiter anything concrete. If your summary doesn't say something specific about your technical focus or a real thing you've built, cut it and replace it with the title-style headline.

Nothing at the top is a missed opportunity. You're making the recruiter do work to figure out what category of candidate you are.

Your most recent job title or top project

For candidates with internship or full-time experience, this is the job title at the most recent company. For new grads and bootcamp graduates with no professional experience, it's the first project in your projects section.

Either way, this is where the recruiter is making their first real judgment call: is this person's background in the right ballpark for this role?

A title that matches what they're hiring for (even approximately) keeps them reading. A title that seems off, or a project entry that's vague ("Personal Project") without context, creates doubt.

The skills section

Most technical recruiters are not engineers. They are pattern-matching against a list of required technologies from the job description.

They will look at your skills section and check for the presence of specific tools. React. Python. AWS. Whatever is on the job description. If they don't see the overlap, they may stop right there.

This is why skills sections matter more than most candidates think. The content matters, but so does the format. A long unorganized dump of every technology you've ever touched is harder to scan than a short organized list grouped by category (Languages, Frameworks, Tools, etc.).

Education

For entry-level roles, school name and graduation year are the two things a recruiter registers. Degree type (CS, software engineering, a related field vs. an unrelated field) gets noted quickly. GPA is usually skipped unless it's prominently displayed.

If you're from a well-known program, the school name alone helps you. If you're from a bootcamp, the program name will register, but the recruiter's interest will immediately shift to your projects and skills sections to decide if you can actually code.

What Causes a 3-Second Reject

Most fast rejects aren't caused by weak skills. They're caused by presentation problems that trigger quick pattern-matching.

The resume looks like a wall of text. Dense paragraphs instead of bullets, too many words per bullet, inconsistent spacing. Anything that signals "this will take effort to parse" gets set aside.

The header information is incomplete or broken. Missing email, a LinkedIn URL that doesn't link anywhere, a phone number in a weird format. These create friction immediately.

The most recent experience or project title is vague. "Various freelance projects" or "Personal development work" tells the recruiter nothing. If they can't tell what you do from your top entry, they're likely to move on.

The formatting is inconsistent. Different fonts, bullet sizes that vary, dates that don't align. This doesn't mean recruiters are design snobs. It means inconsistency signals a lack of attention to detail, which is a real job-relevant quality for software engineers.

The skills section has no recognizable names for the role. A Java position screener who sees zero Java or JVM languages in your skills section will often stop there.

The resume is two or more pages. For candidates with under five years of experience, this immediately marks you as someone who doesn't know what to cut. A one-page resume isn't a stylistic choice, it's a judgment call that signals you understand what matters.

What Earns a Full Read

A resume that survives the initial scan and gets read all the way through usually has a few things in common.

It answers the three implicit questions within the first third of the page: What kind of engineer are you? What have you actually built? Can I reach you?

The most recent or most prominent entry is specific. A job title that matches the role, or a project with a clear name and a line about what it does and what it's built with.

The formatting is quiet. Nothing calls attention to itself in a distracting way. The structure is consistent enough that the recruiter's eye can move through it without recalibrating.

The skills section has obvious overlap with what the job requires.

This isn't about making your resume impressive. It's about making it easy to process quickly. Recruiters are not your adversaries. They are people under time pressure who want to find someone good and move them forward. Remove the friction between them and that outcome.

The 10-Second Audit

Before you submit your next application, do this with your resume:

Print it out or open it in a new window where you haven't been staring at it. Set a timer for 10 seconds. Look at the page, then look away.

Ask yourself: What did I notice first? What question does my resume raise that it doesn't immediately answer? Is the most important information in the top half?

Then ask a friend to do the same thing. Ask them what they saw, not what they think of the content.

What gets noticed in 10 seconds is your resume's actual first impression, not the carefully crafted bullets you spent an hour writing.

Once you understand how the scan works, the next step is making the content hold up when someone actually reads. How you write each bullet point is where most resumes lose people who were initially interested. The goal is showing impact, not just listing what you worked on.

If you have projects instead of job experience, how you present them in the projects section follows similar principles: clear titles, specific tech, concrete outcomes.

For a full view of how every section fits together, the software engineering resume guide covers the structure from top to bottom.

If you want structured support getting your resume to the point where it clears the 10-second test, here's how the Globally Scoped program works.