DEV Community: MADAN DHOUNDIYAL

I Had 160 Playwright Tests. I Deleted All of Them. Here's Why.

MADAN DHOUNDIYAL — Mon, 22 Jun 2026 17:34:09 +0000

I Had 160 Playwright Tests. I Deleted All of Them. Here's Why.

Last week someone asked me a simple question about my E2E test suite:

"How can you assure that these test cases are actually checking?"

I opened the files to answer confidently. Instead, I spent the next hour realizing I couldn't.

The Setup

I'd built ResumeOrbitz — a resume builder with an editor, live preview, template selector, PDF download, cover letters, and public sharing. The kind of app where a lot of things need to work together.

So I did the responsible thing: I wrote tests. 160 of them. Spread across 20 spec files. GitHub Actions ran them on every push. Green checkmarks everywhere.

✓ 160 passed (4.2m)

I felt good about it.

The Question That Broke Everything

When I looked closely at what the tests were actually doing, I saw things like this:

test('dashboard loads and shows new resume button', async ({ page }) => {
  await page.goto('/dashboard');
  await expect(page.getByRole('button', { name: /new resume/i })).toBeVisible();
});

test('login page renders', async ({ page }) => {
  await page.goto('/login');
  await expect(page.getByPlaceholder('you@example.com')).toBeVisible();
  await expect(page.getByPlaceholder('Your password')).toBeVisible();
  await expect(page.getByRole('button', { name: /sign in/i })).toBeVisible();
});

test('forgot password page renders and accepts email', async ({ page }) => {
  await page.goto('/forgot-password');
  await page.getByPlaceholder('you@example.com').fill('test@example.com');
  await page.getByRole('button', { name: /send reset/i }).click();
  await expect(page.locator('body')).toBeVisible(); // 🚩
});

That last one expects body to be visible. The body of an HTML page is always visible. That test will pass even if the page is a blank white screen, a 500 error, or a "this site has been taken down" message.

These aren't tests. They're theater.

What Theater Tests Look Like

A theater test checks that something exists, not that it works.

Theater (presence check)	Real (behavioral check)
Button is visible	Clicking button navigates to /editor
Input field is on page	Typing in field updates the live preview
Page has a title	Invalid login shows an error message
Element count > 0	Deleting a resume removes it from the list

The critical difference: a theater test passes even when the feature is broken.

If I remove the click handler from the "New Resume" button, the first test still passes — the button is still visible. The second one doesn't catch that the sign-in form does nothing on submit. The forgot-password one would pass if I swapped the page for a cat photo.

The Sabotage Test

There's a clean way to find out if a test is actually checking something:

Deliberately break the feature and run the test. If it still passes, the test is worthless.

For example, to verify TC-LP-02 ("first name typed in form appears in live preview"):

In EditorPage.tsx, comment out the line that syncs the first name field to the preview state
Run the test

If the test goes red → it's real. It caught the regression.

If the test stays green → it's theater. It was never checking what it claimed.

I applied this thinking to every one of my 160 tests. The ones that checked actions and state changes were real. The ones that checked visibility and presence were not.

The Tests That Were Actually Good

Out of 160, the ones worth keeping were the behavioral ones:

// ✅ Real: action → URL change (tests the route guard)
test('unauthenticated user redirected from dashboard to login', async ({ page }) => {
  await page.goto('/dashboard');
  await expect(page).toHaveURL(/login/);
});

// ✅ Real: wrong input → specific error (tests validation logic)
test('register with mismatched passwords shows error', async ({ page }) => {
  await page.goto('/register');
  await page.getByPlaceholder('Min. 8 characters').fill('Password123!');
  await page.getByPlaceholder('Repeat your password').fill('Different123!');
  await page.getByRole('button', { name: /create free account/i }).click();
  await expect(page.getByText(/passwords do not match/i)).toBeVisible();
});

// ✅ Real: creates data → navigates away → data still exists (tests persistence round-trip)
test('new resume then back to dashboard shows the resume', async ({ page }) => {
  await page.getByRole('button', { name: /new resume/i }).click();
  await page.waitForURL('**/editor/**');
  await page.goto('/dashboard');
  await expect(page.locator('[href*="/editor/"]').first()).toBeVisible();
});

// ✅ Real: type → check specific value in different part of UI (tests live sync)
test('first name typed in form appears in live preview', async ({ page }) => {
  await page.getByLabel(/first name/i).fill('Alexandra');
  await expect(page.locator('.fixed.right-0').getByText('Alexandra')).toBeVisible();
});

These tests verify state transitions, not static presence. They can actually go red.

What I Did About It

I deleted all 160 tests. Then I generated a proper manual test sheet — 160 rows in a spreadsheet with the module, preconditions, steps, expected result, and a Pass/Fail column I fill in myself before every release.

Yes, manual. Because a manual test you actually run beats an automated test that never fails by design.

The plan going forward: write new E2E tests only for flows that are:

High-risk — auth guards, data persistence, PDF generation
Behavioral — they verify an action produced a specific outcome
Sabotage-verified — they go red when the feature is broken

Ten real tests are worth more than 160 green lies.

The Rule I Wish I'd Had Earlier

Before committing any test, ask:

"If I remove the feature this test claims to cover, will this test fail?"

If the answer is "no" or "I'm not sure" — rewrite the test or delete it. A test that can't go red is not protecting you. It's just giving you false confidence while your bugs ship undetected.

Quick Reference: Theater vs Real

Theater patterns (delete or rewrite):

expect(element).toBeVisible() with no preceding action that could hide it
expect(page.locator('body')).toBeVisible()
expect(page).toHaveURL(currentPage) — checking you didn't navigate away
Any test that checks an element is present but never interacts with it

Real patterns (keep and add more):

action → expect(page).toHaveURL(/new-route/)
fill wrong value → expect(error message).toBeVisible()
create → reload → expect(data still exists)
type in field A → expect(value in panel B).toBeVisible()
delete item → expect(item).not.toBeVisible()

Building something? Check out ResumeOrbitz — a free resume builder with live preview, 100+ templates, and AI-powered suggestions.

Originally published at https://resumeorbitz.com/blog/playwright-theater-tests

I Really Don't Understand Why I'm Not Getting Interviews

MADAN DHOUNDIYAL — Fri, 19 Jun 2026 14:26:05 +0000

You've applied to 50 jobs. Maybe 80. Maybe more.

You spend 20 minutes on each application - customizing the cover letter, reading the job description, double-checking the requirements. You hit submit. And then... silence.

No rejection. No interview. Nothing.

It's one of the most demoralising feelings in the world. And the worst part? You don't even know what's going wrong.

I've been there. And after helping a lot of people fix their resumes, I can tell you - the answer is almost always hiding in one of these five places.

1. Your resume never reached a human

This is the most common reason. And most people have no idea it's happening.

Over 98% of mid-to-large companies use an Applicant Tracking System (ATS) - software that scans and filters resumes before any recruiter sees them. If your resume doesn't score high enough against the job description, it gets rejected automatically.

No human ever saw it. No human ever rejected you.

What the ATS is looking for:

Exact keywords from the job description
Clean formatting it can actually parse (no tables, text boxes, or multi-column layouts)
Standard section headings like "Experience," "Education," "Skills"

Quick fix: Copy the job description into a word cloud tool. The biggest words are your must-have keywords. If they're not in your resume, add them - verbatim.

2. Your bullets describe tasks, not results

This is the second biggest killer.

Most resumes sound like a job description:

"Responsible for managing social media accounts and creating content."

That tells a recruiter nothing about you specifically. Every social media manager in the world could write that line.

What actually gets attention:

"Grew Instagram from 4,200 to 31,000 followers in 8 months through a weekly content series - reduced paid ad spend by 40%."

That's a story. That's specific. That's memorable.

The rule: Every bullet should answer "so what?" If you can delete it without losing anything meaningful, rewrite it.

3. You're sending the same resume everywhere

This one hurts to hear, but it's true.

A generic resume is optimized for nothing. A tailored resume is optimized for one specific job - and that's exactly what gets past ATS filters and catches recruiter attention.

You don't need to rewrite the whole thing. Just:

Update your summary to match the role
Reorder your skills to front-load what the JD emphasizes
Swap 2-3 bullet points to mirror the JD's language

That alone can be the difference between a 45% ATS match and a 78% match.

4. Your contact information is broken (or missing)

I've seen this more times than I can count.

Email in the header image (ATS can't read images)
Phone number in the footer (ATS parsers often skip footers)
LinkedIn URL that's broken or private

Make sure your name, email, phone, and LinkedIn are in plain text at the very top of your resume. Not in a table. Not in a header. Plain. Text.

5. Your resume format is confusing the parser

Some of the most beautiful resumes are completely unreadable to ATS software.

Formats that fail ATS:

Canva resumes with columns and icons
Word docs with tables for layout
PDFs with embedded fonts that don't export correctly
Two-column layouts where the parser reads columns left-to-right, mixing sentences from both sides

What works:

Clean single-column or simple two-column layouts
Exported from a proper resume builder (not Canva)
Standard readable fonts - Arial, Calibri, Georgia

What to do right now

Check your ATS score before submitting any application. Tools like ResumeOrbitz let you paste the job description and instantly see your score, missing keywords, and what to fix.
Pick a clean ATS-friendly template. ResumeOrbitz has 100+ templates that are all tested to parse correctly - from Harvard-style bullet-point formats to modern two-column layouts.
Rewrite your bullets. Add numbers. Be specific. Delete anything vague.
Tailor before you submit. It takes 10 minutes. It changes everything.

The hard truth

You are probably qualified for most of the jobs you're applying to.

The problem isn't your experience. It's how your experience is being presented - and whether a piece of software is letting it through in the first place.

Most people fix 2-3 things on their resume and start getting interview calls within a week. The resume was always good enough. It just needed to be readable.

Don't give up. Fix the process, not yourself.

Originally published at https://resumeorbitz.com/blog/why-not-getting-interviews

ATS-Friendly Resume Tips: How to Beat the Bots and Reach a Human Recruiter (2026)

MADAN DHOUNDIYAL — Mon, 15 Jun 2026 11:42:22 +0000

You applied to 30 companies. Heard back from none. Your skills match the job description. Something is wrong.

Most likely culprit: ATS — the invisible filter that decides whether a human ever reads your resume.

This guide explains exactly how ATS works and gives you a checklist to beat it.

What Is ATS and Why Should You Care?

ATS stands for Applicant Tracking System. It's software that:

Receives your resume when you apply online
Parses it into structured data (name, skills, experience, education)
Scores it against the job description
Ranks it against other applicants
Only passes the top-scoring resumes to a recruiter

Companies using ATS in India: TCS, Infosys, Wipro, HCL, Accenture, Swiggy, Zomato, Razorpay, CRED, Flipkart, most startups with 20+ employees.

If your ATS score is below their threshold — no human ever sees your resume. It doesn't matter how qualified you are.

How ATS Parses Your Resume

ATS converts your resume into a database entry. It tries to extract:

Contact information
Work history (company, title, dates, bullets)
Education (degree, institution, year)
Skills (hard skills, tools, technologies)
Certifications

The problem: ATS parsers are not smart. They follow rigid rules. Anything that breaks those rules = lost data = lower score.

The 10 ATS Rules You Must Follow

Rule 1: Single column layout only

Two-column resumes (sidebar + main content) are the #1 ATS killer.

ATS reads left-to-right across the full page width. A two-column layout makes it read sidebar and main content mixed together:

Python | JavaScript | Led team of 5 engineers at...

Result: your skills get jumbled with your experience, your dates go missing, your score drops.

Fix: One column. Full width. No exceptions.

Rule 2: No tables

Same problem as columns. Table cells get read across rows, mixing unrelated content.

Fix: Replace skill tables with plain comma-separated text.

Rule 3: Standard section headings

ATS looks for known headings to categorize content:

✅ "Experience", "Work Experience", "Professional Experience"
✅ "Education", "Academic Background"
✅ "Skills", "Technical Skills"
✅ "Projects", "Key Projects"
❌ "My Journey", "What I've Done", "Things I Know"

Creative headings break ATS categorization.

Rule 4: No headers or footers for important info

Many ATS systems can't read content inside headers/footers of Word documents.

Don't put your name, phone, or email in the document header. Put them in the main body.

Rule 5: No graphics, icons, or images

ATS ignores images entirely. If you have:

A photo
Company logos
Skill rating icons
Decorative lines made from images

...they get skipped. Worse — they can corrupt the parser output.

Rule 6: No skill bars or rating systems

"Python ████░ 4/5" — ATS reads this as garbled text or ignores it.

Just write: "Python" in your skills section.

Rule 7: Use keywords from the job description

ATS scores your resume by matching it against the job description. More keyword matches = higher score.

If the job says:

"Experience with React.js, TypeScript, and REST API development"

Your resume must say: React.js, TypeScript, REST API — exactly as written.

Not: "React", "TS", "APIs" — variations may not match.

Rule 8: Spell out abbreviations at least once

If the job uses "Machine Learning" but you only wrote "ML" — it might not match.

Fix: "Machine Learning (ML)" the first time, then "ML" after.

Rule 9: Use standard date formats

ATS parses dates to calculate tenure. Use consistent formats:

✅ Jan 2023 – Dec 2023
✅ 01/2023 – 12/2023
❌ "Last year", "2 years ago", "Present" (without a start date)

Rule 10: Submit as PDF (usually) or clean DOCX

Modern ATS handles PDFs well. But some older systems (common in large Indian enterprises) prefer DOCX.

If the job posting says "upload resume" without specifying format — PDF is safer.
If it says "Word document" or "DOCX" — use that.

The ATS-Optimized Resume Template

Here's a structure that passes every ATS:

[Full Name]
[Phone] | [Email] | [City] | [LinkedIn] | [GitHub]

SUMMARY
2-3 lines. Include your target job title + top skills.

SKILLS
Languages: Python, JavaScript, Java
Frameworks: React, Node.js, Spring Boot
Databases: PostgreSQL, MongoDB, MySQL
Tools: Git, Docker, AWS, Postman

EXPERIENCE
Job Title | Company Name | City | Month Year – Month Year
• [Action verb] + [what you did] + [metric/result]
• Mirror keywords from the job description here

EDUCATION
Degree, Major | College Name | Year
CGPA: X.X

CERTIFICATIONS
Certification Name | Issuing Organization | Year

Keyword Strategy: How to Tailor for Every Application

For each job you apply to:

Copy the job description into a text editor
Highlight every technical skill, tool, and qualification mentioned
Check your resume — does each highlighted term appear?
Add missing terms where you genuinely have that skill
Use the exact spelling/format from the job description

This takes 10 minutes per application and dramatically increases your match score.

How to Check Your ATS Score Before Applying

Before submitting, run your resume through an ATS checker:

Go to ResumeOrbitz ATS Checker
Paste the job description
See your keyword match percentage
Fix the gaps it identifies
Re-check until you hit 70%+

Aim for 70-80% match. 100% looks keyword-stuffed and suspicious.

ATS vs Human Reader: You Need to Satisfy Both

Here's the thing: after ATS filters you in, a human reads your resume.

A resume optimized only for ATS (just stuffed with keywords) reads like garbage to humans.

The balance:

Keywords (for ATS) — use terms from the job description naturally
Numbers and outcomes (for humans) — give context that a person cares about
Clean formatting (for both) — ATS parses it, humans scan it

Quick ATS Checklist

Before submitting any application:

[ ] Single column layout
[ ] No tables or text boxes
[ ] No photos or graphics
[ ] Standard section headings
[ ] Keywords from job description included
[ ] Dates in consistent format
[ ] No headers/footers with important info
[ ] File saved as PDF (or DOCX if specified)
[ ] ATS score checked — 70%+ match

Build an ATS-Safe Resume Free

All templates on ResumeOrbitz are single-column and ATS-safe by design. The built-in ATS checker lets you test against any job description before you apply.

Free to use, free to download — no payment required.

Have questions about a specific ATS issue you're facing? Drop it in the comments.

Originally published at https://resumeorbitz.com/blog/ats-friendly-resume-tips

How to Write a Resume With No Experience (2026 Guide for Indian Freshers)

MADAN DHOUNDIYAL — Mon, 15 Jun 2026 11:38:59 +0000

The most common excuse for not applying to jobs: "I don't have enough experience to write a good resume."

Here's the truth: everyone with zero experience thinks this. And almost everyone is wrong. You have more to put on a resume than you think — you just don't know how to frame it yet.

This guide fixes that.

What "No Experience" Actually Means (and Doesn't Mean)

When recruiters say they want "experience", they mean evidence that you can do the job.

Work experience is one form of evidence. But it's not the only one.

Other valid evidence:

A project you built and deployed
A freelance gig, even a small one
An internship (paid or unpaid)
A college club leadership role
Open source contributions
Certifications you completed
Hackathon participation

If you have any of these — you're not "no experience." You're a fresher with real work to show.

The Right Resume Structure for Zero Work Experience

Don't use the standard resume structure (Experience → Education). It highlights what you don't have.

Use this instead:

1. Header (Name + Contact + GitHub/LinkedIn)
2. Summary (2-3 lines — your best selling points)
3. Skills (your technical toolkit)
4. Projects (THIS is your experience section)
5. Education
6. Certifications / Courses
7. Achievements (optional — hackathons, competitions)

The key move: replace "Experience" with "Projects" and treat your projects exactly like work experience.

How to Write a Summary With No Experience

Don't write: "Seeking a challenging position to utilize my skills."

No one has ever gotten a job from that sentence.

Write a 2-3 line summary that says:

What you are (degree/field)
What you can do (top 2-3 skills)
What you want (specific role)

Example for a CS fresher:

"Computer Science graduate (2024) with hands-on experience building full-stack web apps using React and Node.js. Completed 3 deployed projects with real users. Looking for a junior developer role where I can build and ship products."

Example for a non-tech fresher:

"MBA graduate with strong analytical skills and internship experience in digital marketing. Built and managed social media campaigns reaching 10,000+ followers. Seeking a marketing analyst role."

Specific. Skills named. Role named. One number. That's all it takes.

The Projects Section: Your Most Important Section

This replaces your work experience. Treat each project like a job entry.

Format:

Project Name | Tech Stack | [Live Link] | [GitHub]
Month Year
• What it does (one sentence, user-focused)
• What you built technically (the interesting part)
• One metric: users, performance, scale, or feature count

Weak version:

Weather App
• Made a weather app using an API

Strong version:

WeatherNow — Real-Time Weather Dashboard | React, OpenWeatherMap API | [Live] | [GitHub]
March 2024
• Displays real-time weather for any city with 5-day forecast and hourly breakdown
• Implemented geolocation auto-detect and localStorage for city history
• 300+ daily active users within 2 weeks of sharing on college WhatsApp group

Same project. Completely different impact.

What If You Genuinely Have Zero Projects?

Build one this weekend. Seriously — one weekend is enough.

Weekend project ideas that look good on a resume:

For developers:

URL shortener — classic, shows backend + database skills
Expense tracker — full-stack with auth, very practical
GitHub profile README generator — meta and relevant to developers
Any API + dashboard — pick Spotify, NASA, OpenAI, anything interesting

For non-tech roles:

Research report — pick an industry, write a 10-page analysis with data
Social media audit — analyze a brand's presence, write recommendations
Excel dashboard — take public data, build a visualization

Deploy it. Write a README. Put it on GitHub or a live URL.

That's a project. That goes on your resume.

Internships and Part-Time Work Count Too

Anything where someone paid you (or even didn't pay you) to do work counts.

Tutored a student in math? That's "Freelance Academic Tutor"
Managed your cousin's Instagram? That's "Social Media Manager (Freelance)"
Built a website for a local shop for ₹2,000? That's "Web Developer (Contract)"

Format it like a job entry:

Freelance Web Developer
Self-employed | Jan 2024 – Mar 2024
• Built and deployed a portfolio website for a local photography studio
• Implemented contact form with email integration using Nodemailer
• Delivered on a 2-week deadline; client currently using the site

Skills Section: What to Include

List only real skills — things you could answer interview questions about.

Good format:

Languages: Python, JavaScript, SQL
Frameworks: React, Django, Express
Tools: Git, VS Code, Figma, Excel
Soft Skills: (skip this — it's filler)

Don't include:

Soft skills ("good communicator", "team player") — everyone writes this, no one believes it
Skills from a 2-hour tutorial you did once
"MS Office" unless it's genuinely central to the role

Education Section

For freshers, education goes near the bottom (after projects), not at the top.

B.Tech in Computer Science
XYZ Engineering College, Pune | 2024
CGPA: 8.1/10
Relevant Coursework: Data Structures, DBMS, Computer Networks

Include CGPA only if it's 7.0 or above. Below that, simply omit it.

Don't include your 10th or 12th marks unless you're a very recent fresher (graduated in the last year) and your score is above 85%.

The One-Page Rule

As a fresher with no experience: one page, always.

If you can't fill one page, that's fine — a 3/4-full page is better than a padded 2-pager.

If you're overflowing past one page, cut in this order:

Remove the weakest project
Reduce bullets to 2 per project
Remove certifications below the top 3
Tighten margins to 0.5"

ATS: Why Format Matters Even for Freshers

Even as a fresher, your resume goes through ATS before a human sees it.

ATS-safe rules:

Single column only
No photos, skill bars, or graphics
Standard section headings ("Projects" not "Things I Built")
Keywords from the job description in your skills + project bullets

Build Your Fresher Resume Free

ResumeOrbitz has free templates designed specifically for freshers with no work experience — the section order is already optimized (Projects before Education), single-column, ATS-safe.

Free to use, free to download as PDF. Takes 15 minutes.

If you're stuck on a specific section — summary, projects, or skills — drop a comment and I'll help you write it.

Originally published at https://resumeorbitz.com/blog/how-to-write-resume-with-no-experience

Resume vs CV: What's the Actual Difference? (And Which One to Send in India)

MADAN DHOUNDIYAL — Mon, 15 Jun 2026 10:30:37 +0000

"Should I send a resume or a CV?"

Every Indian job seeker has asked this at some point — and gotten confusing answers. HR people use the words interchangeably. Job postings say "send your CV" but mean a 1-page resume. College placement cells say "prepare your CV" and mean something completely different.

Let's settle this once and for all.

The Technical Difference

Resume

Length: 1 page (sometimes 2 for 10+ years experience)
Purpose: Targeted snapshot of your skills for a specific job
Content: Only what's relevant to the role you're applying for
Updated: Every time you apply — tailored to the job description
Used in: Private sector, startups, tech companies, MNCs

CV (Curriculum Vitae)

Length: 2-10+ pages — includes everything
Purpose: Complete academic and professional record
Content: All research, publications, projects, awards, certifications, languages — nothing left out
Updated: Occasionally, as you add new achievements
Used in: Academia, research, government jobs, medical field, international applications

The word "CV" is Latin for "course of life." It's literally your life's work on paper.

What Indians Actually Mean When They Say "CV"

Here's the honest truth: in India, 90% of the time when someone says "send your CV", they mean a resume.

This is a quirk of Indian professional culture. The terms got merged somewhere along the way and now:

Naukri.com calls it a "resume" but most Indians call what they upload a "CV"
Job postings say "attach your CV" but want a 1-2 page document
College placement cells say "prepare your CV" and want a structured 1-pager

Practical rule: Unless you're applying to a university, research institution, government job (UPSC, PSU), or a job outside India — send a resume, not a full CV. Call it whatever you want.

Side-by-Side Comparison

Feature	Resume	CV
Length	1-2 pages	2-10+ pages
Tailored per job?	Yes	No
Includes publications?	No	Yes
Includes all projects?	Only relevant ones	All of them
Includes photo?	Usually no	Sometimes
Used for	Private jobs	Academia/Research
Common in India for	Tech, startups, MNCs	PhD, government, medical

When to Use a CV in India

Use an actual CV (the long one) when applying for:

PhD programs or research fellowships — professors want your complete academic record
UPSC / government jobs — structured format, includes everything
PSU jobs (ONGC, BHEL, NTPC) — they often have their own CV format
Medical / MBBS residency positions — clinical experience, publications matter
Foreign universities — especially European countries that specifically use CVs
Academic positions (assistant professor, lecturer) — publications and conferences required

For everything else — software jobs, product companies, startups, banking, consulting — send a resume.

What a Good Indian Resume Looks Like (2026)

Since 90% of you need a resume, not a CV, here's the structure that works:

NAME
City | Phone | Email | LinkedIn | GitHub

SUMMARY (2-3 lines)
Target role + top skills + one achievement

SKILLS
Organized by category, plain text, no skill bars

EXPERIENCE / PROJECTS
Reverse chronological, 2-4 bullets each
Action verb + what you did + measurable result

EDUCATION
Degree | College | Year | CGPA (if 7.5+)

CERTIFICATIONS (optional)

Length: 1 page for 0-5 years. Strictly.

Format: Single column, no photos, no graphics, no skill bars.

File: Save as PDF. Name it FirstName_LastName_Resume.pdf

The ATS Problem That Both Resume and CV Face

Whether you call it a resume or CV, if it has:

Two columns
Tables
Skill bars (Python ████░)
Text boxes
Photos embedded

...it will get scrambled by ATS software and auto-rejected.

ATS (Applicant Tracking System) is what TCS, Infosys, Swiggy, Razorpay, and most companies use to filter applications automatically. It can't parse fancy layouts — it reads plain structured text only.

The safest approach: single column, plain text sections, standard headings.

Common Questions

Q: Should I put a photo on my Indian resume?
No — unless the job posting specifically asks for it. Photos waste space and can trigger unconscious bias. Most modern Indian companies don't want them.

Q: Should I include my date of birth, father's name, marital status?
No. These are outdated practices leftover from old government job forms. Private companies don't need this info and it wastes valuable space.

Q: My college gave me a "CV format" with DOB, father's name, etc. Should I use it?
For campus placements through your college, follow their format. For applying directly to companies, use a modern resume format without that information.

Q: LinkedIn says "resume" but my Naukri profile says "CV". Does it matter?
Not at all. The platform terminology doesn't matter — the content and format does.

Q: How many pages should my resume be as a fresher?
One. Always one. If it doesn't fit, cut content — not the page limit.

Build the Right Format for Free

If you want to get started with a clean, ATS-friendly resume (not a bloated CV), ResumeOrbitz has 60+ free templates built specifically for Indian job seekers.

All templates are single-column, ATS-safe, and download as PDF for free. No account required to start.

Hope this clears up the resume vs CV confusion for good. If you have a specific situation — applying abroad, government job, academic position — drop it in the comments and I'll tell you exactly which format to use.

Originally published at https://resumeorbitz.com/blog/resume-vs-cv-difference

Software Engineer Resume Tips That Actually Work in 2026 (With Real Examples)

MADAN DHOUNDIYAL — Sun, 14 Jun 2026 09:31:25 +0000

I've reviewed a lot of software engineer resumes — as a developer who's been on both sides of the hiring table, and as someone who built a resume tool and talked to recruiters while doing it.

Here's what actually separates resumes that get callbacks from ones that get ignored.

The #1 Problem: Engineer Resumes Are Too Vague

Engineers tend to write resumes like internal documentation. Accurate, but context-free.

❌ "Developed microservices using Spring Boot"

This tells a recruiter nothing. Every backend dev on the planet has done this.

✅ "Decomposed a monolithic billing system into 6 Spring Boot microservices, reducing average deployment time from 45 minutes to 8 minutes and enabling independent scaling of payment processing"

That's specific. That has a before/after. That tells a story a hiring manager can repeat to their team.

The formula: What you built + the constraint or problem + the measurable outcome.

Structure: What Order Should Sections Go In?

For software engineers with 0-3 years experience:

1. Header (name, contact, GitHub, LinkedIn, portfolio)
2. Summary (2-3 lines, role-specific)
3. Skills (organized by category)
4. Experience / Projects
5. Education
6. Certifications (optional)

For 3+ years experience:

1. Header
2. Summary
3. Experience (this moves up)
4. Skills
5. Education

The Summary Section Most Engineers Skip

A good summary does 3 things in 2-3 lines:

States your specialty and level
Mentions 2-3 specific technologies
Includes one concrete achievement

Example for a mid-level backend engineer:

"Backend engineer with 3 years building high-throughput distributed systems in Go and Python. Designed APIs serving 2M+ daily requests at Razorpay. Strong background in PostgreSQL query optimization and Kubernetes orchestration."

Example for a fresher:

"CS graduate with hands-on experience in React and Node.js. Shipped 3 full-stack projects including a real-time chat app with WebSockets. Seeking a junior frontend role where I can build clean, performant UIs."

How to Write Experience Bullets

Use Action + Result:

"Refactored the search indexing pipeline (Elasticsearch) to support partial matching, reducing failed search queries by 73% and improving user retention in the search flow"
"Led migration of legacy MySQL stored procedures to a service layer in Node.js, enabling proper unit testing and cutting release cycle from 2 weeks to 3 days"

Strong verbs for engineers:

Built, Designed, Implemented — for new things
Optimized, Reduced, Improved — for performance work
Led, Architected, Mentored — for senior/lead roles
Shipped, Launched, Released — for product impact

Never start with: "Responsible for", "Helped with", "Assisted in"

Skills Section: Include vs Drop

Include:

Languages you'd be comfortable being interviewed in
Frameworks you've used in a real project
Tools you use daily (Git, Docker, Postman)
Cloud platforms with specific services ("AWS: EC2, RDS, Lambda, S3")

Drop:

"Microsoft Office"
Skill bars (Python ████░) — ATS can't read them
Anything you'd be uncomfortable answering questions about

Organize by category:

Languages: Go, Python, JavaScript, SQL
Frameworks: Gin, FastAPI, React, Express
Databases: PostgreSQL, Redis, Elasticsearch
Infra: Docker, Kubernetes, AWS, Terraform
Tools: Git, GitHub Actions, Datadog, Postman

ATS: The Invisible Filter

Before a human sees your resume, ATS software parses, scores, and filters it automatically.

ATS-safe rules:

Single column layout only
Standard section headings ("Experience" not "My Journey")
No tables, text boxes, or graphics
Mirror keywords from the job description exactly

You can check your ATS score at ResumeOrbitz's free ATS checker — paste any job description and see your match percentage.

One-Page vs Two-Page

0-5 years: One page, no exceptions
5-10 years: One page preferred, two acceptable
10+ years: Two pages acceptable

If struggling to fit on one page: cut old jobs, reduce to 2-3 bullets per role, tighten margins to 0.5".

Build Your Resume Free

ResumeOrbitz has free ATS-friendly templates for software engineers — single column, clean, with an AI bullet generator to help you write strong impact statements. Free to use, free to download.

Drop a comment if you want specific feedback on your resume structure.

Originally published at https://resumeorbitz.com/blog/software-engineer-resume-tips

I Used AI to Write My Resume Bullet Points — Here's What Happened

MADAN DHOUNDIYAL — Sun, 14 Jun 2026 08:34:56 +0000

Writing resume bullet points is the most painful part of the whole process.

You know what you did at your job or in your project. But translating it into crisp, ATS-optimized, recruiter-friendly language? That's where most people get stuck for hours.

I decided to test using AI to write them — and the results were better than I expected.

The Problem With Resume Bullet Points

Most people write bullet points like this:

Worked on the frontend
Responsible for testing
Helped with deployment

This is weak for two reasons:

It describes tasks, not outcomes
It uses passive, generic language that means nothing to a recruiter

Strong bullet points follow this formula:

[Action verb] + [What you did] + [Measurable result]

Example:

❌ "Worked on the frontend"
✅ "Built responsive UI components in React, reducing page load time by 30% and improving mobile session duration by 2x"

The problem: coming up with that second version yourself, for every single bullet, is exhausting.

What AI Does Well

I tested AI bullet generation with a simple prompt:

"I worked on a React dashboard for a logistics company. I built charts, tables, and filters. The dashboard helped managers track 500+ deliveries per day. Write 3 resume bullet points."

The output:

Built an interactive logistics dashboard using React and Chart.js, enabling real-time tracking of 500+ daily deliveries for operations managers
Implemented dynamic filtering and sorting for delivery data tables, reducing manual report generation time by 60%
Optimized component rendering with React.memo and lazy loading, cutting initial page load from 4.2s to 1.8s

All three are strong. All three have numbers. All three use action verbs. That took 10 seconds.

The Catch: You Need to Edit, Not Just Accept

AI bullet points are a strong starting point, not a final answer.

Three things to always check:

1. Are the numbers accurate?
If the AI invented "60% time reduction" and you have no data to back it up, change it to something you can verify or estimate.

2. Does it match the job description?
If you're applying for a role that mentions "real-time data" or "dashboard analytics", make sure those exact terms appear in your bullet.

3. Does it sound like you?
AI output can feel generic. Add one specific detail only you would know — the actual tech version, the real company context, a constraint you worked around.

The AI Resume Builder Workflow That Actually Works

Here's the exact process I use:

Step 1: Brain dump
For each role or project, write 5-10 raw notes:

What did I build?
What tech did I use?
How many users / how much data / what scale?
What problem did it solve?
What would have broken without my work?

Step 2: Feed it to AI
Paste your notes into an AI resume generator. ResumeOrbitz's AI builder does this inline — you describe your role and it generates the bullets directly in your resume.

Step 3: Edit for accuracy and keywords
Take the AI output, verify the numbers, add keywords from the job description, and make it sound like a human wrote it.

Step 4: ATS check
Paste the job description and run an ATS score check. Aim for 70%+ match before applying.

Prompts That Get the Best AI Bullet Points

If you're using any AI tool (ChatGPT, ResumeOrbitz, etc.), these prompts work well:

For developers:

"I built [X] using [tech stack]. It did [what it does] for [how many users/at what scale]. Write 3 resume bullet points using strong action verbs and include metrics."

For freshers with projects:

"This was a college project where I [what you built]. The tech was [stack]. [Any stats: GitHub stars, users, features]. Write 2-3 bullet points for a resume."

For internships:

"During my internship at [company type], I was responsible for [tasks]. The team was [size], the product had [scale if known]. Write 3 bullet points that emphasize impact."

What AI Can't Do (Yet)

It can't know your actual impact numbers — you have to supply those
It can't tailor to a specific job description unless you paste it in
It sometimes invents plausible-sounding but false details
It doesn't know Indian company names, Indian salary norms, or Indian job market context well

This is why tools built specifically for Indian job seekers tend to produce better outputs for this market than generic AI.

My Recommendation

Use AI for the first draft. Always. It's 10x faster than staring at a blank page.

Then edit for:

Accuracy
Keyword matching to the specific job
One human detail per bullet that makes it sound real

If you want to try it, ResumeOrbitz has a free AI resume builder with bullet generation built in — no account needed to start, no paywall for the download.

What's your experience with AI-generated resume content? Do you use it as a starting point or avoid it entirely? Drop a comment below.

Originally published at https://resumeorbitz.com/ai-resume-builder

Best Free Resume Builder for Freshers in India 2026 (No Paywall, No BS)

MADAN DHOUNDIYAL — Sun, 14 Jun 2026 08:23:23 +0000

Every time I searched for a free resume builder in India, I'd find the same thing: a tool that lets you build 80% of your resume for free, then locks the download behind a ₹799/month paywall.

I got tired of it. So I built one that's actually free.

But before I talk about that — here's a guide on what actually matters when building a resume as a fresher.

What Freshers Get Wrong About Resume Building

Mistake 1: Using fancy templates with photos and columns

Every "cool" template with two columns, a profile photo sidebar, and colorful skill bars is an ATS disaster.

ATS (Applicant Tracking System) — the software that filters resumes at TCS, Infosys, and most startups — can't parse columns and tables. Your resume gets scrambled, your keywords get missed, you get rejected.

Fresher rule: single column, no photo, no graphics.

Mistake 2: Starting with "Objective: To work in a challenging environment..."

This says nothing. Every recruiter skips it automatically.

Replace it with a 2-line Professional Summary that targets the specific role:

"Computer Science graduate with hands-on experience in React and Node.js. Built 3 deployed projects including an e-commerce platform with 500+ users. Seeking a junior frontend developer role."

That's specific, that has numbers, that tells a story.

Mistake 3: Listing responsibilities instead of outcomes

❌ "Worked on the backend of the project"
✅ "Built REST APIs using Node.js + Express, reducing data fetch time by 35%"

If you're a fresher with no work experience, apply this to your projects instead:

❌ "Made a weather app"
✅ "Built a weather dashboard using OpenWeatherMap API with real-time updates, used by 200+ people in my college"

The Ideal Fresher Resume Structure

[NAME — in large text]
[City, India] | [Phone] | [Email] | [LinkedIn] | [GitHub]

PROFESSIONAL SUMMARY
2 sentences. Role + your top skills + one achievement.

SKILLS
Languages: Python, JavaScript, C++
Frameworks: React, Node.js, Django
Databases: MySQL, MongoDB
Tools: Git, VS Code, Postman

PROJECTS (most important section for freshers)
Project Name | [Live Link] | [GitHub]
• What it does in one line
• Tech stack used
• One measurable outcome (users, performance, scale)

EDUCATION
B.Tech Computer Science | XYZ College | 2024
CGPA: 8.2 (include only if 7.5+)

CERTIFICATIONS (optional but helpful)
AWS Cloud Practitioner | Coursera Python | etc.

One Page or Two?

Always one page as a fresher. No exceptions.

Recruiters spend 6-10 seconds on a resume at first glance. They won't scroll to page 2. Put everything that matters on page 1 — if it doesn't fit, cut the less important stuff, not the page limit.

What to Do If You Have Zero Projects

Build one this weekend:

Clone a simple app from GitHub and add one feature
API project — pick any public API (Spotify, OpenAI, NASA) and build something with it
Automation script — write a Python script that automates something boring (rename files, scrape a table, send a daily email)

Document it on GitHub with a good README and deploy it. One real project is enough to start applying.

Which Resume Builder Should You Use?

Here's my honest take on the main options:

Tool	Free?	ATS-Safe?	Indian context?
Canva	Templates free, download ₹599/mo	No (graphics-heavy)	No
Zety	Paid	Yes	No
Resume.io	Paid	Yes	No
Novoresume	Paid	Partially	No
ResumeOrbitz	100% free	Yes	Yes

I built ResumeOrbitz for Indian freshers specifically:

60+ ATS-safe templates
AI bullet point generator (helps when you don't know what to write)
ATS score checker — paste any job description, see your match percentage
PDF + DOCX download — completely free, no card required

Your Resume Checklist Before Applying

[ ] Single column layout
[ ] No photo (unless specifically asked)
[ ] Professional summary (not objective)
[ ] Skills section near the top
[ ] Projects with live links and measurable outcomes
[ ] Action verbs: Built, Designed, Implemented, Reduced, Increased
[ ] No spelling errors (use Grammarly or just paste in Google Docs)
[ ] Saved as PDF (not .docx unless they ask)
[ ] File named: FirstName_LastName_Resume.pdf
[ ] One page

Job hunting is a numbers game but also a quality game. A well-structured resume that passes ATS gets you in the door — after that, it's all about your skills and how you present them.

If you want to build or improve your resume right now, try ResumeOrbitz — it's free, it's built for India, and it'll take you 15 minutes to have something solid.

Good luck out there. Feel free to share your resume in the comments if you want quick feedback.

Originally published at https://resumeorbitz.com/resume-builder-for-freshers

Why 75% of Developer Resumes Are Rejected Before a Human Reads Them (ATS Explained)

MADAN DHOUNDIYAL — Sun, 14 Jun 2026 08:18:12 +0000

You spent hours perfecting your resume. You applied to 30 companies. You heard back from none.

Here's what's actually happening: your resume never reached a human.

What Is ATS?

ATS stands for Applicant Tracking System. It's software that companies use to automatically filter, rank, and manage job applications before a recruiter ever opens a single resume.

Companies using ATS include: TCS, Infosys, Wipro, Swiggy, Razorpay, CRED, and virtually every company that gets more than 20 applications per role.

The ATS scans your resume for specific keywords, checks the formatting for parseability, and scores you against the job description. If your score is below their threshold — your resume goes into the rejected pile automatically.

The 5 Most Common Ways Developers Fail ATS

1. Multi-column layouts

Your beautifully designed two-column resume with a sidebar for skills? ATS reads it left-to-right across the page, mixing your sidebar text with your main content. It becomes unreadable garbage.

Fix: Single column only.

2. Putting skills in a table

Same problem. Tables confuse most ATS parsers. Your "Python | Django | PostgreSQL" table becomes "PythonDjangoPostgreSQL" or nothing at all.

Fix: List skills as comma-separated text in a plain Skills section.

3. Using the wrong keyword variations

If the job description says "React.js" and your resume says "ReactJS", some ATS systems won't match them.

This sounds ridiculous, but it's real. Always mirror the exact terminology from the job posting.

Common mismatches:

"Node" vs "Node.js"
"Postgres" vs "PostgreSQL"
"ML" vs "Machine Learning"
"CI/CD" vs "Continuous Integration"

4. Burying skills at the bottom

ATS systems weight content differently based on where it appears. Skills mentioned early (in your summary or first section) score higher than skills buried at the bottom.

Fix: Put a Skills section near the top, right after your summary.

5. Headers with creative names

If you name your sections "My Journey" instead of "Experience" or "Things I Know" instead of "Skills", ATS can't categorize your content.

Fix: Use standard headers: Summary, Skills, Experience, Projects, Education, Certifications.

How to Actually Check Your ATS Score

The best way: paste your resume and a job description into an ATS checker and see your match percentage.

ResumeOrbitz has a free ATS checker — paste any job description and instantly see:

Your keyword match score
Missing keywords
Formatting issues
Specific suggestions to improve

No account required to check.

The ATS-Optimized Resume Structure (Copy This)

[Full Name]
[Phone] | [Email] | [LinkedIn] | [GitHub] | [Portfolio]

SUMMARY
2-3 lines. Use the job title they're hiring for + your top 2-3 skills.

SKILLS
Languages: Python, JavaScript, TypeScript
Frameworks: React, Node.js, FastAPI
Databases: PostgreSQL, MongoDB, Redis
Tools: Git, Docker, AWS, Linux

EXPERIENCE (or PROJECTS for freshers)
Company Name | Role | Month Year – Month Year
• [Action verb] + [what you did] + [measurable result]
• Reduced API response time by 40% by implementing Redis caching
• Built CI/CD pipeline with GitHub Actions, cutting deploy time from 20min to 3min

EDUCATION
Degree, Branch | College Name | Year
CGPA: X.X (include only if above 7.5)

Quick Wins Before You Apply Next

Run your resume through an ATS checker — know your score before submitting
Copy 5-8 keywords from the job description into your resume (only ones that are true)
Switch to a single-column template if you're using a fancy multi-column one
Add a 2-line summary at the top that uses the exact job title they posted
Remove photos, logos, and graphics — they break ATS parsing every time

The frustrating part about ATS is that it filters good candidates unfairly based on formatting mistakes, not actual skill. But once you know the rules, it's very beatable.

Build your ATS-optimized resume for free at ResumeOrbitz — 60+ single-column, ATS-safe templates built specifically for Indian job seekers.

Have you been rejected from roles you know you were qualified for? ATS might be the culprit. Drop a comment — happy to look at your resume structure.

Originally published at https://resumeorbitz.com/free-ats-resume-checker

How to Write a LinkedIn Headline That Gets You Noticed (2026)

MADAN DHOUNDIYAL — Wed, 10 Jun 2026 14:10:02 +0000

Your LinkedIn headline is the most visible text on your profile. It shows in search results, connection requests, and Google.

Most people waste it by just writing their job title. Here is how to make it work for you.

The Formula That Works

[Your Role] | [Key Skill] | [Value/Result] | [Open to X]

Examples

Software Engineer:
Backend Engineer | Java, Spring Boot, AWS | Building APIs that scale to millions | Open to Senior SDE roles

Fresher/Student:
CS Final Year @ Delhi University | React, Node.js | 3 full-stack projects | Seeking SDE-1 roles (July 2026)

Data Analyst:
Data Analyst | Python, SQL, Power BI | Turned raw data into 2Cr cost savings | Open to Analytics roles

Career Switcher:
Transitioning to Data Science | Python, SQL, ML | 4 yrs operations experience | Google Data Analytics certified

What NOT to Write

Just your job title: 'Software Engineer at TCS' - zero personality, no keywords
Vague buzzwords: 'Passionate | Hardworking | Team Player' - says nothing
Walls of text that say absolutely nothing specific

Keywords Are Critical

LinkedIn ranks profiles by keyword match. If 'React Developer' is not in your headline, you won't appear when recruiters search for it.

Use the exact job title from job descriptions you want to apply to.

Quick Checklist

Contains your exact job title keyword
Mentions 2-3 key skills or tech stack
Includes one result or achievement
States availability if job hunting
Uses most of the 220 characters available

Full guide with more examples: https://resumeorbitz.com/blog/how-to-write-linkedin-headline

Build a resume as strong as your LinkedIn - free at ResumeOrbitz

How to Get a Job in India With No Experience (2026 Guide)

MADAN DHOUNDIYAL — Wed, 10 Jun 2026 14:02:11 +0000

Every job posting says '2 years experience required'.

Here is the exact playbook for landing your first job in India with zero experience.

Step 1 - Build Your Resume Around Projects

Projects ARE your experience. Use ResumeOrbitz - free, ATS-optimized, instant PDF.

Step 2 - Get a Certification

Google IT Support Certificate
AWS Cloud Practitioner
HackerRank certifications (free)

Step 3 - Short Internship

Even 1 month unpaid beats 0 experience. Find on Internshala, LinkedIn, AngelList.

Step 4 - Apply in the Right Order

Startups - less competition, faster learning
Mid-size companies
TCS/Infosys via campus drives

Step 5 - Where to Apply

Naukri.com
LinkedIn Jobs
Instahyre
Wellfound

Full guide: https://resumeorbitz.com/blog/how-to-get-job-in-india-no-experience

How to Write a LinkedIn Summary That Gets You Noticed (2026)

MADAN DHOUNDIYAL — Wed, 10 Jun 2026 12:58:12 +0000

Most LinkedIn summaries are blank or generic. Here is how to write one that makes recruiters reach out.

Why It Matters

LinkedIn has 900M+ users. Keywords in your About section help you appear in recruiter searches.

The 4-Part Formula

Hook - who you are in one line
What you do - expertise and tech stack
Best achievement - one win with a number
Call to action - what you are looking for

Example: Software Engineer

Backend engineer who loves building systems that scale. I work with Java, Spring Boot, and AWS. Built APIs handling 5M+ daily requests and reduced costs by 30%. Open to senior backend roles at product companies.

Example: Fresher

Final-year CS student building with React and Node.js. My recent project was used by 300+ students. Looking for SDE-1 roles starting July 2026.

Key Tips

Write in first person
Strong first line (only 2-3 lines show before See more)
Include keywords recruiters search for
Include at least one number
End with a clear call to action

Mistakes to Avoid

Leaving it blank
Using buzzwords like passionate or hardworking
No keywords
Writing in third person

Checklist

Professional headshot
Keyword-rich headline
About section with numbers
10+ relevant skills
Custom LinkedIn URL (linkedin.com/in/yourname)

Build a resume that matches your LinkedIn at https://resumeorbitz.com

Originally published at https://resumeorbitz.com/blog/how-to-write-linkedin-summary