engineering · Fresher-friendly
Software Engineer Interview Questions India 2026
Curated Software Engineer interview questions for Indian campus placements and top tech companies — with hiring process guides, topic importance charts, company-wise expectations, common mistakes, and a 30-day preparation roadmap.
Software Engineer Career Roadmap 2026
- Programming Basics
- DSA
- OOPs
- DBMS
- System Design
- Behavioral
- Mock Interviews
- Offer
On this page
Software Engineer Interview Process (2026)
Most Software Engineer loops in India — campus drives and product companies — follow the sequence below. Each stage filters a different signal: aptitude, coding depth, design thinking, or communication.
Step 1 — Application & resume screen
Recruiters scan for relevant projects, DSA practice signals, internship impact, and tech stack alignment. Tailor bullets to measurable outcomes — latency reduced, users served, bugs fixed — not task lists.
Step 2 — Online Assessment (OA)
Timed coding, MCQs on CS fundamentals, and sometimes aptitude. Campus drives (TCS NQT, InfyTQ, Wipro Elite) filter heavily here. Practice under 60–90 minute clocks with arrays, strings, and basic DSA.
Step 3 — Technical Round 1
Live coding on arrays, trees, hashing, or strings plus CS fundamentals — OOPs, DBMS, OS, networking. Explain approach before coding; state time and space complexity; test edge cases aloud.
Step 4 — Technical Round 2
Deeper DSA, language-specific depth, or introductory system design for experienced candidates. Expect follow-ups: optimize further, handle scale, discuss trade-offs, or refactor your solution.
Step 5 — System design (senior / product)
Design APIs, storage, caching, queues, and failure modes for real products — URL shortener, chat, feed, or rate limiter. Entry-level campus loops may skip this; product SDE-2+ loops rarely do.
Step 6 — Behavioral / HR
STAR-format stories on ownership, conflict, deadlines, and learning agility. Company-specific frameworks matter at Amazon (LPs), Microsoft (growth mindset), and service firms (communication + stability).
Step 7 — Offer
Selected candidates receive level, compensation, and joining timeline. India SWE packages range roughly 3.5–8 LPA at mass recruiters to 15–40+ LPA at top product companies for 0–3 YOE — negotiate after level confirmation.
Company-specific loops differ — compare Amazon SDE interviews, Microsoft SDE interviews, and Infosys SWE interviews.
Software Engineer Preparation Roadmap
Step-by-step learning path from programming basics to interview readiness. Do not skip fundamentals — panels test OOPs, DBMS, and OS even when the job title says “full stack” or “backend.”
Drill DSA patterns with our DSA interview hub and algorithms topic questions.
Topic Importance for Software Engineer Interviews
Interview panels do not weight topics equally. The chart below is an illustrative composite of campus OAs, service-company drives, and product company technical rounds across India — use it to order revision, not to skip entire areas.
Illustrative topic importance (technical + behavioral rounds)
Deep-dive by skill area: data structures, system design, OOPs, and operating systems.
Company Comparison — Product vs Service SWE Interviews
Big Tech and campus mass recruiters share the SWE title but not the same bar. Use this table to prioritize prep time before you commit to a single study plan.
| Dimension | Microsoft | Amazon | TCS | |
|---|---|---|---|---|
| Hiring Difficulty | Very High — OA + multi-round DSA + design | High — OA + structured loop | High — LP depth + Bar Raiser | Medium — aptitude-heavy campus OA |
| DSA Depth | Very High — graphs, DP, trees | High — arrays, trees, graphs | High — two live coding rounds | Easy–Medium — arrays, strings |
| System Design | Dedicated onsite round | Common at SDE-2+ | SDE-2+ common | Rare at fresher level |
| Behavioral Weight | Medium — Googleyness | Medium — growth mindset | Very High — 16 LPs | Low–Medium — HR screen |
| Typical Timeline | 6–10 weeks | 4–8 weeks | 4–8 weeks | 2–4 weeks (campus) |
| Package (0–2 YOE) | 25–50+ LPA | 18–35 LPA | 20–40 LPA | 3.5–7 LPA |
Top Mistakes Software Engineer Candidates Make
These patterns cause rejections even when candidates know the right answers on paper. Fix them in mock interviews before your first real loop.
Jumping to code without clarifying
Starting implementation before restating constraints, edge cases, and examples signals poor communication — a top rejection reason even when the final code works.
Fix: Spend 60–90 seconds on problem restatement, 1–2 examples, and approach outline. Ask “Does this match what you expect?” before typing.
Skipping complexity analysis
Many candidates solve the problem but cannot explain time/space complexity or why their approach is optimal. Panels treat this as incomplete mastery.
Fix: Always close with Big-O, walk through loop counts or recursion depth, and mention one optimization trade-off (time vs space).
Neglecting CS fundamentals
Strong LeetCode scores with weak OOPs, DBMS, or OS answers fail service-company and hybrid product loops that mix coding with MCQ-style depth.
Fix: Allocate 30% of prep to fundamentals — normalization, indexing, process vs thread, TCP vs UDP — alongside DSA patterns.
Generic behavioral answers
“We worked as a team” without your specific actions, metrics, or trade-offs fails STAR evaluation at product companies and campus HR rounds alike.
Fix: Prepare 8–10 STAR stories with numbers. Use I not we for actions. End every story with measurable outcome plus one lesson learned.
One-size-fits-all company prep
Studying only hard DP for a TCS NQT or only aptitude for Amazon SDE guarantees mismatch. Company loops weight topics differently.
Fix: Use the company comparison table on this page. Pick 2 target employers and mirror their OA format and round depth for the last 2 weeks.
No timed mock interviews
Reading questions without speaking answers under time pressure leaves communication gaps invisible until the real loop.
Fix: Run at least 4 full mock interviews in your final 14 days — coding narration plus one behavioral round per mock.
30-Day Software Engineer Preparation Roadmap
A focused four-week plan plus final polish days — balanced across DSA, fundamentals, system design, and behavioral prep for typical India hiring loops.
Week 1 (Days 1–7)
DSA foundations
- Arrays, strings, hashing — 25 timed problems
- Two pointers and sliding window patterns
- Binary search variants on sorted data
- Review time/space complexity notation daily
Week 2 (Days 8–14)
Trees, graphs & CS fundamentals
- Trees/BST traversals, BFS/DFS on graphs
- OOPs pillars with one example each
- DBMS: normalization, indexing, transactions
- OS: process vs thread, deadlock, scheduling basics
Week 3 (Days 15–21)
System design & company targeting
- Design URL shortener, chat, or rate limiter on paper
- Networking: TCP vs UDP, HTTP, REST vs gRPC overview
- Complete 2 company-specific OA practice sets
- Polish 6 STAR behavioral stories with metrics
Week 4 (Days 22–28)
Mocks & weak-area repair
- 3 full-loop mock interviews (coding + behavioral)
- Revisit missed patterns from mock feedback
- Resume bullets aligned to story evidence
- Company research for “why us” HR answers
Days 29–30
Final polish
- Light revision — high-frequency problems only
- One timed OA simulation under exam conditions
- Rest and logistics — ID, platform, quiet space
Practice beats passive reading
Run a full Software Engineer mock interview — scored in 5 dimensions
Upload your resume and practice real SWE questions with AI-generated follow-ups. Get rubric-based feedback on communication clarity, technical depth, answer structure, confidence, and relevance — the same signals Indian panels evaluate.
- Resume-aware technical + behavioral questions
- Timed answers with filler-word analysis on voice mode
- Free credits to start — no card required
Related Interview Preparation Guides
Cross-train with role, topic, company, and blog guides — including Android Developer, Java Developer, and company SWE hubs linked below.
Software Engineers Interview Questions
10 curated · DSA & CS fundamentals · Updated 2026- 01
What is the difference between a stack and a queue? Where would you use each?
TechnicalEasyView expert answer & prep guide
Expert answer: A stack follows LIFO, so the last item pushed is the first removed. A queue follows FIFO, so the first item added is the first removed. I use stacks for undo/redo, recursion, and browser back navigation. I use queues for job scheduling, print spooling, and request buffering in APIs. In interviews, I also mention operation costs: push/pop are O(1) for stack, and enqueue/dequeue are O(1) for queue implementations using linked lists or circular arrays.
What interviewers evaluate: Core data-structure fundamentals and your ability to map theory to practical engineering use cases.
Answer strategy: Define LIFO vs FIFO first, then attach one real production scenario for each structure and mention O(1) operations.
Common mistakes: Mixing up ordering semantics, giving only textbook definitions, or skipping where each structure is actually used.
Follow-up questions:
- How would you implement both using arrays?
- When would you choose deque over queue?
- 02
What is the time complexity of binary search and what is its prerequisite?
TechnicalEasyView expert answer & prep guide
Expert answer: Binary search runs in O(log n) time because every comparison removes half of the search space. The mandatory prerequisite is that data must be sorted in the same order you search against. Space is O(1) for iterative implementation and O(log n) for recursive due to call stack. In campus interviews, I also clarify edge cases: duplicate values, not-found result handling, and overflow-safe midpoint calculation using left + (right - left) / 2.
What interviewers evaluate: Algorithmic complexity clarity and whether you understand binary search preconditions and implementation details.
Answer strategy: State O(log n) immediately, mention sorted input requirement, then explain halve-the-range logic with one example.
Common mistakes: Forgetting sorted prerequisite, wrong midpoint arithmetic, or not discussing boundary conditions for duplicates.
Follow-up questions:
- How do you find first occurrence in duplicates?
- What changes for rotated sorted arrays?
- 03
Explain the four pillars of Object-Oriented Programming with one example each.
TechnicalEasyView expert answer & prep guide
Expert answer: The four pillars are encapsulation, inheritance, polymorphism, and abstraction. Encapsulation means keeping data private and exposing controlled methods, like a BankAccount class with deposit/withdraw methods. Inheritance lets a SavingsAccount reuse BankAccount behavior. Polymorphism means calling the same method on different classes, like processPayment() for UPI and Card. Abstraction hides complexity behind interfaces, like a PaymentGateway interface exposing pay() while each provider handles its own implementation details.
What interviewers evaluate: Foundational OOP understanding and your ability to connect concepts with concrete coding examples.
Answer strategy: Name each pillar in order and provide one short production-style class example rather than abstract analogies only.
Common mistakes: Confusing abstraction with encapsulation, or listing pillars without explaining why each matters in design.
Follow-up questions:
- Can you show method overriding vs overloading?
- When is composition better than inheritance?
- 04
What is a deadlock? State the four conditions required for it to occur.
TechnicalMediumView expert answer & prep guide
Expert answer: A deadlock is a state where two or more threads wait forever because each holds a resource the other needs. The four Coffman conditions are mutual exclusion, hold and wait, no preemption, and circular wait. If all four exist together, deadlock is possible. In production Java services, I reduce risk by enforcing lock ordering, minimizing nested locks, and using timed lock acquisition so stuck threads fail fast and trigger alerts instead of hanging indefinitely.
What interviewers evaluate: Concurrency fundamentals and whether you can reason about deadlock causes and practical prevention.
Answer strategy: Define deadlock first, list all four conditions correctly, then add one prevention tactic like lock ordering.
Common mistakes: Missing one Coffman condition, treating deadlock as slowdown only, or giving no prevention approach.
Follow-up questions:
- How do you detect deadlocks in Java?
- What is livelock and how is it different?
- 05
What is the difference between TCP and UDP? When would you choose each?
TechnicalMediumView expert answer & prep guide
Expert answer: TCP is connection-oriented, reliable, and ordered: packets are acknowledged, retransmitted if needed, and delivered in sequence. UDP is connectionless, lower-overhead, and does not guarantee delivery or order. I choose TCP for APIs, payments, and file transfer where correctness matters. I choose UDP for real-time use cases like live voice, gaming updates, or telemetry where occasional packet loss is acceptable but low latency is critical. In interviews, I also mention handshake overhead and congestion control differences.
What interviewers evaluate: Networking trade-off judgment between reliability, ordering, and latency for real systems.
Answer strategy: Compare reliability and ordering first, then map each protocol to one latency-sensitive and one correctness-sensitive scenario.
Common mistakes: Saying UDP is always faster without caveats, or failing to justify protocol choice by workload needs.
Follow-up questions:
- Why does HTTP/3 use QUIC over UDP?
- What is TCP three-way handshake?
- 06
Describe the difference between process and thread. What are the pros and cons of multithreading?
TechnicalMediumView expert answer & prep guide
Expert answer: A process is an isolated execution unit with its own memory space, while threads are lighter units inside a process that share the same memory. Multithreading improves responsiveness and throughput for I/O-heavy workloads because tasks can run concurrently with lower context-switch overhead than processes. The trade-offs are race conditions, deadlocks, and harder debugging due to shared state. In backend services, I combine thread pools, immutable data where possible, and synchronization primitives to keep concurrency safe and predictable.
What interviewers evaluate: OS and concurrency fundamentals plus awareness of practical engineering trade-offs in multithreaded code.
Answer strategy: Start with memory model difference, then present one benefit and one risk of multithreading with mitigation.
Common mistakes: Claiming threads are always better, or ignoring synchronization and shared-state failure modes.
Follow-up questions:
- When do you prefer multiprocessing?
- How does context switching differ for process vs thread?
- 07
Tell me about a time you had to meet a tight deadline. How did you prioritise?
BehavioralMediumView expert answer & prep guide
Expert answer: In my final-year placement project, we had three days to demo a recruiter dashboard after API scope changed late. I split features into must-have versus nice-to-have, aligned with the mentor on a thin vertical slice, and assigned owners for API, UI, and testing. We shipped login, candidate list, and status updates first, and deferred analytics charts. I sent progress updates every few hours and flagged blockers early. We demoed on time with zero critical bugs and added deferred items in the next sprint.
What interviewers evaluate: Execution discipline, prioritization under pressure, and communication maturity during constrained delivery.
Answer strategy: Use STAR with clear constraints, your prioritization framework, stakeholder communication, and measurable result.
Common mistakes: Giving vague team stories, skipping trade-offs, or not showing what you intentionally deprioritized.
Follow-up questions:
- What did you cut first and why?
- What would you improve in that execution plan today?
- 08
Describe a situation where you had to learn a new technology quickly.
BehavioralEasyView expert answer & prep guide
Expert answer: During internship onboarding, I had to deliver a feature in Next.js even though I had mostly used plain React. I spent the first day reading official docs and building a small sandbox for App Router patterns, then paired with a senior for code-review feedback. By day three, I shipped a production-ready page with server-side data fetching and form validation. I documented what I learned for the next intern. The key was structured learning, fast experimentation, and immediate application to a real task.
What interviewers evaluate: Learning agility, self-directed execution, and ability to convert learning into deliverable output quickly.
Answer strategy: Share your learning loop: docs, proof-of-concept, mentorship feedback, then production implementation with timeline.
Common mistakes: Saying you are a fast learner without concrete actions, outcomes, or evidence of applied understanding.
Follow-up questions:
- How did you validate your understanding quickly?
- What would you do if no mentor was available?
- 09
Why do you want to work at [Company]? What do you know about us?
HREasyView expert answer & prep guide
Expert answer: I want to work here because your product solves a meaningful user problem at scale, and the engineering challenges match my strengths in backend and system reliability. I studied your recent launches, India hiring focus, and engineering blogs on performance and developer productivity. I am especially excited by the ownership culture and opportunity to ship measurable impact early. My goal is to contribute to customer-facing features while growing under strong review standards and mentorship in a high-quality engineering environment.
What interviewers evaluate: Preparation quality, motivation authenticity, and role-company fit beyond generic enthusiasm.
Answer strategy: Anchor answer in three points: product mission, engineering challenge match, and why your background fits this team now.
Common mistakes: Generic praise, incorrect company facts, or focusing only on salary and brand value.
Follow-up questions:
- Which recent product launch impressed you most?
- How does this role align with your two-year goals?
- 10
If you discovered a critical bug in production right before a major release, what would you do?
SituationalHardView expert answer & prep guide
Expert answer: I would first assess severity and user impact, then immediately notify the release owner and relevant stakeholders. If the bug risks data integrity, payment flow, or security, I would block release and trigger rollback or a controlled hotfix path. I would assign owners for triage, fix, verification, and communication, while keeping an incident log. After stabilization, I would run root-cause analysis and add safeguards like regression tests, monitoring alerts, and release checklist updates so the same class of failure is less likely to recur.
What interviewers evaluate: Incident judgment, communication under pressure, and production-risk management maturity.
Answer strategy: Walk through sequence: impact assessment, escalation, release decision, mitigation, validation, and post-incident prevention.
Common mistakes: Acting alone without communication, prioritizing launch date over user risk, or skipping postmortem actions.
Follow-up questions:
- When do you choose rollback over hotfix?
- What would your postmortem include?
Frequently Asked Questions
How many Software Engineer interview questions should I prepare?
Aim for 50–80 core questions across DSA, OOPs, DBMS, OS, networking, and behavioral — but depth beats volume. Master 30 patterns you can explain aloud with complexity analysis rather than memorizing 200 shallow answers.
What DSA topics matter most for Software Engineer interviews in India?
Arrays, strings, hashing, two pointers, sliding window, binary search, trees, graphs (BFS/DFS), heaps, and medium dynamic programming cover most product and campus OAs. Service-company drives add aptitude and CS MCQs.
Is system design required for Software Engineer campus placements?
Usually not for mass-recruiter fresher loops (TCS, Infosys, Wipro). Product companies may introduce light design at SDE-2+ or experienced hire loops. Still learn basics — APIs, databases, caching — to stand out in technical Round 2.
How long does the Software Engineer interview process take in India?
Campus drives often complete in 2–4 weeks. Product company loops typically run 4–8 weeks from application to offer, depending on OA scheduling, panel availability, and offer approval chains.
What is the difference between product and service company SWE interviews?
Product companies weight DSA depth, system design, and structured behavioral signals more heavily. Service companies often emphasize aptitude, communication, CS fundamentals MCQs, and broader campus eligibility — with moderate coding difficulty.
Should I prepare in Java or Python for SWE interviews?
Use the language you can write cleanly under pressure — usually what your projects use. Indian panels accept Java, Python, or C++ if syntax is fluent and you can explain standard library choices. Consistency matters more than trend-chasing.
How important are behavioral rounds for Software Engineer roles?
Very important at product companies (Amazon LPs, Microsoft growth mindset) and increasingly at campus HR screens. Technical rejection gets attention, but vague STAR stories eliminate candidates who cleared coding rounds.
Can I crack SWE interviews with only LeetCode practice?
LeetCode alone is insufficient for most Indian loops. You also need CS fundamentals, company-specific OA formats, spoken problem-solving, and behavioral stories. Combine DSA drills with mocks and fundamentals revision.
What salary should I expect as a fresher Software Engineer in India (2026)?
Mass recruiters typically offer 3.5–8 LPA for B.Tech freshers. Mid-tier product and unicorns range 10–18 LPA. Top product companies can exceed 20–40 LPA for strong campus or off-campus hires — always confirm level and location.
How do I prepare for Online Assessments (OA)?
Practice timed sets weekly: 2 coding problems plus MCQ sections under real clocks. Read prompts twice, manage time per section, and review debugging and code-tracing questions — not only algorithm puzzles.
Is a GitHub portfolio necessary for Software Engineer interviews?
Helpful but not mandatory for campus drives. For product companies and experienced roles, 1–2 polished projects with README, architecture explanation, and measurable impact strengthen resume screens and project discussion rounds.
How should I use mock interviews in my SWE prep?
Start mocks after Week 2 of structured prep. Run at least 4 before your first real loop: narrate approach, accept follow-ups, and review filler words and pacing. InterviewEra mock interviews score answers across five rubric dimensions.