Table of Contents

Why Most Software Engineer Resumes Fail Before a Human Reads Them

The Indian technology job market processes millions of applications every month. At top product companies - Flipkart, Swiggy, PhonePe, Razorpay, Google India, Microsoft Hyderabad - a single job posting may receive thousands of applications within days. At IT services companies like TCS, Infosys, and Wipro, the application volumes are even larger. The screening funnel before a human recruiter sees a resume is aggressive, and most resumes are eliminated at stages the applicant never sees.

Understanding where applications fail is the first step toward building a resume that actually converts into interview calls.

Software Engineer Resume Guide for India: ATS-Friendly Templates, Project Descriptions, Keywords, LinkedIn Optimization & Cover Letter Strategies for Naukri, LinkedIn & Referrals Software Engineer Resume Guide for India — ATS-Friendly Templates, Project Descriptions, Keywords, LinkedIn Optimization and Cover Letter Strategies for Naukri, LinkedIn and Referrals

Stage 1: ATS Parsing Failure

Most companies above a certain hiring volume use an Applicant Tracking System (ATS) to automatically parse, index, and filter applications. Common ATS platforms used in India include Workday, Greenhouse, Lever, iCIMS, SAP SuccessFactors, and proprietary systems at large IT companies. These systems extract text from your resume and score it against criteria derived from the job description.

Resumes that use heavy graphic design (multi-column layouts, tables, text boxes, icons, custom fonts, header/footer sections) frequently fail ATS parsing entirely - the system extracts garbled text or no text at all. A visually beautiful resume that an ATS cannot read is invisible to a recruiter using that ATS. This is the single most common and most preventable reason for application failure.

Stage 2: Keyword Mismatch

ATS systems and recruiters both filter by keywords. If a job description requires “Kubernetes” and your resume says “container orchestration,” an ATS keyword match will not fire. If the job description says “distributed systems” and your resume says “large-scale backend development,” a recruiter scanning for keywords may miss your profile.

Keyword alignment between your resume and the job description is not dishonest - it is the minimum necessary translation of your experience into the language used by the role you are targeting. The skill is real; the vocabulary must match.

Stage 3: Structural Confusion

Recruiters who do review resumes manually spend an average of 6-10 seconds on initial screening. If the most relevant information (current company, role, key technologies, quantified impact) is not immediately visible in those first few seconds, the resume is deprioritised. Poorly structured resumes - where education appears before experience for a senior engineer, or where the skills section is buried at the bottom, or where work experience bullets are vague paragraphs - fail the 6-second scan test.

Stage 4: Content Weakness

Even resumes that survive ATS parsing and pass the 6-second scan may fail in detailed review if the content does not demonstrate impact. Bullet points that describe responsibilities (“worked on the backend API”) rather than achievements (“reduced API response time by 40% by implementing Redis caching, improving checkout conversion by 8%”) do not differentiate the candidate.

This guide addresses all four failure modes systematically.

Resume Structure: The Right Sections in the Right Order

The optimal structure of a software engineer resume in the Indian job market differs slightly depending on experience level, but the core principle is consistent: the most relevant and impressive information appears first.

For Freshers (0-2 years experience)

  1. Header - Name, phone, email, LinkedIn URL, GitHub URL, portfolio URL (if applicable)
  2. Education - Degree, institution, CGPA (if above 7.5), graduation year, relevant coursework (optional)
  3. Skills - Programming languages, frameworks, databases, cloud platforms, tools
  4. Projects - 3-4 significant projects with description, tech stack, and impact
  5. Internships / Work Experience - Any professional experience, even if brief
  6. Certifications - Relevant technical certifications
  7. Achievements / Awards - Competitive programming ratings, hackathon wins, academic distinctions

For freshers, education and projects are the primary differentiation. Most recruiters for fresher roles understand that work experience is limited; they evaluate technical aptitude through projects, CGPA, and college brand.

For Experienced Engineers (2+ years)

  1. Header - Name, phone, email, LinkedIn URL, GitHub URL (optional at senior level)
  2. Summary - 2-3 line professional summary (optional but useful at 5+ years)
  3. Skills - Grouped by category (Languages, Frameworks, Databases, Cloud, Tools)
  4. Work Experience - In reverse chronological order, with impact-driven bullet points
  5. Projects - Only if they meaningfully differentiate from work experience (open source, side projects, publications)
  6. Education - Brief: degree, institution, graduation year (no need for CGPA at senior level)
  7. Certifications - Relevant to the role

For experienced engineers, work experience is the primary evaluation signal. Education moves to the bottom; a senior engineer’s college and CGPA are nearly irrelevant compared to what they built and the impact it had.

The Header: What to Include and What to Skip

The header must contain: full name (largest text on the page), city and state (no full address required for privacy), phone number (Indian mobile), professional email address, LinkedIn profile URL (shortened - linkedin.com/in/yourname), and GitHub URL if your profile has public repositories worth reviewing.

What to skip in the header: passport photograph (creates bias, is not required, and is inappropriate on a professional resume in the tech industry - despite being common in India, it is increasingly being dropped by candidates targeting product companies), date of birth, marital status, father’s name, gender, and religion. These details are legally irrelevant to hiring decisions and can create unconscious bias.

Professional email address means a variation of your name at a common provider (Gmail, Outlook). Avoid email addresses created in college that include birth years, nicknames, numbers, or department codes.

ATS (Applicant Tracking System) Optimisation: Getting Past the Bots

Format Rules for ATS Compatibility

Use a single-column layout. Multi-column layouts (two columns side by side, sidebar layouts popular in visual resume templates) are parsed incorrectly by most ATS systems. Text in the right column may be read before the left, creating incoherent parsed output. Use a single-column format throughout.

Avoid tables and text boxes. Text inside HTML/Word tables and text boxes is frequently skipped by ATS parsers. All your content should be in the main body of the document as standard paragraph and list text.

Use standard section headings. ATS systems are trained to recognise section titles like “Work Experience,” “Education,” “Skills,” “Projects,” and “Certifications.” Creative headings like “My Journey,” “What I’ve Built,” and “Toolkit” may not be recognised, and the content under them may be miscategorised or ignored.

Use standard bullet characters. Simple round bullets (•) or hyphens (-) are reliably parsed. Custom bullet characters (checkmarks, arrows, diamond symbols) from the Symbol character set may be parsed as garbled text.

Save and submit as PDF. PDF preserves formatting across all platforms and operating systems. Word documents (.docx) can reflow differently on different Microsoft Office versions, potentially breaking your formatting. PDFs are reliably rendered identically everywhere. The exception: some ATS systems explicitly ask for .docx format. If the application page says “.docx required,” submit .docx.

Use standard fonts. Arial, Calibri, Garamond, Georgia, Times New Roman, and Helvetica are universally supported. Avoid decorative fonts, script fonts, or fonts that may not be embedded correctly in PDFs.

Avoid headers and footers. Content placed in Word/Google Docs header and footer areas (page numbers, your name repeated on page 2) is frequently skipped by ATS parsers. Put your name and contact information in the main body on page 1 only.

No images, icons, or graphics. Profile photos, skill rating bars, social media icons, and decorative graphics are either ignored or parsed as garbled text by ATS systems. Remove all visual elements.

Keyword Strategy

The foundation of ATS keyword strategy is the job description. For every application, read the job description carefully and identify:

  • Technology keywords: Specific languages, frameworks, databases, tools, and platforms mentioned (Java, Spring Boot, PostgreSQL, Kubernetes, AWS, React, Kafka, etc.)
  • Role-specific keywords: System design, microservices, CI/CD, REST APIs, distributed systems, high-availability, scalability, low-latency
  • Soft skill keywords: Leadership, collaboration, cross-functional, mentorship (mentioned in JD requirements sections)
  • Degree and certification keywords: B.Tech, B.E., Computer Science, AWS Certified, Oracle Certified

Check your resume for each of these keywords. If a technology you genuinely have experience with appears in the JD but not in your resume (perhaps you used a different term), add it. If the JD says “TypeScript” and your resume only says “JavaScript,” add TypeScript explicitly if you have used it.

Do not keyword-stuff - adding skills you do not have creates problems at the interview stage and is straightforwardly dishonest. The goal is complete and accurate representation of genuine skills in the vocabulary used by the target role.

ATS Keyword Density and Placement

Keywords are weighted more heavily when they appear in the skills section and work experience section than in project descriptions. The skills section is typically parsed first and scored heavily. Your work experience bullets reinforce keyword signals with context and usage.

A keyword mentioned once may not trigger a match. Keywords that appear in both your skills section and your work experience descriptions are more likely to result in a match. Do not force repetition unnaturally, but do ensure that your primary technical stack appears in both sections.

Writing High-Impact Bullet Points: The XYZ Formula

The most impactful change most software engineers can make to their resume is rewriting their work experience bullets from responsibility descriptions to achievement statements.

The XYZ Formula

Google’s recruiting team has publicly described a formula for strong resume bullets: “Accomplished X as measured by Y, by doing Z.”

  • X = The achievement or outcome
  • Y = The metric that makes the achievement concrete and credible
  • Z = The specific actions, technologies, or decisions that produced the outcome

This formula forces three disciplines simultaneously: stating what you achieved (not just what you did), quantifying it (making it concrete), and explaining how (demonstrating technical competence).

Transforming Weak Bullets into Strong Ones

Weak: “Worked on optimising database queries.” Strong: “Reduced average query response time by 65% (from 800ms to 280ms) by adding composite indexes and rewriting N+1 queries using batch fetching, reducing peak database CPU by 40%.”

Weak: “Developed microservices for the payment module.” Strong: “Designed and implemented 3 payment microservices (checkout, refund, reconciliation) handling Rs 80 crore in monthly transaction volume, achieving 99.95% uptime over 18 months.”

Weak: “Built a REST API for the mobile app.” Strong: “Built a REST API serving 500,000 daily active mobile users with p99 latency under 200ms, using Spring Boot and Redis caching to handle traffic spikes of 3x baseline during sale events.”

Weak: “Worked with the team on code reviews and mentoring.” Strong: “Mentored 3 junior engineers, conducting weekly code reviews that reduced post-deploy defect rate by 30% over two quarters.”

Weak: “Improved CI/CD pipeline.” Strong: “Reduced deployment pipeline runtime from 45 minutes to 12 minutes by parallelising test stages and containerising build agents, enabling the team to ship 3x more frequently.”

When You Do Not Have Metrics

Not every bullet can be quantified with a specific number. When you genuinely do not have a metric, use relative scale indicators or scope descriptors:

  • “Serving X million users” (if you know the product’s user base)
  • “Processing Y transactions per day” (if this is public knowledge or you can estimate)
  • “Reduced deployment time significantly” is weak; “Reduced deployment time by approximately 60%” based on your observation is better even without an exact figure
  • “One of 3 engineers responsible for the core payment service” establishes scope without a metric

Avoid making up metrics. However, using reasonable estimates based on your knowledge (your product has 10 million downloads - you can infer scale; your API handles checkout for a company with public GMV numbers) is appropriate. Phrase estimated metrics as approximate: “approximately” or “over X” rather than false precision.

Action Verb Vocabulary

Begin every bullet with a strong, specific action verb. Avoid: “worked on,” “helped with,” “was responsible for,” “assisted with.” Use:

Design and Architecture: Architected, Designed, Engineered, Modelled, Planned, Defined

Development: Implemented, Built, Developed, Wrote, Created, Coded

Optimisation: Optimised, Reduced, Improved, Accelerated, Streamlined, Refactored

Leadership: Led, Managed, Mentored, Coached, Directed, Guided, Coordinated

Delivery and Operations: Deployed, Launched, Shipped, Released, Automated, Migrated

Analysis: Analysed, Investigated, Profiled, Benchmarked, Evaluated, Diagnosed

The Skills Section: What to List and How to Organise It

The skills section is the most directly keyword-matched section of a software engineer’s resume and deserves careful organisation.

Grouping Skills by Category

Group your skills into clear categories rather than listing everything in a single comma-separated block. Recruiters and ATS systems both benefit from categorical organisation.

Recommended categories:

  • Languages: Python, Java, TypeScript, Go, Kotlin, SQL, Bash
  • Frameworks and Libraries: Spring Boot, FastAPI, React, Node.js, Django, gRPC
  • Databases: PostgreSQL, MySQL, MongoDB, Redis, Cassandra, Elasticsearch
  • Cloud and Infrastructure: AWS (EC2, S3, Lambda, RDS, SQS), GCP, Docker, Kubernetes, Terraform
  • Tools and Platforms: Git, GitHub Actions, Jenkins, Datadog, Grafana, Jira, Confluence
  • Concepts: Microservices, System Design, REST APIs, Event-Driven Architecture, CI/CD

What Not to Include in the Skills Section

Basic tools everyone knows: Microsoft Word, Excel, PowerPoint, Google Docs, email clients. Listing these on a software engineering resume signals either inexperience or padding.

Soft skills: “Communication,” “Teamwork,” “Problem Solving,” “Quick Learner.” These belong in bullet points as demonstrated behaviours, not as listed skills. “Strong communicator” is an unsubstantiated claim; “Led weekly architectural decision meetings with 8 engineers across 3 teams” is evidence.

Skills you only encountered once: If you used a technology in a tutorial or touched it in a single 2-week project, it is not yet a genuine skill. Listing it invites interview questions you cannot answer confidently. Include skills you are genuinely prepared to discuss and demonstrate.

Outdated skills: Very old technologies that have no relevance to your target role. Listing technologies from a decade ago as primary skills signals that your skills may not be current.

Proficiency Levels: To Indicate or Not

Many resume templates include proficiency levels (beginner, intermediate, expert) displayed as stars, progress bars, or text labels. Avoid these for two reasons: first, visual indicators are stripped by ATS systems; second, proficiency is subjective and relative - “expert” means something very different to different people. Let your work experience bullets demonstrate proficiency through actual usage and outcomes, which is more credible than a self-assigned label.

Ordering Within the Skills Section

List your most relevant and strongest skills first within each category. Technologies most likely to appear in job descriptions for your target role should be prominent. If you are targeting backend engineering roles: your primary backend language (Java, Python, Go) first, then the framework, then the database. Do not alphabetise - importance and relevance should drive order.

Projects Section: The Most Underutilised Resume Asset

The projects section is the highest-value section on a fresher’s resume and remains relevant for experienced engineers who have built significant personal or open-source projects. Most candidates underinvest in this section, providing bare-bones descriptions that waste the opportunity to demonstrate technical depth.

What Makes a Strong Project Entry

A strong project entry includes: the project name (and a live URL or GitHub link if available), the tech stack used, a 2-3 line description of what the project does and what problem it solves, and 2-3 bullet points describing the technically interesting decisions, scale achieved, and outcomes.

Weak project entry:

URL Shortener | Python, Flask, MySQL | GitHub Link
- Built a URL shortener web application

Strong project entry:

ScaleURL - Distributed URL Shortener | Python, FastAPI, Redis, PostgreSQL, Docker | github.com/yourname/scaleurl
- Designed and built a URL shortening service capable of handling 10,000 redirects/minute using FastAPI 
  for the API layer and Redis for sub-millisecond redirect lookups.
- Implemented Base62 encoding for short code generation and a consistent hash ring for distributed 
  caching across 3 Redis nodes, eliminating single-cache-node bottleneck.
- Containerised with Docker Compose; deployed on AWS EC2 with a PostgreSQL RDS instance for persistent 
  URL storage and TTL-based expiry.

The strong entry demonstrates: awareness of scale, specific architectural decisions, knowledge of distributed caching, deployment experience, and database design - all from a single project description.

Choosing Which Projects to Include

Prioritise projects with:

  • Technical depth - they involved non-trivial architecture, data structures, algorithms, or distributed systems decisions
  • Real usage - live applications used by real users are far more credible than dead-end tutorials
  • Measurable scale - any project with usage data (downloads, registered users, API requests per day) should highlight that data
  • Relevance to target role - a backend engineering project is more relevant for a backend role than a mobile app project

Deprioritise:

  • Pure tutorial-followthrough projects (building a to-do app following a YouTube tutorial)
  • College assignment projects with no original design decisions
  • Projects built in a team where your specific contribution was minimal

Open-Source Contributions

Contributions to well-known open-source projects are among the most credible signals on a software engineer’s resume. A merged pull request to a major open-source project (a bug fix in a widely-used library, a feature in a popular tool) demonstrates: code quality sufficient to pass maintainer review, ability to navigate an unfamiliar codebase, communication skills to collaborate with maintainers, and genuine technical interest beyond the job.

If you have open-source contributions, describe them as you would work experience: “Contributed a query optimisation patch to [Project] (GitHub: X stars), reducing ORM join query time by 30% for nested relation fetches; PR reviewed and merged by project maintainers.”

Fresher-Specific Project Strategy

If you are a fresher without strong project experience, the optimal strategy is to build 2-3 high-quality projects specifically designed to fill your resume gaps before applying, rather than applying with a thin project section. Invest 4-6 weeks building projects that:

  • Are full-stack (front end + back end + database + deployment) to demonstrate breadth
  • Are deployed and publicly accessible (on Heroku, Railway, Vercel, or AWS Free Tier)
  • Include a README with architecture overview, setup instructions, and screenshots
  • Involve at least one genuinely interesting technical problem (rate limiting, caching, real-time updates, search)

Two strong projects beat six tutorial-grade projects every time.

Work Experience for Freshers: Making the Most of Internships

Internship experience is the most credible professional signal available to freshers. Even a 2-month internship at a small company is more valuable than nothing, if described well. The challenge for many freshers is that internship work was narrowly scoped - they were assigned specific tasks, worked under close supervision, and may not have a clear sense of the measurable impact of their contributions.

Reconstructing Impact from Internship Work

Work backward from what you know. If you built a feature: Who used it? How often? If you fixed a bug: How frequent was the bug? How many users were affected? If you optimised something: What were the before and after metrics? If you wrote tests: What was the test coverage improvement?

Talk to your manager or teammates if you are still in touch. Recruiters are not going to fact-check every metric on a fresher’s resume, but the metrics must be plausible and, ideally, based on something real.

If you genuinely cannot quantify impact, describe scope and context: “Implemented the password reset feature for a B2B SaaS product serving 200+ enterprise clients.” The product context (B2B SaaS, enterprise clients) provides scale even without a specific number.

Structuring an Internship Entry

Software Development Intern | CompanyName, City | Month Year - Month Year
- Developed a data export module in Python that allowed clients to download filtered 
  transaction reports in CSV and Excel formats, reducing client support tickets 
  related to manual data extraction by an estimated 40%.
- Wrote unit tests for 3 core API endpoints using PyTest, increasing test coverage 
  from 45% to 72% for the orders module.
- Integrated a third-party SMS verification API (Twilio) for OTP-based login, 
  replacing the email-only verification flow used by 8,000 registered users.

Note the specific action verbs, the specific technologies named, and the combination of scope description and estimated impact where exact metrics are unavailable.

Including Academic Projects and Coursework

For freshers with limited internship experience, major academic projects (final year project, 6-month project, research project) are treated like work experience. Describe them with the same structure:

  • What the project was and what problem it solved
  • Your specific role and contribution (especially if it was a team project)
  • Technologies used
  • Measurable outcomes (marks, faculty commendation, external recognition if any)

Competitive programming achievements belong in a separate section or in the achievements section: “Codeforces rating: 1600 (Specialist),” “LeetCode: 400+ problems solved, top 10% globally,” “Qualified for ICPC Regionals” are all meaningful signals for freshers targeting product companies.

Work Experience for Experienced Engineers: Quantifying Impact

For engineers with 3+ years of experience, the work experience section is the primary evaluation surface. Every bullet must justify its presence by adding a signal that differentiates you from another candidate with a similar title at a similar company.

Structuring Multi-Year Tenure

If you have been at a company for 3+ years with a promotion, show the progression explicitly:

Senior Software Engineer | CompanyName, Bengaluru | [Month Year] - Present
Software Engineer | CompanyName, Bengaluru | [Month Year] - [Month Year]

This signals career progression without requiring the reader to calculate tenure and infer promotion. The promotion itself is a credibility signal.

Prioritising Bullets by Impact

Most engineers write bullets in the order they remember doing the work, not in the order of impact. Reorder your bullets so the most impactful, most technically interesting, and most quantified achievements appear first. A recruiter who only reads the first 2 bullets of each role should see your best work.

If you have 10 bullets for a role, cut to 5-6. The marginal utility of the 8th bullet is much lower than the cost of diluting the 4 strong ones with 4 weak ones.

Types of Impact to Quantify

Performance improvements: Latency reduction, throughput increase, CPU/memory reduction, query time improvement. Always state the before and after, not just the improvement percentage.

Reliability improvements: Reduction in error rate, improvement in uptime (from X nines to Y nines), reduction in on-call incidents per month.

Development velocity improvements: CI/CD pipeline speed, test coverage improvement, deployment frequency increase, time-to-production reduction.

Business impact: Revenue handled, cost savings (infrastructure optimisation), user growth enabled, feature adoption rate.

Scale achieved: Users served, transactions processed, data volume managed, RPS at peak.

Team and process impact: Engineers mentored, interview cycles conducted, documentation created that reduced onboarding time, incident response processes implemented.

Technical Leadership Signals

For engineers targeting SDE-2 and above, technical leadership signals matter as much as individual coding contributions. Include bullets that demonstrate:

  • Owning a system end-to-end (designed, built, launched, monitored, iterated)
  • Driving architecture decisions (led design review, proposed and got approved a migration from X to Y)
  • Cross-team collaboration (worked with product, data, and infrastructure teams to deliver X)
  • Mentoring (mentored N engineers, conducted code reviews that improved team-wide code quality)
  • Incident response (led resolution of P0 incident affecting X users, implemented fixes and post-mortem action items)

Resume Keywords by Role: SDE, Data Engineer, ML Engineer, DevOps

Different engineering roles have distinct keyword vocabularies. Tailoring your resume’s keyword profile to the specific role you are targeting is essential for both ATS matching and recruiter pattern recognition.

Software Development Engineer (SDE) - Backend Focus

Primary languages: Java, Python, Go, Kotlin, Scala, Node.js, C++

Frameworks: Spring Boot, Spring MVC, FastAPI, Flask, Django, Express.js, gRPC

Databases: PostgreSQL, MySQL, MongoDB, Redis, Cassandra, DynamoDB

Infrastructure: AWS, GCP, Azure, Docker, Kubernetes, Helm, Terraform

Architecture concepts: Microservices, REST APIs, GraphQL, Event-Driven Architecture, Message Queues (Kafka, RabbitMQ, SQS), CQRS, Domain-Driven Design

Key phrases to include: “Distributed systems,” “high-traffic production systems,” “system design,” “scalability,” “low-latency,” “high availability,” “CI/CD,” “observability,” “code review,” “technical design documents”

Software Development Engineer - Frontend Focus

Primary languages: TypeScript, JavaScript

Frameworks and libraries: React, Angular, Vue.js, Next.js, Redux, React Query, Webpack, Vite

Tools and concepts: HTML5, CSS3, SASS, Tailwind CSS, Storybook, Jest, Cypress, Web performance (Core Web Vitals, Lighthouse), Accessibility (WCAG), responsive design, PWA

Backend awareness keywords: REST API integration, GraphQL client, WebSocket, SSO, OAuth

Data Engineer

Languages: Python, SQL, Scala, Java

Data platforms: Apache Spark, Apache Kafka, Apache Airflow, dbt, Apache Hive, Apache Flink

Data warehouses and lakes: Snowflake, BigQuery, Redshift, Delta Lake, Apache Iceberg

Cloud data services: AWS Glue, AWS EMR, Azure Data Factory, GCP Dataflow, GCP Pub/Sub

Key phrases: “ETL/ELT pipelines,” “data lake,” “data warehouse,” “batch processing,” “stream processing,” “data quality,” “data lineage,” “schema design,” “partitioning strategy,” “SLA-adherent pipelines”

Machine Learning Engineer

Languages: Python

ML frameworks: TensorFlow, PyTorch, scikit-learn, XGBoost, LightGBM, Hugging Face Transformers, LangChain

MLOps tools: MLflow, Kubeflow, SageMaker, Vertex AI, DVC, Weights and Biases, BentoML, Seldon

Data tools: Pandas, NumPy, Polars, Apache Spark (MLlib), Feature Store (Feast, Tecton)

Key phrases: “Model training and evaluation,” “feature engineering,” “model deployment,” “A/B testing,” “model monitoring,” “inference latency,” “recommendation systems,” “NLP,” “computer vision,” “LLM fine-tuning,” “RAG (Retrieval Augmented Generation)”

DevOps / Platform Engineer / SRE

Languages: Python, Go, Bash

Infrastructure as Code: Terraform, Pulumi, Ansible, CloudFormation

Container and orchestration: Docker, Kubernetes, Helm, Istio, Linkerd, ArgoCD, Flux

CI/CD: GitHub Actions, Jenkins, GitLab CI, CircleCI, Spinnaker

Monitoring and observability: Prometheus, Grafana, Datadog, PagerDuty, ELK Stack, Jaeger, OpenTelemetry

Cloud: AWS (deep: EKS, RDS, Lambda, VPC, IAM, CloudTrail), GCP, Azure

Key phrases: “Site Reliability Engineering,” “infrastructure automation,” “GitOps,” “incident management,” “SLO/SLA management,” “capacity planning,” “cost optimisation,” “zero-downtime deployment,” “disaster recovery”

Resume Templates and Formatting Rules

The One-Page vs Two-Page Debate

In the Indian tech industry: freshers and engineers with fewer than 5 years of experience should use a one-page resume. Engineers with 5-10 years of experience may use two pages if the second page adds genuine value (not padding). Engineers with 10+ years of experience can use two pages, and sometimes need to.

The one-page constraint is not arbitrary - it forces prioritisation. Everything on the page must justify its presence. The discipline of cutting to one page forces you to remove weak bullets, redundant descriptions, and irrelevant old experience, making the remaining content stronger.

If you are exceeding one page, cut in this order: oldest work experience (roles more than 10 years back can be a one-liner: “Company Name Role Year-Year”), unnecessary education details (no need to list every course or activity), weak project entries, and verbose bullet points that can be trimmed.

Font and Sizing Rules

  • Body text: 10-11pt. 11pt is preferable for readability; 10pt if you need to fit more content.
  • Section headings: 12-13pt, bold.
  • Your name: 16-20pt, bold.
  • Margins: 0.5 inch to 1 inch on all sides. Narrowing margins too much (below 0.5 inch) creates a claustrophobic layout.
  • Line spacing: 1.0 to 1.15x. Single spacing with consistent padding between sections.

Section Dividers

Use a horizontal line (Word/Google Docs HR element, or a border on a section heading) to visually separate sections. This aids the recruiter’s 6-second scan by making section boundaries immediately apparent. Avoid colour blocks, shading, and gradient elements (ATS-unfriendly and visually distracting).

LaTeX templates (Overleaf): The Jake’s Resume template on Overleaf is the gold standard for software engineering resumes - clean, single-column, ATS-friendly, and used by engineers at Google, Microsoft, and top startups globally. It requires basic LaTeX familiarity but produces the cleanest output. Overleaf is free for public templates.

Google Docs: Google’s own resume templates (File > New > From template > Resumes) include several clean, single-column options. The “Swiss” template is particularly clean and appropriate for tech resumes.

Microsoft Word: The “Simple” and “Modern” resume templates in Word are ATS-compatible, unlike the visually elaborate templates.

What to avoid: Canva resume templates (visually beautiful, ATS-incompatible - text is inside graphics elements), Zety and Resume.io templates (often multi-column with sidebar, poor ATS performance), Kickresume’s more visual templates.

Tailoring Your Resume for Each Application

One of the most impactful and most underused practices is tailoring your resume for each specific job application. This does not mean rewriting the entire document - it means making targeted adjustments to the skills section, the summary (if present), and the ordering of experience bullets to align with each specific role’s requirements.

Tailoring the skills section: If a role specifically mentions Kubernetes and you have Kubernetes experience but it is buried in the middle of your tools list, move it to the top of the tools category for this application. If a role does not mention a technology at all, deprioritise it.

Tailoring bullet order: Within each role, reorder bullets so the ones most relevant to the target role appear first. If you are applying for a data engineering role and your most recent job included both backend development and data pipeline work, lead with the pipeline bullets.

Tailoring your summary: If you have a professional summary, write a brief role-specific variant that references the company’s known focus area or the role’s specific requirements: “Backend engineer with extensive experience in payment systems and financial data pipelines, seeking to bring high-scale Java and Kafka expertise to [Company]’s core payments infrastructure.”

The time investment for tailoring each application is 10-15 minutes. The improvement in keyword alignment and relevance relevance is significant. For your top 10-15 target companies, always tailor. For tier-C backup applications, a standard version is acceptable.

Resume Versioning

Maintain multiple saved versions of your resume:

  • A “master” version with all experience, all bullets, all projects - longer than one page, used as your source of truth
  • A tailored one-page version for product company applications (backend focus)
  • A tailored one-page version for product company applications (data engineering focus, if applicable)
  • An updated version reflecting the most recent role additions and achievements

Use a consistent naming convention: “FirstName_LastName_Resume_Backend_v3.pdf.” Sending a file named “resume_final_v7_NEW.pdf” or “resume (1).pdf” signals poor attention to detail.

Action Verbs, Phrases to Avoid, and Language Quality

Resume language quality is evaluated, consciously or unconsciously, by every recruiter and hiring manager who reads the document. Weak language diminishes the impression of even strong underlying work; precise, active language amplifies it.

Phrases to Eliminate from Your Resume

“Responsible for…”: This describes a job description, not an achievement. Replace with an action verb that describes what you actually did.

“Worked on…”: Vague and passive. What specifically did you do? Built, implemented, optimised, designed, led, debugged?

“Helped to…”: Implies minimal ownership. If you contributed meaningfully, own the contribution with a direct verb. If you contributed minimally, either find the angle where you can claim ownership or drop the bullet.

“Excellent communication skills”: An unsubstantiated claim. Show evidence: “Presented quarterly architecture decisions to cross-functional stakeholders across 3 teams” demonstrates communication far more credibly than the phrase.

“Good team player”: The weakest phrase in any resume. Every resume claims this; the claim means nothing. Replace with specific collaborative work: “Collaborated with 4 engineers across the mobile and backend teams to deliver the notifications overhaul in an accelerated timeline.”

“Passionate about technology”: Generic filler. Everyone applying for a software engineering job presumably has some interest in technology. Use this space for something that actually differentiates you.

“Fast learner” and “Quick learner”: Universal self-praise that no one can verify from the resume. Replace with evidence: listing a technology you demonstrably mastered quickly and deployed in production is worth far more than the phrase.

Grammar and Consistency Rules

Tense: Current role bullets in present tense (“Design and maintain the core billing service”). Past roles in past tense (“Designed and maintained…”). Be consistent within each role.

Parallelism: Every bullet in a section should follow the same grammatical structure. If the first bullet starts with an action verb, every bullet in that section should start with an action verb - not some starting with verbs and others starting with noun phrases.

Oxford comma: Pick a convention (with or without the comma in lists of three or more) and apply it consistently throughout the document.

Spelling: UK English and US English differ in technology-relevant words (optimise/optimize, colour/color, programme/program). India’s IT industry predominantly uses UK English, but consistency is more important than which variant you choose. Do not mix.

Numbers: Spell out numbers below ten; use numerals for ten and above, and always for metrics (“reduced by 65%,” “serving 3 million users,” “4 junior engineers”).

Naukri.com is the dominant job platform for the Indian IT industry, with millions of active recruiters and job postings. Your Naukri profile is independently indexed and searched by recruiters - it is not just a place to upload your resume, it is a searchable talent database entry that must be optimised independently of your resume.

Profile Completeness Score

Naukri calculates and displays a “Profile Strength” score to recruiters. Profiles with higher completeness scores appear higher in recruiter search results. Ensure 100% profile completion by filling every section: personal details (excluding sensitive personal information you prefer to keep private), current CTC and expected CTC, notice period, work experience with full descriptions, education, skills, certifications, projects, and a professional summary.

Headline (Profile Title)

The headline is the most important field for recruiter discovery. It appears in search results alongside your name and is the primary signal recruiters use to decide whether to open your profile. Your headline should contain: your primary role title, years of experience, and your most valuable technology keywords.

Weak headline: “Software Engineer at XYZ Company”

Strong headline: “Backend Engineer 4 Years Java, Spring Boot, Kafka, AWS Microservices, System Design”

Keep it under 120 characters. Pack the most important keywords into this single field.

Summary Section

The Naukri summary (profile description) is indexed for keyword search. Write a 4-6 sentence professional summary that includes: your role, experience level, primary technology stack, domains you have worked in, and what you are looking for.

Example: “Backend software engineer with 4 years of experience designing and building high-scale microservices in Java (Spring Boot) and Python (FastAPI). Experienced in distributed systems architecture, Kafka-based event streaming, and AWS cloud infrastructure. Have led the development of payment and order management services serving over 2 million daily active users at a Bengaluru-based fintech company. Seeking senior backend engineering roles at product companies in Bengaluru or Hyderabad, open to remote opportunities.”

This summary is keyword-dense, role-specific, includes scale, and signals intent - all of which help recruiters assess fit quickly.

Skills Section on Naukri

Naukri allows you to add skills (listed as tags) which are matched against recruiter search filters. Add all legitimate technical skills - recruiters filter by specific skill tags, and a skill not listed means you are invisible to those searches. Add: all programming languages, all frameworks, all databases, all cloud platforms, DevOps tools, and relevant conceptual skills (system design, microservices).

Naukri also shows “skill endorsements” from connections. While these are less meaningful than LinkedIn endorsements, having them does not hurt and can marginally improve profile credibility.

Desired Job Profile Section

Naukri’s desired profile section is used to match your profile to automated job recommendations and recruiter searches for candidates who are actively looking. Fill it carefully:

  • Desired role: List specific role titles (do not just put “Software Engineer” - be specific: “Backend Engineer,” “Senior SDE,” “Software Development Engineer II”)
  • Preferred locations: List the cities you are willing to work in
  • Expected CTC: Research market rate for your profile and set a realistic expected CTC
  • Notice period: Keep this accurate and up to date

Activity and Visibility Settings

Naukri allows you to control who can see your profile. If you are actively looking: set your profile to “Actively looking” or “Open to offers” - this prioritises your profile in recruiter searches for active candidates. If you are passively looking and do not want your current employer to see your activity: Naukri has a “Confidential” mode that hides your current employer from your profile when viewed by recruiters at your current company.

Update your profile at least once every 2-3 weeks while actively searching. Profile update recency is a ranking factor in recruiter search results - a profile updated recently ranks higher than an identical profile that was last updated months ago.

LinkedIn Profile Optimisation for Indian Software Engineers

LinkedIn is the primary professional network for the Indian tech industry at the mid-to-senior level. Recruiter InMail, hiring manager connections, and employee referrals all flow primarily through LinkedIn. An optimised LinkedIn profile works continuously as a passive job search tool even when you are not actively looking.

The LinkedIn Headline

Your LinkedIn headline follows you everywhere on the platform - in search results, in connection requests, in InMail previews, in post comments. It has 220 characters and must be used strategically.

Do not let LinkedIn default your headline to “Software Engineer at [Company Name]” - this is what 80% of engineers do and it tells a recruiter nothing useful. Instead, write a keyword-rich headline that describes your value:

“Backend Engineer Java · Spring Boot · Kafka · AWS Building scalable fintech systems Open to Senior SDE roles”

This headline: names your role, lists your key technologies (using the dot separator common on LinkedIn), gives context about your domain, and signals that you are open to opportunities.

The About Section

LinkedIn’s About section (formerly Summary) is indexed by LinkedIn’s search algorithm and read by every recruiter who opens your profile. Write 150-300 words in first person (LinkedIn is a more personal platform than a resume) covering:

  • What you do and what you are good at
  • The technologies you work with most
  • The domain or industry you work in
  • What kind of opportunities interest you (without being overly desperate)
  • One or two genuine interests or differentiators (open-source contributions, technical writing, community involvement)

End with a clear call to action: “Feel free to connect if you are working on similar problems or have opportunities in backend engineering at product companies.”

Experience Section

Your LinkedIn experience section should mirror your resume but can be slightly more verbose. LinkedIn allows rich text formatting, and bullet points are displayed better than on a PDF in terms of line length. Expand your bullet points where the character limit permits - LinkedIn experience sections support longer descriptions than a resume.

Critically: ensure your current role’s end date is correctly set as “Present” and your start dates are accurate. Recruiters frequently filter by “currently working at X type of company” and “total experience,” which are derived from your experience section dates.

Skills and Endorsements

LinkedIn allows up to 50 skills in your profile. Add all legitimate technical and professional skills. Pin your top 3 skills - these appear prominently on your profile. The top 3 should be your most important technical skills (Java, Python, System Design - whatever is most relevant to your target roles).

Endorsements from colleagues who can genuinely vouch for the skill add credibility. Reciprocal endorsements (you endorse them, they endorse you) are common and acceptable. Do not endorse skills you have not personally seen the person demonstrate.

Open to Work Settings

LinkedIn’s “Open to Work” feature can be set to visible to all LinkedIn members (green banner on your profile photo) or visible only to recruiters. For most engineers in stable employment who are passively looking: set it to “Recruiters only” to avoid your current employer seeing the signal. For engineers who are actively seeking and unconcerned about employer visibility: the full “Open to Work” frame significantly increases the InMail volume you receive.

LinkedIn Activity: Posts, Comments, and Articles

LinkedIn’s algorithm surfaces active users in feeds and search results. Engineers who post consistently (even once per month) about their technical work, learnings, or opinions on industry trends get significantly more profile views than passive users with identical credentials.

You do not need to be a prolific creator. A post explaining a technical problem you solved recently, a summary of a conference or meetup you attended, or a genuine reaction to a technology announcement takes 20-30 minutes and can generate hundreds of profile views if the content is relevant and specific. Technical content performs significantly better than generic career advice on LinkedIn’s algorithm.

Commenting thoughtfully on posts by engineering leaders at companies you are interested in is also effective - a substantive comment visible to that leader’s followers puts your profile in front of an audience relevant to your job search.

Referral Strategy: How to Get Employee Referrals That Actually Work

Employee referrals are the highest-conversion application channel in the Indian tech industry. Referred candidates are typically fast-tracked through initial screening, receive prioritised scheduling, and in many companies receive an expedited decision timeline. At product companies where most external applications are rejected at the ATS stage, a referral can be the difference between entering the interview process and being screened out.

Building Your Referral Network Before You Need It

The most effective referral strategy begins before you are looking. Engineers who regularly engage with their alumni network, attend meetups and technical events, and maintain professional relationships with former colleagues and managers have a ready referral network when they need it. Attempting to build this network only when you need something is significantly less effective and feels transactional.

Practical habits that build your referral network over time: connect with every colleague on LinkedIn when you join a new company, attend industry events and engineering meetups in your city, contribute to or participate in technical communities (GitHub, Stack Overflow, Discord servers for technologies you use), write and share technical content that others in your field find useful.

Identifying the Right Person to Ask

Not all referrals are equal. A referral from a senior engineer at the team you are targeting is more valuable than a referral from a recruiter or a person who works in a completely different business unit. The closer the referrer is to the hiring decision - the hiring manager, a teammate at the target team, a peer who works on the same technology - the more weight the referral carries.

Use LinkedIn to identify specific people who match these criteria: search for current employees of your target company with titles that suggest they work on relevant teams. Check your existing network for connections at the company. Look for mutual connections who could introduce you.

The Referral Request Message

The worst referral request is a cold message with no context, no personal connection, and an immediate ask: “Hi, please refer me for the Software Engineer role at your company. I have attached my resume.” This template request is sent by thousands of people and is routinely ignored.

An effective referral request:

  1. Establishes context: Remind the person how you know them or how you found them. “We connected at PyCon India / We were in the same batch at [College] / I have been following your posts on distributed systems.”

  2. Shows genuine interest: Mention something specific about the company or role that you genuinely find interesting. “I’ve been following [Company]’s engineering blog posts on their event-driven migration, and it maps closely to the kind of architecture problem I’ve been working on.”

  3. Demonstrates you have done the work: Attach your resume and mention the specific role. Make the referral easy to provide - give them everything they need in a single message.

  4. Respects their time and makes a specific, bounded ask: “If you feel my background is a fit after reviewing my resume, I would really appreciate a referral. I completely understand if it’s not a good match.”

  5. Does not make them responsible for the outcome: A referral is not a job offer. The referrer is introducing you; the hiring process decides the rest.

Sample referral request message:

“Hi [Name], I hope you are doing well. We worked together at [Previous Company] in [Year] on the payments team - I was the backend engineer who built the reconciliation service you helped review.

I came across the Senior Backend Engineer opening at [Company] and it looks like a great fit - the stack (Java, Kafka, distributed systems) is exactly what I have been working on for the past 3 years, and I have been impressed by [Company]’s engineering depth from their recent blog post on their messaging infrastructure.

I’ve attached my resume here. If you feel it’s a fit after looking it over, I’d genuinely appreciate a referral. If it’s not the right time or the role is not a match, no worries at all - I just wanted to reach out to someone I respect who knows the company well.

Best, [Your Name]”

Using Alumni Networks

College alumni networks, particularly at IITs, NITs, BITS, and IIITs, are among the most active referral channels in Indian tech. Most premium institutions have LinkedIn groups, WhatsApp groups, and formal alumni portals. Many alumni are willing to refer fellow alumni for roles at their company, especially if the requester is polite, well-prepared, and their profile is strong.

For alumni outreach: connect via LinkedIn, mention your institution and batch year in your message, and follow the same respectful referral request structure. Alumni networks are a particularly effective channel for reaching employees at companies where you have no direct personal connections.

Cover Letter Frameworks for Indian Tech Jobs

Cover letters are less common in the Indian tech job application process than in Western markets. Most Naukri and LinkedIn applications do not include or require a cover letter. However, in three specific situations, a well-written cover letter significantly improves your application: applying directly to a startup where the founder or hiring manager reviews applications personally, applying via email after a recruiter referral or networking connection, and applying for senior or leadership roles where communication quality is itself an evaluation criterion.

When to Write a Cover Letter

Write a cover letter when: the application explicitly asks for one; you are applying via email or directly to a person (not through an ATS portal); you have a significant career gap, career switch, or unusual background that benefits from brief explanation; or you have a specific personal connection to the company or role that is worth mentioning.

Do not spend hours on a cover letter for an ATS application where there is a cover letter upload field but no indication it will be read. In that case, a brief, well-written 3-paragraph cover letter is sufficient and takes 20 minutes.

The Three-Paragraph Cover Letter Framework

Paragraph 1 - The Hook: Why this company, why this role, and why now. Be specific. “I am applying for the Senior Backend Engineer role at [Company] because [Company’s] approach to [specific technical problem] - particularly the architecture described in your recent engineering blog post on [specific topic] - aligns directly with the distributed systems work I have led over the past 3 years at [Current Company].”

Generic opening lines to avoid: “I am writing to express my interest in the position.” “I believe I would be a great fit.” These openings waste the reader’s time and do not differentiate you.

Paragraph 2 - The Evidence: Your single most relevant achievement, in 3-4 sentences. This is not a summary of your resume; it is the one specific thing in your experience that is most directly relevant to what this company needs. Tell a brief story: what the situation was, what you built or did, and what the impact was.

“At [Current Company], I led the migration of our monolithic payment service to a microservices architecture, reducing per-transaction processing time from 1.2 seconds to 180ms and enabling the team to independently deploy billing and refund functionality. This involved designing the Kafka-based event streaming layer, coordinating the migration plan with 6 engineers across 3 teams, and establishing the architectural standards now used by our entire backend organisation. The resulting system handles [X] transactions daily at 99.97% uptime.”

Paragraph 3 - The Ask: Express genuine enthusiasm and a clear call to action. “I would welcome the opportunity to discuss how my experience with distributed payment systems and Java/Kafka infrastructure could contribute to [Company]’s backend platform. Thank you for your time.”

Email Subject Line for Direct Applications

“Senior Backend Engineer Application - [Your Name] - [3 years, Java/Kafka/AWS]”

A specific, informative subject line is more likely to be opened by a busy engineering manager than a generic “Job Application - [Your Name].”

Follow-Up After Application

For direct applications (not through ATS portals), a follow-up after 5-7 business days is appropriate and professional. A brief follow-up email: “Hi [Name], I wanted to briefly follow up on the Senior Backend Engineer application I sent on [date]. I remain very interested in the role and would welcome the chance to speak. Happy to share more about my work at any time.”

Do not follow up more than once on an application where you have not received a response. Multiple follow-ups are counterproductive and leave a negative impression.

Using Alumni Networks

College alumni networks, particularly at IITs, NITs, BITS, and IIITs, are among the most active referral channels in Indian tech. Most premium institutions have LinkedIn groups, WhatsApp groups, and formal alumni portals. Many alumni are willing to refer fellow alumni for roles at their company, especially if the requester is polite, well-prepared, and their profile is strong.

For alumni outreach: connect via LinkedIn, mention your institution and batch year in your message, and follow the same respectful referral request structure. Alumni networks are a particularly effective channel for reaching employees at companies where you have no direct personal connections.

Tracking Your Referral Outreach

When actively seeking referrals, manage your outreach systematically. Maintain a simple spreadsheet with: the company name, the person you contacted, the date of contact, the role you are targeting, their response, and the follow-up date. Referral outreach is a numbers game within limits - the more relevant connections you activate, the more likely at least some will result in active referrals. Without tracking, you will lose threads, send duplicate messages, and miss follow-up windows.

A reasonable target during an active search: 15-25 personalised referral requests over 3-4 weeks, prioritised to the companies you most want to join. Quality of personalisation matters more than volume - 25 thoughtful, personalised messages outperform 100 copy-paste blasts.

What to Do After You Get a Referral

When a connection agrees to refer you, make the process easy for them. Provide: your resume (PDF), the specific job posting URL, the role title and requisition ID if visible, and a brief note about your most relevant qualification for the role that they can include in their referral submission. Some companies’ referral portals ask the referrer to briefly describe the candidate’s qualifications - giving your referrer this language saves them time and ensures the strongest possible framing.

After your referral has been submitted: send a brief thank-you message. If you receive an interview, let your referrer know out of courtesy. If you get the job, let them know - many companies pay referral bonuses to employees whose referred candidates are hired, and they deserve to know their referral worked.

Understanding the Full Job Search Strategy

A resume is one component of a broader job search strategy. Engineers who treat a job search as a multi-channel effort - combining inbound profile visibility, outbound applications, referrals, and direct recruiter relationships - close offers significantly faster than engineers who rely on a single channel.

The Four Job Search Channels

Channel 1 - Inbound (passive): Your Naukri and LinkedIn profiles work continuously without your active involvement, surfacing you in recruiter searches. Inbound inquiries from recruiters arrive as InMail messages (LinkedIn) and Job Alert matches (Naukri). This channel requires upfront investment (profile optimisation) and then works passively. The quality of inbound leads is highly variable - a well-optimised profile with clear role and location preferences attracts more relevant inbound than a generic one.

Channel 2 - Outbound applications: Applying to specific roles via company career pages, Naukri, and LinkedIn Jobs. The conversion rate from outbound application to interview call is significantly lower than from referral, but the volume of available roles is much higher. Outbound applications are most effective when the application is tailored to each specific role’s keywords and requirements rather than blasted identically to dozens of positions.

Channel 3 - Referrals: As detailed in the referral section. Highest conversion rate of all channels; each referral is a meaningful investment of your network’s social capital. Reserve referral requests for companies genuinely at the top of your preference list.

Channel 4 - Recruiter relationships: Third-party technical recruiters (staffing agencies and boutique tech placement firms) can be valuable, particularly for roles at companies you are not reaching through other channels. Reputable technical recruiters in India include firms specialising in technology placements. The limitation: third-party recruiters are focused on open roles at companies that pay placement fees, which excludes many top product companies that do direct hiring.

Optimising Application Timing

Applications submitted within the first 24-48 hours of a job posting typically receive better screening response than applications submitted later, particularly for roles that close when a sufficient pool of strong candidates is reached. Setting LinkedIn Job Alerts and Naukri Job Alerts for your target roles and companies ensures you see new postings within hours.

For companies you have prioritised, monitor their career pages directly rather than waiting for job boards to aggregate postings. Many companies post roles on their career site days before they appear on aggregator platforms.

Target Company List Strategy

An effective job search is focused rather than diffuse. Identify 15-25 target companies organised into three tiers:

Tier A (5-8 companies): Your dream companies - the places where you would accept an offer immediately if one was forthcoming. These companies receive your deepest research, most personalised applications, and most proactive networking.

Tier B (8-12 companies): Strong companies where you would seriously consider an offer. These get personalised applications and some networking effort.

Tier C (5-8 companies): Backup options you would consider if the higher tiers do not pan out within your timeline. Standard applications, less personalisation.

Working from a prioritised list prevents the paralysis of an open-ended search and ensures your best energy goes toward your most desired opportunities.

Preparing for the Application to Interview Gap

The time between submitting applications and receiving interview calls is 1-4 weeks for most channels (longer if you are relying on inbound only). Use this window productively: resume review and refinement based on what you learn from rejections, technical preparation (DSA, system design, language-specific topics), and research on your target companies (their products, engineering culture, recent engineering blog posts, the specific teams you are targeting).

Do not wait until you have an interview call to start technical preparation. Starting technical prep on the same day as your application outreach ensures you are ready when calls start arriving, rather than scrambling to prepare in the 48 hours before a first round.

After the Resume: Preparing for the Screening Call

The resume gets you the call; the call determines whether you proceed to technical rounds. The typical first touchpoint is a 20-30 minute HR or recruiter screening call, followed by a technical screening (often a 30-45 minute phone screen with a hiring engineer). Understanding what each stage evaluates helps you prepare specifically.

The HR Screening Call

HR screening calls typically cover: confirming your current role, company, and experience; establishing your notice period and expected CTC; a brief description of the role and company; and preliminary culture-fit questions. This is not a technical interview - it is a logistics and motivation check.

Be prepared to: state your notice period clearly (if you are negotiating it, have a clear position before the call), give a specific expected CTC range (not a vague “it depends” - research the market and give a number), articulate in one sentence why you are interested in this company and role, and confirm your location flexibility if relocation is relevant.

The most common HR screening mistake: being vague about expected CTC or notice period. These are not trick questions - they are logistics checks. Having clear, thought-out answers to both saves multiple rounds of back-and-forth and demonstrates that you are a serious candidate who has done basic preparation.

The Technical Phone Screen

A technical phone screen at most product companies involves 1-2 coding problems (LeetCode medium difficulty), sometimes followed by a brief system design or architectural discussion at the SDE-2 level. The screen typically happens on a shared coding platform (CoderPad, HackerRank, Google Docs, or proprietary).

Specific preparations for a good technical phone screen: think aloud from the moment you read the problem, clarify the problem before coding (ask about edge cases and constraints), start with a brute force solution and discuss its complexity before optimising, write clean code with meaningful variable names (not a, b, c), test your solution with examples before declaring it done.

A poor technical phone screen is often not caused by inability to solve the problem - it is caused by silent coding, jumping to code without clarification, or being unable to articulate the time and space complexity of your own solution. Communication quality during the screen is weighted as heavily as the correctness of the solution at most companies.

Building a Technical Portfolio That Supports Your Resume

A technical portfolio is the set of publicly accessible work that supports and extends your resume’s claims. For engineers targeting product companies, a well-maintained GitHub profile and optionally a technical blog or personal website serve as evidence that your resume’s technical claims are genuine.

GitHub Profile Optimisation

A recruiter-facing GitHub profile should have:

A profile README: GitHub allows a pinned README at the top of your profile. Use it to briefly introduce yourself, list your primary skills, and link to your most significant repositories and any deployed projects. Think of it as a one-screen professional profile within GitHub.

Pinned repositories: Pin 4-6 of your best repositories to the top of your profile. Pinned repositories are the first thing a visitor sees. Choose repositories that showcase depth, originality, and technical quality - not tutorial projects.

Active commit history: An active contribution graph (the green squares on your GitHub profile page) signals ongoing technical engagement. Regular commits, even to personal projects or open-source contributions, make your profile visually active.

Repository quality: Each pinned repository should have a clear README with: what the project is, the problem it solves, the architecture overview, setup instructions, a screenshot or demo link if applicable, and the tech stack badges. A repository with no README signals low effort regardless of the quality of the code inside.

Meaningful commit messages: If a recruiter or hiring engineer does browse your code, commit messages like “fixed bug,” “updates,” and “WIP” suggest poor engineering discipline. Meaningful messages (“Add Redis caching for session storage to reduce DB load by ~60%”) tell the story of your technical decisions.

Technical Writing and Blogging

A technical blog with even 3-5 well-written posts demonstrating deep knowledge of a specific topic is a strong differentiating signal, particularly for senior roles. Writing demonstrates communication skills (a critical competency for senior engineers), confirms deep understanding (you can only explain something clearly if you truly understand it), and builds visibility within the technical community.

Platforms for technical writing: Medium (large existing readership), Dev.to (developer-specific community with active engagement), Hashnode (developer blog with custom domain support), and a self-hosted blog. Cross-posting to LinkedIn adds distribution.

Topics that perform well: deep dives into a specific technology decision you made and why (title: “Why we migrated from MongoDB to PostgreSQL and what we learned”), explanations of complex technical concepts in accessible language (“Understanding consistent hashing with a real-world example”), or walkthroughs of open-source contributions you made.

You do not need to write prolifically. Two or three high-quality, deeply technical posts linked from your resume’s GitHub URL or LinkedIn profile are more impressive than a high volume of shallow posts.

Frequently Asked Questions

Q1: Should I include my CGPA on my resume?

Include CGPA if it is 7.5 or higher out of 10. Below 7.5, it is better to omit it entirely - no CGPA listed is a better signal than a below-threshold CGPA that actively harms your screening. For engineers with more than 3 years of experience, CGPA is rarely an evaluation factor and can be omitted regardless of score.

Q2: Is a one-page resume really better for experienced engineers?

For engineers with up to 7-8 years of experience: yes, strongly. For engineers with 10+ years: two pages is acceptable, especially if the second page is genuinely needed for substantive content (not padding). The discipline of one-page forces you to prioritise and produces a sharper document. Most recruiters prefer conciseness.

Q3: Should I include hobbies and interests on my resume?

Only if they are relevant to the role or demonstrate a distinctive quality. “Competitive programming (Codeforces Candidate Master)” is relevant and impressive for a product company application. “Reading books” and “Travelling” add no signal and waste space. If you have a technical hobby (you build hardware projects, you write a technical blog, you contribute to open source in your spare time), include it briefly.

Q4: How often should I update my Naukri and LinkedIn profiles?

During an active job search: every 2-3 weeks, even if the update is minor (add a new skill, edit a bullet). Recency is a ranking factor on both platforms. When not actively searching: update within 2-4 weeks of any significant career event (promotion, new project, new certification, company change).

Q5: Is lying about skills or experience on a resume ever acceptable?

No. Beyond the ethical issue, the practical risks are significant. Technical interviews immediately expose skills you do not have. Background verification at offer stage checks employment history, including dates and titles, with previous employers. Many companies use third-party BGV firms that contact previous employers directly. Misrepresentation discovered during BGV results in offer rescindment, and misrepresentation discovered after joining can result in immediate termination. The Indian tech industry is smaller and more connected than it appears - reputations, positive and negative, travel quickly through referral networks.

Q6: How should I handle a career gap on my resume?

Do not hide a career gap by being vague about dates. Use clear month-year date ranges. A gap of a few months is not concerning; employers understand that job transitions are not always instant. For longer gaps (6+ months), a brief explanation in the resume or cover letter is better than leaving it ambiguous: “Career Break: Family responsibilities / Health recovery / Upskilling (completed [specific courses and projects]).” What you learned or built during the gap is often more relevant than the gap itself.

Q7: Can I use ChatGPT to write my resume?

AI tools can be useful for improving bullet point phrasing, checking grammar, and generating initial drafts of a summary. However, an AI-generated resume without human editing produces generic, imprecise language that sounds similar to thousands of other AI-generated resumes. Specifically: AI cannot supply your actual metrics, your real project outcomes, or your genuine technical decisions - you must provide those inputs. Use AI as an editing assistant, not as the primary author of your professional story.

Q8: What should I do if I have only internship experience but want to target product companies?

Focus aggressively on building 2-3 strong technical projects before applying. Target companies in tier 2 and tier 3 (mid-size product companies) for your first role - breaking into Tier 1 product companies directly from college without an on-campus placement or an extremely strong competitive programming profile is very difficult. A first role at a mid-tier product company followed by strong performance gives you the work experience foundation to move to Tier 1 companies in 2-3 years, with far better compensation leverage than a direct mass recruiter hire.

Q9: How do I explain a switch from a service company to a product company on my resume?

You do not need to explain the switch - the switch is normal, expected, and viewed positively by product company recruiters. What you do need to do is reframe your service company experience in terms that resonate with product company evaluations. Emphasise: the specific technologies you used, the scale of the systems you worked on (number of users, transaction volumes), any product-like engineering decisions you made, and the technical complexity of the problems you solved. Service company experience is not a liability if described with technical specificity and scale context. The liability is describing it in vague, delivery-manager language (“managed client deliverables,” “coordinated with onshore teams”) rather than technical engineering language.

Q10: Is a cover letter expected when applying to Indian product companies?

For most applications through Naukri and LinkedIn job portals: no, a cover letter is not typically expected or read at the initial screening stage. However, when reaching out directly to a hiring manager or HR contact via email, including a brief cover letter (the 3-paragraph framework in this guide) significantly improves response rates. Cover letters are also worth writing for companies where you have a specific personal connection to the culture or technology, because they give you space to articulate that connection in a way a resume cannot.

Q11: How should I list technologies I know from online courses vs professional work on my resume?

Be honest but do not undersell course-based skills. A technology you learned through a quality course and then used in a personal project is a genuine skill, even if it was not used in professional work. The distinction matters in the interview: be prepared to be tested on anything listed in your skills section, regardless of how you learned it. A skill you put in your skills section because you spent two days watching a tutorial and have not touched since is not a skill you should list - it will be exposed in the first 5 minutes of a technical screen.

Q12: What is the best way to handle the “expected CTC” field on Naukri and job application forms?

Research market rate for your profile before filling this field. Use Levels.fyi for MNC companies, AmbitionBox and Glassdoor for Indian companies, and peer conversations for the most current data. Set your expected CTC at the high end of the range you would genuinely accept - it is easier to negotiate down than to negotiate up from a number you have already anchored. Avoid the extremes: setting it too low signals that you are undervaluing yourself (and recruiters sometimes filter out low expected CTCs for senior roles as a proxy for underqualification); setting it at an unrealistic premium relative to your current CTC (more than 100% hike for a lateral move without an exceptional reason) may screen you out of relevant roles.

Q13: How should I prepare my resume differently for a product company vs an IT services company application?

For IT services company applications: emphasise technologies listed in their requirements, client-facing project context (enterprise clients, industry verticals), certifications (many services companies value cloud and vendor certifications heavily), and communication and collaboration skills that indicate delivery capability.

For product company applications: emphasise technical depth, system scale, ownership of features end-to-end, impact metrics, and architecture decisions. Soft skills and delivery process matter less than technical specificity. Remove services-company jargon (“client stakeholder management,” “offshore-onshore coordination”) entirely - these phrases do not translate and consume space that should be used for technical signals.

It is perfectly acceptable - and recommended - to maintain two versions of your resume, optimised for each context, rather than attempting a single document that serves both equally poorly.

Q14: How should I represent a promotion on my resume?

A promotion is a credibility signal that should be made immediately visible. Represent it by listing the two titles under the same company entry, with separate date ranges:

Senior Software Engineer  |  [Month Year] - Present
Software Engineer  |  [Month Year] - [Month Year]
TechCorp, Bengaluru

List 3-4 bullets under each title, with the senior-level bullets reflecting the higher scope and ownership expected at that level (architecture decisions, team leadership, complex features owned end-to-end) and the junior-level bullets reflecting execution and delivery.

If the promotion came with a significant scope increase or a technology change, make that transition visible: “Promoted from Software Engineer to Senior Software Engineer after leading the successful migration of the legacy monolith to a microservices architecture, taking on additional ownership of the platform team’s core API infrastructure.”

Q15: What is the right balance between technical detail and readability on a resume?

The right balance: every technical term must be real and accurate; every metric must be plausible; but the document must be readable by a non-specialist recruiter doing initial screening as well as by a technical engineer in a detailed review. Concretely: lead bullets with the outcome and scale (accessible to a recruiter), then include the specific technology and approach in the second half of the bullet (scannable by the technical reviewer). “Reduced checkout latency by 55% (600ms to 270ms) by implementing Redis-based session caching and query optimisation on the PostgreSQL orders table” is accessible (the outcome is clear upfront) while technically specific (the reviewer knows exactly what was done and how).

A strong resume, an optimised online presence, and a deliberate referral strategy work together as a system. The resume gets you through automated screening; the Naukri and LinkedIn profiles attract inbound interest from recruiters; referrals bypass screening entirely and get you directly into the process. Most engineers invest in only one of these three channels. Engineers who build all three, supplement them with a GitHub portfolio and targeted technical writing, and manage their job search with the same rigour they apply to engineering problems, create a compounding advantage that significantly shortens the time between starting a search and receiving an offer.

All platform features, algorithms, and formatting best practices described in this guide reflect general industry knowledge and community experience. Platform interfaces and ranking algorithms evolve regularly; always check current platform documentation and community resources for the most up-to-date guidance.