First, understand what you're actually building for. Before you write a single word, know this: at most companies your resume gets read by software before a human ever sees it. It's called an ATS, an applicant tracking system. It scans your document, tries to pull out your job titles, skills, and dates, and ranks you against the posting. If the software can't read your resume cleanly, you're rejected before a person ever looks at it. So the whole game is writing something a machine can parse and a tired human can skim in a few seconds. Keep that in your head the entire time.

Start with a blank document, not a template. This is counterintuitive but it saved me. Open a plain document and set it to single column. Don't grab a fancy template with sidebars, colored boxes, or graphics. Those two-column designs look gorgeous to you and get shredded by the parsing software, which scrambles your job titles and drops entire sections. Single column, plain, top to bottom. That's the foundation.

Pick a normal font and size. Arial, Calibri, or Times New Roman, at 10 to 12 point. Nothing decorative. Set clean margins. This isn't the place to express yourself.

Now lay out your sections in this order:

Contact info at the very top. Your name, then a professional email (firstname.lastname at gmail is perfect, not the nickname you made as a teenager), a phone number, your city and state, and a LinkedIn link if you have one. Do not put your full street address, a photo, or your birthday. Nobody needs those and they can work against you.

A short professional summary, two or three lines. This is a quick snapshot of who you are professionally and what you bring. Skip the vague fluff like "hardworking team player seeking opportunities." Instead say concretely what you do and your strongest results. You write this last, actually, once the rest is done, because by then you'll know what to highlight.

A skills section. A clean list of your actual hard skills and tools. This is where a lot of your keyword matching lives, which I'll explain in a second.

Work experience, most recent job first, working backward. For each job: your title, the company, and the dates. Then bullet points underneath.

Education near the bottom. Degree, school, graduation year. If you're early in your career it can go higher; once you have real work experience it belongs at the end.

Now the part that actually determines whether you get called: the bullet points. This is where most people, including old me, go wrong. Don't list duties. "Responsible for managing social media" tells nobody anything. Instead, every bullet should show a result with a number attached. "Grew the company's social following from 2,000 to 15,000 in eight months" gets read instantly. For every line you write, ask yourself: how much, how many, how often, and what happened as a result. Even rough estimates are fine if you can't find exact figures. Start each bullet with a strong action verb like led, built, cut, grew, launched, or automated, not "responsible for" or "helped with."

Then tailor it to each specific job. This is the step people skip because it's tedious, and it's exactly why they don't hear back. Read the job posting carefully. Notice the exact words it repeats for skills and responsibilities. If the posting says "stakeholder communication," use that exact phrase in your resume, don't paraphrase it as "talking to people across teams." The software often looks for exact matches. So you keep one master resume and spend ten minutes per application swapping in the language and skills that match that specific posting. Do not stuff keywords in unnaturally though. It reads like nonsense to the human who eventually sees it, and some systems flag it. Weave them into your real bullets.

A few rules on the file itself. Kill any tables or text boxes you were tempted to use to line things up neatly, because they get read out of order or dropped. Save it as a normal document, and name the file "Firstname Lastname Resume," not "resume final v3.pdf."

On length: one page if you have under about five years of experience, two pages is completely fine after that. Don't cram a decade into one page with microscopic font to obey some rule you heard once. That one-page thing is really just a courtesy to human readers, and a clean two pages beats a cramped one. The software doesn't care about the second page.

A word on the AI writing tools everyone's pushing right now. They're okay for generating a rough skeleton if you're truly staring at a blank page, but the output sounds generic and everyone ends up with near-identical resumes. If you use one at all, rewrite it heavily in your own voice. Sounding like a real person is an advantage now precisely because so much of what's out there sounds the same.

Last thing, an honest reality check. Even a great resume can't beat how crowded the market is. A solid resume doesn't work magic; it just stops you from getting filtered out for dumb, avoidable reasons. Think of it as clearing an obstacle, not finding a shortcut.

That's the whole thing. Build the plain single-column skeleton, fill it with numbers-driven bullets, tailor the language to each posting, keep it clean, and you're already ahead of most of the pile. Good luck. It's a grind, but it ends.

## TL;DR checklist

- ☐ One page, single column, PDF named First-Last-Resume.pdf
- ☐ No photo, no skill bars, no objective, no "references available"
- ☐ Top third = your best material (the 6-second scan zone)
- ☐ Every bullet: XYZ formula, strong verb, a number
- ☐ Skills: grouped, ordered by relevance, everything interview-defensible
- ☐ Exact keyword spelling mirrored from each JD (React.js vs React matters)
- ☐ 2-3 base versions + 15-minute tailoring per application
- ☐ Projects (juniors): deployed, with users, not a tutorial clone
_____________________________________________________

I've been on both sides: hundreds of applications across two job searches, then screening resumes for my own team. This is everything I wish someone had told me before my first search. No fluff, no "use action verbs!!" filler.

It's long, but read the whole thing and you'll know more about SWE resumes than 95% of the people you're competing against.

Part 1: How your resume is actually read

A human looks at your resume for 6-10 seconds. They scan: current title, current company, dates, tech stack, school. In that order. The top third of your resume is doing 80% of the work. Design accordingly.

https://preview.redd.it/c5829azob0fh1.png?width=1628&format=png&auto=webp&s=1aea98d79f112e76be017200d498c4194169372b

The ATS almost never "auto-rejects" you. But it still kills you. The robot-throwing-out-resumes thing is mostly a myth. What actually happens: the ATS is a searchable database. A recruiter with 800 applicants types "React" "AWS" "Kubernetes" into a search bar and only opens what matches. You weren't rejected. You were never found. Same outcome, different mechanism, and it changes how you optimize:

• Your resume must be machine-parseable: no tables, no text boxes, no two-column layouts, no icons, no critical info in headers/footers.
• Use the exact spelling from the job description. If the JD says "CI/CD" and you wrote "continuous integration," you may not show up in the search. Cover both: "React (React.js)", "PostgreSQL (Postgres)".

Recruiters can't evaluate your engineering. They pattern-match. The first screener is usually non-technical, matching a checklist: years, stack, degree. The hiring manager (reader #2) is the one who cares about depth. So your resume needs keyword density to survive reader #1 AND substance to impress reader #2. Most resumes have one or the other.

Part 2: The template (settled law at this point)

The format below is boring on purpose. Boring parses. Boring scans. Boring wins.

• One page (two max if 10+ years, and page one must stand alone). Single column. PDF, always, named FirstName-LastName-Resume.pdf and not resume_final_v3 (2).pdf.
• No photo, no graphics, no skill bars. A 7/10 bar next to "Python" is meaningless (7/10 compared to whom, Guido?) and reads junior. In the US, a photo can actually get you discarded due to discrimination-liability policies.
• Standard font (Calibri, Helvetica, Georgia, Computer Modern), 10-12pt, 0.5-0.75" margins.
• No "References available upon request." No objective statement. A 3-line summary is worth it for seniors only, more on that in Part 7.

Section order. Students/new grads: Header > Education > Skills > Projects > Experience. Everyone with 1.5+ years: Header > Experience > Skills > Projects (optional) > Education. Once you have real experience, education shrinks to one or two lines at the bottom.

Header: Name, city + state (or "Open to relocation"), email, phone, LinkedIn, GitHub, all as clickable links. Recruiters click GitHub more than you'd think. If yours is a graveyard of empty forked repos, either clean it up or leave it off. An empty GitHub is worse than no GitHub.

Here's a complete resume built exactly to this guide. Steal the structure:

https://preview.redd.it/yudc8abbb0fh1.png?width=1360&format=png&auto=webp&s=e3e48db7bdd7571de746bc115767744e812fb50b

Template: Pure ATS Resume Template

Part 3: The bullet formula (where 90% of resumes die)

Most SWE bullets are job descriptions:

>❌ "Responsible for developing backend microservices"
>❌ "Fixed bugs and implemented new features"

These say what you were assigned. Any warm body in that seat could write them. Instead, use the XYZ formula: "Accomplished [X], as measured by [Y], by doing [Z]."

>✅ "Cut p99 API latency from 1.2s to 340ms by introducing Redis caching and rewriting N+1 queries, improving checkout conversion by 2.1%"
>✅ "Reduced AWS spend by $8.4K/month by migrating batch jobs from EC2 to spot-instance-backed ECS"
>✅ "Shipped a feature-flag system used by 40+ engineers, cutting release rollbacks by ~60%"

Outcome first, number attached, technique last. The recruiter sees impact, the hiring manager sees judgment. One bullet, two audiences.

"But I don't have metrics." Yes you do, you just never measured. A cheat sheet:

• Scale: requests/day, DB rows, services, users, team size
• Speed: build time before/after, deploy frequency, query time
• Money: infra cost, hours saved x hourly cost, revenue of the flow you worked on ("owned checkout processing $2M/month")
• Quality: incident count, test coverage change, on-call pages reduced

Careful estimates are fine. "~30%", "from ~2 days to ~2 hours". Nobody will subpoena your Datadog dashboard. Just be ready to walk through the reasoning in an interview, because good interviewers will ask. "I estimated it carefully" is a legitimate answer, "I made it up" is not.

Ban the weak verbs (helped, worked on, assisted, was responsible for). Own your part explicitly: not "helped migrate the database" but "migrated 12 of 30 services from MySQL 5.7 to 8.0 with zero downtime." 3-5 bullets for recent roles, 1-2 for old ones.

https://preview.redd.it/y9zyc30ea0fh1.png?width=1200&format=png&auto=webp&s=ff95562167ec48e57c048ac43e726a17ace21b04

Part 4: Skills (short, honest, weaponized)

• Everything you list is fair game in the interview. Listed Kubernetes because you once ran kubectl get pods? Enjoy your systems interview. If you can't survive 5 minutes of questions on it, cut it.
• Order by relevance to the target job, not alphabetically. The first 3-4 items get read, the rest get skimmed.
• Group it: Languages / Frameworks / Infra & Cloud / Tools. Three or four lines total. A 25-item comma soup signals you can't prioritize, which is itself an engineering signal, and not a good one.
• Delete the filler: MS Office, Git (assumed, like listing "typing"), "Agile/Scrum" unless you're a lead.
• Never list soft skills. Show them in bullets instead ("mentored 3 juniors", "led incident response"). Claimed soft skills are invisible. Demonstrated ones are memorable.

Part 5: Projects, the section that gets juniors hired and seniors ignored

Under 2 years of experience? Projects are your experience section in disguise. 5+ years? Cut the section unless a project is genuinely notable (real users, open source with adoption).

What separates interview-getting projects from tutorial slop:

• Deployed and live beats perfect and local. A janky app with a real URL and 30 actual users beats a flawless local-only clone. Deployment forces you into the exact problems day-one job work involves (auth, hosting, CI, migrations), and interviewers know it.
• The instant tells: a todo app, a weather app, a Netflix clone with the same name as a famous YouTube tutorial. Screeners have seen the same three projects 400 times. If you started from a tutorial, extend it until it's unrecognizable, then describe the extension.
• Write project bullets in XYZ format too: "Built a price-tracking tool with 200+ weekly users; scrapes 5K products/day with a queued worker system (Python, Celery, Redis)."
• One weirdly effective trick: include a "why". "Built X because Y didn't exist for Z" reads like an engineer solving a problem. Screeners remember it.

Part 6: Tailoring, the 15-minute ritual that triples callbacks

One generic resume blasted at 300 jobs gets you a 1-2% callback rate. Tailoring routinely triples that. The ritual:

1. Open the JD. Highlight every technology and every noun that appears twice or more.
2. Mirror the exact spelling into your skills section and 2-3 bullets (only for things you've genuinely used).
3. The JD's top 3 requirements should appear in your top 3 bullets.
4. Match your title if it's an honest synonym: "Software Engineer II (Member of Technical Staff)". Recruiters search by standard titles, and nonstandard ones make you unfindable.
5. If the JD leads with a domain (fintech, healthcare), surface any adjacent experience. Domain match is a silent tiebreaker.

You don't need a new resume per job. You need 2-3 base versions (backend / full-stack / infra). And yes, your FAANG version and your startup version should differ: big companies want scale and rigor, startups want ownership and shipping speed.

Part 7: Seniors, your resume has a different job

If you're 7+ years in, the junior playbook actively hurts you.

• Scope replaces stack. Nobody hires a staff engineer for knowing React. "Led design of the event pipeline handling 2B events/day across 4 teams." Systems owned, decisions made, dollars affected.
• A 3-line summary now earns its space: "Backend engineer, 9 yrs, distributed systems at fintech scale; led teams of 4-8; deepest in Go/Kubernetes/event-driven architectures." That's the 6-second scan, pre-digested.
• Leadership evidence without a manager title: mentored X engineers, ran the interview loop, drove the migration RFC.
• Compress ancient history. Roles older than 10 years become one line each. And cut technologies you'd refuse to be interviewed on. Everyone knows "10+ years JavaScript" includes the jQuery years.

Part 8: Instant red flags (from people who reject resumes for a living)

• Buzzword bullets: "Leveraged synergies to deliver scalable, robust solutions." Deleted on sight.
• 15 technologies listed, bullets mention 3. Screams keyword stuffing.
• Vague "we" bullets everywhere. What did you build?
• Unexplained 6+ month gaps. One line fixes it: "Career break: family care / relocation / independent study." Laid off? Say it plainly, there's zero stigma in this market.
• 8pt font and 0.2" margins to fake one page. You need an editor, not a smaller font.
• Typos in a resume that claims "attention to detail." Read it out loud once, you'll catch things your eyes skip.
• Personal info that doesn't belong (US market): date of birth, marital status, photo, street address.

Rapid-fire FAQ

• GPA? Include if 3.5+, students/new grads only. Gone after your first job.
• Certs? Cloud certs have modest signal for junior/infra roles. A Udemy certificate wall has negative signal.
• LeetCode profile? Only if genuinely strong, and only for junior roles.
• Hobbies? One line, only if distinctive ("restore arcade cabinets"). "Reading and traveling" is a blank line that ate a bullet point.
• AI tools? If you use them for real work, yes. "Integrated LLM-based X" is one of the most-searched keywords of this hiring cycle.

The resume won't get you the job. It gets you the conversation. But in a market where one posting pulls 800 applicants in a week, the conversation is the whole battle.

Good luck out there. You've got this.

If this does well I'll write up part 2: where to actually apply (the 48-hour rule, the referral cheat code, cold email vs the apply button) and the follow-up emails almost nobody sends.

most of these builders let you make the whole resume then hit you with a paywall at download. wasted an hour on two different sites like that

is there one with an actually usable free plan? I mainly need clean ATS-friendly templates and PDF export. AI features would be nice but not a dealbreaker

applying to a lot of jobs right now so budget matters lol

so I keep seeing every resume builder advertise "AI rewrite" or "AI tailoring" but when I actually try them the output is always the same corporate buzzword soup. "results-driven professional with a proven track record" type stuff that recruiters can smell from a mile away

what I want is something that takes MY bullet points and actually makes them stronger, not replaces everything with generic filler. bonus if it can adapt the wording to match a job description without me copy pasting everything manually

currently applying to a bunch of remote positions so I'm rewriting stuff constantly and it's eating my whole evening every day

tried the free tier of a few (rezi, teal) but hard to judge the AI quality before paying. is there one where the rewrite feature is actually good in 2026? or is chatgpt/claude + a normal template still the better move

not looking for "just write it yourself" answers lol, I know, that's what I've been doing