Resume & LinkedIn That Get Callbacks

"A resume doesn't get you the job. It gets you the interview. Confuse the two and you'll write the wrong document." — a recruiter who has screened more resumes than she can count

You can pass the coding screen, design a system on a whiteboard, and tell a STAR story that lands. None of it matters if your resume never gets read. Before any of the skills in this volume come into play, a different, quieter gate has to open first: someone — or something — has to look at a page of text and decide you're worth a phone call.

That decision is faster and more mechanical than most engineers imagine. A recruiter spends around six seconds on a first pass. Before that, an applicant tracking system (ATS) may have already parsed, scored, and filtered your resume against the job description without a human ever seeing it. Two gatekeepers, both skimming, both looking for reasons to move on to the next candidate in a stack of three hundred.

This chapter is about getting through both. Not with tricks or keyword stuffing, but with the same discipline you've already practiced in the STAR Results step: showing specific, quantified impact instead of vague responsibility. By the end you'll be able to write a resume bullet that survives the six-second scan and the parser, tune it to a job without lying, build a LinkedIn profile recruiters actually find, and get the referral that beats a cold application every time.

The two gatekeepers you're actually writing for

Most resume advice fails because it imagines an attentive reader studying your career. There is no such reader. There are two skimmers.

The ATS is software that ingests your resume, extracts text into fields (name, title, dates, skills), and matches it against the requisition. If it can't parse your file, or it can't find the terms the role calls for, you can be filtered before a human looks. It is not artificial intelligence sitting in judgment — it's a database that's bad at reading creative layouts.

The recruiter picks up where the ATS leaves off and gives your resume a six-second triage: current title and company, most recent role, a scan for the skills in the job description, and one question — is this person plausibly a fit? They are not reading; they are pattern-matching for a reason to say yes or no.

Write for both at once and you don't need tricks. A clean, keyword-honest, impact-driven resume satisfies the machine and the human, because they're looking for the same thing from different angles: evidence, quickly.

The resume: format that survives, content that convinces

The one-page rule (for most of you)

If you have under ten years of experience, your resume is one page. Full stop. The one-page rule isn't about brevity for its own sake — it's a forcing function that makes you cut everything that isn't your strongest evidence. A two-page resume from a mid-level engineer signals that you can't distinguish signal from noise, which is precisely the judgment the role is testing. The exception: genuinely senior engineers, staff-and-above, or people with long research/publication records may earn a second page. Early-career and mid-career: one page, ruthlessly.

Reverse-chronological, always

Recruiters and every ATS expect reverse-chronological order: most recent role first, working backward. "Functional" or "skills-based" resumes that hide your timeline are a red flag — they read as an attempt to conceal gaps or job-hopping, and many parsers mangle them. Standard sections, standard headings: Experience, Skills, Education, Projects. Don't get clever with the labels; the ATS is looking for the words it knows.

The bullet formula

This is the heart of the whole document. A resume bullet is not a job description — it's a result. The same instinct you use in the STAR method's Results step applies here: don't tell me what you were responsible for, tell me what changed because you were there.

The metric is what separates a resume that gets callbacks from one that gets skimmed and dropped. "Improved performance" is a claim; "cut p95 latency from 800ms to 120ms" is evidence. Not everything is measurable, and you must never invent a number — but far more of your work is quantifiable than you think: time saved, error rate, users affected, revenue, cost, build time, incidents, test coverage, page count in a migration, size of the codebase or team.

Before and after: the rewrites that matter

Here are the model rewrites. Study the move in each one — every "after" adds a strong verb, a specific what, and a real number.

Read the left column again. Every weak bullet is true — and every one is invisible. "Responsible for," "worked on," "helped," "part of a team," "used" — these are the verbs of someone describing a job, not someone describing their impact. The right column says the same things with ownership and numbers, and that is the entire difference between the reject pile and the phone screen.

A full example experience entry

Here is what a complete, well-built entry looks like — one role, tight and evidence-first.

Keywords and the ATS: match, don't stuff

The ATS matches your resume against the job description, so the job description is your keyword list. If the posting says "Kubernetes," "distributed systems," and "gRPC," and you've genuinely done those things, use those exact words — not "container orchestration" and "microservices" when the parser is scanning for "Kubernetes." This isn't gaming the system; it's speaking the system's language for skills you actually have.

What it is not is keyword stuffing: a hidden white-text block of every buzzword, or a "Skills" section listing forty technologies you touched once. Recruiters see through it instantly and modern parsers weight it poorly. The honest version: keep a Skills section of technologies you can defend in an interview, and weave the role's key terms naturally into your bullets where they're true.

Tailoring without rewriting your life

You don't rewrite your resume for every job — you retune it. Keep one strong master resume, then for each application:

1. Read the job description and note its top 5–8 recurring terms and priorities.
2. Reorder your bullets so the most relevant ones sit first under each role.
3. Adjust your Skills section and a few bullet phrasings to mirror the posting's language — where honest.
4. Make sure your top third of the page screams "fit" for this role.

Ten minutes of tailoring per application beats a hundred generic blasts. The recruiter can tell the difference between a resume aimed at their role and a form letter.

What to cut

Space on a one-page resume is your most valuable real estate. Spend it only on evidence. Cut:

Projects: the early-career engineer's secret weapon

If you're a new grad or career-changer without much professional experience, projects are how you prove you can build. But a project entry follows the same rule as a job bullet — it's not "made a to-do app," it's evidence of real engineering:

• Built a full-stack expense tracker (React, Node, PostgreSQL) with authentication and CSV export; deployed on a VPS, used by ~50 beta users from a personal waitlist.
• Contributed a bug fix to [open-source library] merged into the main branch, resolving a memory leak in the connection pool (PR #1423).

Deployed, used by real people, merged into a real repo, solving a real problem — that's what turns a project from a tutorial exercise into a hiring signal. A live link and a GitHub repo beat any bullet, because the reader can check.

LinkedIn: be findable before you're ready to apply

Your resume is a document you send. LinkedIn is a profile recruiters find — often before you've applied anywhere. A huge share of engineering hiring starts with a recruiter running a search and reaching out. If your profile isn't built for that search, you're invisible to a pipeline you never see.

The recruiter's search view

Recruiters use LinkedIn Recruiter, which lets them filter by title, skills, location, years of experience, and keywords, then ranks results. They see a compact card: your photo, headline, current title, location. That card — not your full profile — is what earns the click. So the two highest-leverage fields are the headline and your skills/keywords, because those drive whether you appear in the search and whether the card gets clicked.

The headline

The default headline is just your current job title. That's a wasted asset. Your headline is searchable and it's the first line a recruiter reads. Make it say what you are and what you work with:

The strong versions carry keywords recruiters actually search and tell them in one line whether to click.

The About section

Write it in first person, like a human, not a third-person corporate bio. Three or four short paragraphs: what you do and your focus, a signature accomplishment or two (with numbers, same discipline as always), the technologies you work in, and — if you're looking — what you're open to. Front-load it; the preview cuts off after a couple of lines, so the hook goes first.

Being findable: skills, open-to-work, and staying current

• Skills section: LinkedIn's skills are a direct search filter. List the ones that match the roles you want, and get a few endorsed. This is one of the strongest levers on whether you surface in searches.
• Open to Work: you can signal availability privately to recruiters only (the discreet setting) without the green banner your current employer would see. It puts you into a pool recruiters specifically filter for. If you're job-hunting, turn it on.
• Keep it current: an outdated profile reads as neglect. Your current role, recent work, and up-to-date skills should match your resume. Recruiters cross-check.
• Photo and completeness: a real, professional-enough headshot and a "complete" profile rank higher and get more clicks than a blank silhouette.

Portfolio and GitHub: the signal that can't be faked

A resume claims; a repo proves. For engineers, a GitHub with real, readable code — a pinned project or two, sensible commits, a clear README — is corroborating evidence a recruiter or hiring manager can actually inspect. You don't need a dazzling portfolio site; you need a few things you're genuinely proud of, cleaned up and pinned. One well-documented, deployed project beats twenty abandoned tutorial forks. If your GitHub is a graveyard, pin your best work and let the rest recede.

Referrals beat cold applies — and how to get them

Here's the lever most engineers underuse. A referred candidate is dramatically more likely to get an interview than one who applies cold — referrals are how a large fraction of hires actually happen. A referral routes your resume past the stack and into a recruiter's "the ATS flagged this one as internal" lane, with a human vouching for you. Same resume, completely different odds.

You don't need a close friend inside. You need to be reasonable and specific:

• Start with your real network: former colleagues, classmates, bootcamp cohort, people you've worked with. A warm "I'm applying to your company — would you be comfortable referring me?" is normal and expected.
• Make it easy to say yes: send them the specific job link, your resume, and two sentences on why you fit. Don't make them do work. Most people want to refer good candidates — companies pay referral bonuses — but they won't chase you for details.
• Reach out cold, but warmly: a short, specific, respectful message to an engineer on the team ("I'm applying for the backend role and admired [specific thing your team built] — would you be open to a quick chat or a referral?") works more often than you'd expect. Be brief, be genuine, make it skippable.
• Give before you ask, over time: the best referrals come from relationships you built before you needed them. Answer questions, contribute, stay in touch. Networking isn't a favor economy you raid in an emergency; it's a garden you tend.

Common Mistakes

• Writing a job description, not a resume. "Responsible for X" lists duties. The reader wants results. Fix: lead every bullet with an action verb and end it with a number.
• No metrics anywhere. A resume of vague claims is indistinguishable from every other. Fix: quantify time, cost, users, errors, performance — anything true and specific.
• Fabricating impact. Inventing numbers or titles is the one unforgivable error; it collapses the moment an interviewer digs (and this volume's honesty rule is absolute). Fix: use real, defensible figures; if you must estimate, keep it honest and be ready to explain it.
• Fancy formatting that breaks the ATS. Columns, tables, text boxes, and graphics confuse parsers. Fix: single column, standard headings, real text, a common font, PDF-from-text (not an exported image).
• One generic resume for everything. A form-letter resume matches no job well. Fix: retune bullet order and keywords per role in ten minutes.
• A dead or default LinkedIn. An untouched profile with the default headline is a closed door to inbound recruiting. Fix: strong headline, real About section, skills filled in, Open to Work if you're looking.
• Only ever applying cold. Ignoring referrals throws away your biggest advantage. Fix: for every serious application, spend five minutes finding a warm path in.
• Keyword stuffing. Hidden text and 40-item skill lists get filtered and embarrass you in interviews. Fix: use the role's real terms only where they're true.

Summary

• You're writing for two skimmers: an ATS that parses text against the job description, and a recruiter who spends about six seconds looking for plausible fit. A clean, keyword-honest, impact-driven resume satisfies both.
• The bullet formula is everything: strong action verb + what you did + quantified impact. The metric is the difference between a claim and evidence — the same "show the result" discipline as STAR's Results step.
• Format to survive parsing: one page (for most), reverse-chronological, single column, standard headings, real text — and cut objectives, "references available," bloated skill lists, and anything without a result.
• Tailor, don't blast: retune bullet order and keywords to each job in ten minutes; match the JD's real terms without stuffing; never fabricate a number.
• LinkedIn makes you findable: a keyword-rich headline, a real About section, filled-in skills, and Open to Work put you in the recruiter searches you never see. Back it with a GitHub that proves you can build.
• Referrals beat cold applies by a wide margin — for every serious application, spend five minutes finding a warm path in.
• Emphasis shifts with seniority: new grads lead with projects, mid-levels with impact and scope, seniors with leadership and outcomes.

You've now got the interview — the resume passed the scan, the referral opened the door, the recruiter said yes. Next, we turn to what happens once you're in the room and the conversation turns to money: how to talk about compensation without leaving value, or dignity, on the table.