DEV Community: python Akshay

Your First Resume for Campus Placements: A Developer-Friendly Guide for Indian Freshers

python Akshay — Mon, 12 Oct 2026 14:04:06 +0000

Placement season is a strange sprint. Companies arrive back to back, shortlists drop overnight, and one PDF has to clear screening software, a 10-second recruiter skim, and then an interviewer who reads every line while you sit opposite them.

You can't control the cutoffs or the interview panel. You can control that PDF. Here's how I'd put one together as a fresher today.

Rule zero: one page, one column

No fresher needs two pages. Recruiters screening an entire batch won't reach page two anyway.

Stick to a single column. Fancy two-column templates often confuse applicant tracking systems (ATS), which read top to bottom; your skills sidebar can end up stitched into your education line. Skip photos, tables, text boxes, icon-only labels and skill bars. "Java ★★★★☆" tells a recruiter nothing.

The order of sections

Header
Two-line summary (optional)
Education
Technical skills
Projects
Internships and training
Achievements and positions of responsibility
Relevant certifications

Experienced engineers lead with work history. You lead with what you actually have: your education and what you've built.

Header: get the boring bits right

Use a professional email, ideally firstname.lastname@.
Write links as plain text so they survive parsing: github.com/yourname, linkedin.com/in/yourname.
Leave out date of birth, full address, father's name, religion and marital status. They eat space and add nothing for most private-sector roles. (Government and PSU forms have their own formats; follow those exactly.)

Summary: delete the "objective"

"Seeking a challenging position in a reputed organisation…" appears on thousands of resumes. If you want a summary, write two lines: target role, strongest area, one proof point. For example:

Final-year B.Tech (CSE) student aiming for backend roles. Built and deployed two full-stack projects using Node.js and PostgreSQL; completed a two-month internship on an internal reporting tool.

Swap in your real details.

Education: exact, not rounded

Spell out degree, branch, college, university and batch, because recruiters often filter on branch and passing year. Write your CGPA exactly as your university reports it. A 7.86 stays 7.86; mismatches with placement-cell records cost you trust. Class XII and Class X (board plus percentage) are usually expected on Indian campus resumes, one line each.

Skills: grouped, and only what you can defend

Languages : Java, Python, C++
Web       : React, Node.js, Express
Databases : MySQL, MongoDB
Tools     : Git, Docker, Postman

Treat every item as a possible interview question. One tutorial on Kubernetes doesn't earn it a spot.

Projects: your real work experience

For most freshers this is the section that wins the interview. For each project, give it a name, the stack, a link, and two or three bullets that say what you built and what it does. Start bullets with a verb ("Built", "Designed", "Reduced") and be specific about your part, especially for team projects. Two solid projects you can explain end to end beat five copied ones.

Internships, achievements, certifications

List internships with organisation, role, dates and one or two concrete bullets. Under achievements, hackathon results, coding-contest ranks and club leadership roles all count; keep each to one line. Include certifications only when they relate to the role.

Before you hit submit

Export as PDF, then select all, copy and paste it into a text editor. If the text comes out jumbled, an ATS will struggle too.
Read the job description and make sure skills you genuinely have are named the way the company names them.
Name the file sensibly: Firstname_Lastname_Resume.pdf.

If you want a head start on layout, Imperfectors is a free resume builder with one-column, ATS-safe templates and a watermark-free PDF download after email verification. If you'd like to see which keywords from a specific job description your resume is missing, that's the Pro plan.

Good luck this season. What tripped you up on your first placement resume? Tell me in the comments.

Akshay Arora is a full-stack developer in New Delhi building Imperfectors, a free ATS-friendly resume builder.

Tailoring a Developer Resume to a Job Posting: A Keyword Workflow That Stays Honest

python Akshay — Mon, 12 Oct 2026 13:42:31 +0000

"Use the words in the job description" is correct advice, but it isn't a method. Taken literally, it ends with a wall of buzzwords pasted under Skills and no change in callbacks. Below is a repeatable workflow: pull out the right terms, rank them, place them where your experience proves them, and stop before it turns into keyword soup. After a couple of tries it takes 15–20 minutes per application.

What matching is for

Apply on a company's careers page and your resume usually lands in an applicant tracking system that extracts the text and lets recruiters search and filter. Someone hiring a backend engineer may search "Go," "Kubernetes" or "distributed systems." If you have those skills but describe them differently, or hide them in a paragraph, you're harder to find. The goal is to be findable for what you can genuinely do, not to game software.

That assumes your text extracts cleanly. If you're unsure, this breakdown of what ATS parsers read and what breaks them covers headings, dates, columns and file types.

Pass 1 and pass 2 over the posting

First read for meaning: will this person build APIs, run infrastructure, or ship UI? Then read for terms, sorted into four groups:

Group	Backend examples
Title	Backend Engineer, SDE-2
Tools and skills	Go, PostgreSQL, Kafka, Kubernetes, AWS, gRPC
Practices	code review, CI/CD, observability, on-call
Context	payments, high-throughput, B2B SaaS

Notice where each term sits. The title, the opening paragraph and the "Requirements" list outweigh "Nice to have."

Rank them

Split the terms into must-have (title, required skills, anything repeated, usually 5–10) and nice-to-have (another 5–10). A term that shows up in the title, the summary and the requirements is almost certainly a must-have.

Audit your resume

Mark each term with one of four labels:

Present in the employer's wording
Reworded: "Postgres" vs "PostgreSQL," "K8s" vs "Kubernetes"
True but missing: you did it and never wrote it down
Not true: you don't have this skill

Edit only the reworded and true-but-missing items. The "not true" list is information, not a to-do list.

A quick script speeds up the first pass:

import re
jd = open("jd.txt").read().lower()
cv = open("resume.txt").read().lower()
terms = ["go", "postgresql", "kafka", "kubernetes", "aws", "grpc", "ci/cd", "observability"]
for t in terms:
    n_jd = len(re.findall(r"\b" + re.escape(t) + r"\b", jd))
    n_cv = len(re.findall(r"\b" + re.escape(t) + r"\b", cv))
    print(("OK     " if n_cv else "MISSING"), t, "JD:", n_jd, "CV:", n_cv)

It won't know that Postgres and PostgreSQL are the same, but the gaps stand out. Make resume.txt by copying all the text out of your PDF, which also confirms the PDF contains real text.

Place each term where the evidence lives

A keyword is strongest when it appears twice: once in Skills, where it's searchable, and once in a bullet, where it's believable. Reorder Skills so the must-haves come first without deleting the rest. Then rewrite one or two bullets per relevant role.

Before: Worked on backend services for the payments team.

After: Built and maintained Go services for payment reconciliation on PostgreSQL; added tracing and dashboards that cut time-to-diagnose for on-call issues.

That bullet covers Go, PostgreSQL, payments and observability because that was the actual work. If you can't stand behind a result, describe the work and skip the result. And if the posting says "Backend Engineer" while your summary says "Full-stack developer," lead with backend if that's truly your strength.

Mirror their wording once, then stop

Write "CI/CD" at least once if that's their term. Once in Skills plus once or twice in context is enough. Warning signs that you've gone too far: 40 items under Skills, the same word in every bullet, tools you've only read about, or a section that reads aloud like a tag cloud. Interviewers ask about every line.

Frontend example

Posting: Frontend Engineer, strong React and TypeScript, building our design system; accessibility (WCAG), Jest and Playwright testing, performance work required; Next.js a plus.

Audit: React and TypeScript present. "Component library" should also be called "design system." Accessibility is true but missing (you fixed keyboard navigation). Playwright isn't true, since you used Cypress, so list Cypress.

Built a shared React + TypeScript component library (internal design system) used across three product teams; added keyboard navigation and ARIA labels to meet WCAG guidelines, with Jest and Cypress tests.

Speeding up the comparison

Doing it by hand is the most reliable approach, because you decide what's true. Tools can speed up the comparison. Imperfectors, which I'm building, includes job-description keyword matching on its ₹499/month Pro plan: paste a JD and see matched and missing keywords. The resume builder itself is free. Treat any tool's output as a checklist, never a verdict.

Akshay Arora builds Imperfectors, a free ATS-friendly resume builder.

How to Match Your Resume to a Job Description (Without Keyword Stuffing)

python Akshay — Sun, 11 Oct 2026 11:05:16 +0000

A practical method for developers, with real examples from software engineering job descriptions.

Most advice about "ATS keywords" boils down to "use the words in the job description." That's true, but it's not a method. It leads people to paste a block of buzzwords into their skills section and wonder why nothing changes.

This post is a repeatable process: you extract the right terms, sort them by priority, find where they honestly belong in your resume, and stop before it turns into a word cloud. It takes 15–20 minutes per application once you've done it a couple of times.

Why matching matters at all

When you apply through a company's careers page, your resume usually goes into an applicant tracking system. It extracts the text, builds a candidate profile, and lets recruiters search and filter. A recruiter looking for a backend engineer might search for "Go," "Kubernetes" or "distributed systems."

If you have those skills but your resume calls them something else, or buries them in a paragraph, you're harder to find. Keyword matching is about being findable for the things you can actually do. It's not about fooling software.

(Matching only works if your resume's text extracts cleanly in the first place. If you're not sure, this guide to what ATS parsers read and what breaks them covers headings, dates, columns and file types.)

Step 1: Read the JD once for meaning, then again for terms

On the first pass, just answer: what is this person actually going to do? Build APIs? Own infrastructure? Ship UI?

On the second pass, highlight terms in four buckets:

Bucket	Example terms from a backend JD
Role title	Backend Engineer, Software Engineer II, SDE-2
Hard skills / tools	Go, PostgreSQL, Kafka, Kubernetes, AWS, gRPC
Practices	code review, CI/CD, observability, on-call
Domain / context	payments, high-throughput, B2B SaaS

Also note where each term appears. Words in the job title, the first paragraph, and the "Requirements" or "Must have" list matter most. "Nice to have" matters less.

Step 2: Sort into must-have vs nice-to-have

Make two short lists:

Must-have (title + required skills + anything repeated): usually 5–10 terms.
Nice-to-have (preferred tools, context words): another 5–10.

If a term appears in the title, the summary and the requirements, it's almost certainly a must-have.

Step 3: Audit your resume against the list

Go through each term and mark it:

✅ Present: already in your resume, in the employer's wording
🔁 Different wording: you wrote "Postgres," they wrote "PostgreSQL"; you wrote "K8s," they wrote "Kubernetes"
➕ Missing but true: you've done it, you just didn't mention it
❌ Missing and not true: you don't have this skill

Your edits come from 🔁 and ➕. The ❌ list is information, not a to-do list. Don't add those.

If you want a quick way to do the first pass, a tiny script works:

import re

jd = open("jd.txt").read().lower()
resume = open("resume.txt").read().lower()   # paste your resume's extracted text here

terms = ["go", "postgresql", "kafka", "kubernetes", "aws", "grpc",
         "ci/cd", "observability", "code review", "distributed systems"]

for t in terms:
    in_jd = len(re.findall(r"\b" + re.escape(t) + r"\b", jd))
    in_cv = len(re.findall(r"\b" + re.escape(t) + r"\b", resume))
    status = "OK " if in_cv else "MISSING"
    print(f"{status}  {t:<20} JD:{in_jd}  resume:{in_cv}")

It's crude (it won't know "Postgres" equals "PostgreSQL"), but it makes the gaps obvious. Get resume.txt by opening your PDF, selecting all, and pasting into a text file; that also confirms your PDF has real text.

Step 4: Put each keyword where the proof is

A keyword is strongest when it appears in two places: your Skills section (so it's searchable and scannable) and a bullet (so it's credible).

Skills section: reorder so the JD's must-haves come first. Don't delete the rest of your stack, just move it down.

Bullets: rewrite one or two bullets per relevant role so they show the skill in use.

Before:

Worked on backend services for the payments team.

After:

Built and maintained Go services for payment reconciliation on PostgreSQL; added tracing and dashboards that cut time-to-diagnose for on-call issues.

The second bullet hits "Go," "PostgreSQL," "payments" and "observability" (via tracing and dashboards) because that's what the work was. Only write what's true; if you don't have a result you can stand behind, describe the work clearly and skip the result.

Summary / title line: if the JD says "Backend Engineer" and your summary says "Full-stack developer," and backend really is your strength, adjust the summary to lead with backend.

Step 5: Use their wording, once

If the JD says "CI/CD" and you wrote "build pipelines," use "CI/CD" at least once. If they say "React.js" and you wrote "React," either is fine for humans; for search, matching their exact form once doesn't hurt.

You don't need to repeat a keyword five times. Once in Skills and once or twice in context is plenty.

Step 6: Stop before it becomes stuffing

Signs you've gone too far:

Your Skills section has 40 items
The same term appears in every bullet
You've added tools you've only read about
Reading it aloud sounds like a tag cloud

Recruiters read the shortlisted resumes, and interviewers ask about every line. Stuffing helps you get found and then hurts you in the room.

A worked mini-example

JD excerpt (frontend role):

We're looking for a Frontend Engineer with strong React and TypeScript skills to build our design system. Experience with accessibility (WCAG), testing (Jest, Playwright) and performance optimisation is required. Next.js is a plus.

Must-haves: Frontend Engineer, React, TypeScript, design system, accessibility/WCAG, Jest, Playwright, performance
Nice-to-have: Next.js

Resume audit:

React ✅, TypeScript ✅
"Component library" 🔁 → also say "design system" if that's what it was
Accessibility ➕ (you fixed keyboard navigation but never mentioned it)
Jest ✅, Playwright ❌ (you've used Cypress, not Playwright: list Cypress, don't claim Playwright)
Performance ➕ (you reduced bundle size)

Edited bullet:

Built a shared React + TypeScript component library (internal design system) used across three product teams; added keyboard navigation and ARIA labels to meet WCAG guidelines, with Jest and Cypress tests.

Doing this faster

The manual method above is the most reliable because you're the one judging what's true. Tools can speed up the comparison step.

If you'd rather not run a script, several resume tools offer job-description matching. The one I'm building, Imperfectors, has job-description keyword matching on its Pro plan (₹499/month): paste a JD and see which keywords your resume matches and which are missing. The resume builder itself is free. Whatever tool you use, treat its output as a checklist, not a verdict, and apply the "only if it's true" rule.

FAQ

How many keywords should I match?
There's no magic number. Aim to cover the must-haves you genuinely have, in Skills and in at least one bullet each.

Should I tailor my resume for every job?
For roles you really want, yes. A 15-minute pass is usually enough. For similar roles, keep two or three base versions (e.g. backend, full-stack) and tweak.

Is a "match score" the same as what the employer sees?
No. Each tool calculates its own score. Employers' systems vary. Use scores as a rough guide to gaps.

What about soft skills like "communication"?
Show them in bullets (e.g. "wrote the onboarding docs," "led code reviews"), rather than listing them as keywords.