Assessment tips
- Confirm the current Microsoft pattern from the drive mail before practising old papers
- Finish one problem or section fully before starting the next
- Revise the fundamentals listed in the round table on this page
Microsoft Interview Experience 2026
Overview
How Microsoft’s SDE loop actually runs, synthesized from recent candidate reports and Microsoft public hiring guides. We reorganized rounds, added prep notes, and flagged team/level variance - treat this as a prep map, not a script.
Reported fresher SDE total compensation in India commonly falls in the roughly Rs 28-40 LPA range (base plus bonus and stock), concentrated at Microsoft’s Hyderabad, Bangalore, and Noida development centers - treat any specific figure as a self-reported approximation, not a guarantee, since it varies by level, college tier, and location.
Microsoft interview process overview
| Round | Duration | What it tests |
|---|---|---|
| Online Assessment (OA) | 60-90 min | 2-4 DSA problems on HackerRank/Codility |
| Technical Interview 1 | 45-60 min | DSA, live coding, problem-solving approach |
| Technical Interview 2-3 | 45-60 min each | CS fundamentals, LLD/OOD, light system design for senior roles |
| As Appropriate (AA) round | 45-60 min | Culture fit, growth mindset, leadership signal - senior leader, veto power |
| HR / offer discussion | 20-30 min | Logistics, compensation, closing questions |
Real interview experiences
Experience 1: SDE-1, campus hire (2025)
Profile: B.Tech CSE, ~8.3 CGPA, tier-1 college, one internship, consistent LeetCode practice, hired through campus placement in Hyderabad
Online Assessment
- 90 minutes, 3 problems on HackerRank: a two-pointer array problem, a binary tree path-sum variant, and a harder graph problem (shortest transformation sequence). Cleared with all test cases passing on the first two, partial on the third.
Technical Interview 1
- Live coding on Microsoft Teams: design an LRU cache with O(1) get/put. Interviewer pushed on thread-safety as a follow-up after the base solution worked.
- A second, shorter problem: number of islands in a grid (DFS), then a follow-up asking for the Union-Find version.
Technical Interview 2
- Word ladder-style shortest-path problem (BFS), followed by CS fundamentals: paging and virtual memory, then a database question on transaction isolation levels.
- A short discussion of the candidate’s internship project - architecture choices and one specific performance fix.
As Appropriate (AA) round
- Interviewer: a Principal Engineer from an unrelated product group.
- “Tell me about a project you’re most proud of, and one thing you’d change about it.”
- “Describe a time you disagreed with your team’s technical approach.”
- “Tell me about a time you didn’t know something you needed to - how did you close that gap?”
- Kept every answer to a clear situation, action, and a specific change made afterward rather than a polished success story.
HR / offer
- Short call: location confirmation, notice period (not applicable for a fresher), and “why Microsoft.”
Result: Selected. Reported package in the mid-30s LPA range (base plus stock and bonus), Hyderabad.
Takeaways
- What decided it: The AA round rewarded a specific, honest answer about a technical disagreement over a rehearsed leadership anecdote - preparing “what changed afterward” mattered more than preparing a flawless story.
- Common fail: Rushing OOD or a rehearsed AA anecdote without growth
- How to practise: Clarify requirements first; prepare AA disagreement + learning stories
Experience 2: SDE-2, off-campus/lateral hire (2024-2025)
Profile: ~3 years at a mid-size product company, applied off-campus through a referral, strong system design background
Online Assessment
- Skipped for this experience level; the loop began directly with technical interviews.
Technical Interview 1
- Merge k sorted lists (min-heap), then a discussion of time/space trade-offs versus a divide-and-conquer merge approach.
- Follow-up: how would this change if the lists were too large to fit in memory?
Technical Interview 2 (System design)
- Design a URL shortener, then extended into rate limiting for the write path.
- Discussion of consistency versus availability trade-offs and how the candidate would monitor the system in production.
Technical Interview 3
- LLD: design a parking lot system with proper class relationships, followed by a short DSA warm-up (valid parentheses variant with multiple bracket types).
As Appropriate (AA) round
- Interviewer: a Director from a different business group.
- Leaned almost entirely behavioural: a time the candidate pushed back on a manager’s decision, how they mentor more junior engineers, and a time they had to learn an unfamiliar part of a codebase quickly.
- The interviewer probed follow-ups on what the candidate would do differently, more than on the outcome itself.
Result: Selected after a loop with one technical round rated only “lean hire” - the strong AA round is what the candidate believes tipped the decision.
Takeaways
- What decided it: A single average technical round did not sink the loop; a clearly strong AA performance can offset it, which matches how the AA round is reported to work as a final, override-capable check.
- Common fail: Rushing OOD or a rehearsed AA anecdote without growth
- How to practise: Clarify requirements first; prepare AA disagreement + learning stories
Experience 3: Engage intern → FTE SDE-1 (L60), Hyderabad (2024-2025)
Profile: B.Tech IT, ~7.6 CGPA, tier-2 college, Microsoft Engage summer program, converted to FTE after intern project review
Engage / intern loop
- Virtual technical: array range-merge on sorted intervals (two pointers), emphasis on explaining approach before coding.
- Design discussion: lightweight notification service other teams could call - interviewer pushed on Observer vs pub/sub and edge cases (duplicate subscribers, retry).
- Internship: worked on an internal tooling team; final presentation to skip full OA for FTE conversion (drive-dependent).
FTE conversion interviews
- Technical 1: Prefix-sum style problem plus follow-up on space optimization; Codility-style “think aloud” even on Teams.
- Technical 2: CS fundamentals - virtual memory and a short DB transaction question; deep dive on intern project metrics (latency before/after a refactor).
- AA round: Senior leader from another org - failure story, disagreement with mentor, and how AI tools helped vs hurt on the intern codebase (candidate described using Copilot for tests but manual review for security-sensitive paths).
HR / offer
- Location preference (Hyderabad), joining date, standard benefits overview.
Result: Selected for SDE-1 (L60). Reported total compensation in the high-30s LPA band (candidate-reported, Hyderabad).
Takeaways
- What decided it: Engage and intern paths still test growth-mindset follow-ups and project depth; treat the intern presentation as a behavioral round with metrics.
- Common fail: Rushing OOD or a rehearsed AA anecdote without growth
- How to practise: Clarify requirements first; prepare AA disagreement + learning stories
Experience 4: Off-campus L60 - OA cleared, rejected after LLD round (2025)
Profile: B.Tech CSE, ~8.0 CGPA, strong DSA, weaker OOD speed
Online Assessment
- HackerRank: two medium problems - solved both with all visible tests; unknown score on hidden performance cases.
Technical Interview 1 (DSA)
- “Count perfect pairs” - brute force then two-pointer after hint; minor bug consumed time.
- Second problem: heater / binary-search radius variant - approach agreed, coding time ran out.
Technical Interview 2 (LLD)
- Design a notification module for targeted user alerts; candidate opened with Observer pattern but requirements shifted (batching, failure handling) and code stayed incomplete.
Result: Rejected after LLD round.
Takeaways
- What decided it: Public L60 reports often fail on implementation speed in OOD, not lack of DSA knowledge - clarify requirements for five minutes before naming patterns.
- Common fail: Rushing OOD or a rehearsed AA anecdote without growth
- How to practise: Clarify requirements first; prepare AA disagreement + learning stories
Pre-interview checklist (Microsoft SDE)
| Stage | What to verify | Common miss |
|---|---|---|
| OA invite | HackerRank vs Codility, time limit, proctoring rules | Assuming visible tests = full score on Codility |
| Virtual loop | Teams link, shared editor, camera policy | No quiet space for 3×60 min back-to-back |
| AA prep | 3 stories ending in behavior change | Failure stories that stop at “I learned” |
| Level / location | L59/L60, Hyderabad vs Bangalore requisition | Comparing CTC across cities without offer letter |
Questions that come up often
Coding / technical
- Design an LRU cache - HashMap + doubly linked list, thread-safety follow-up
- Number of islands - DFS, then Union-Find follow-up
- Word ladder / shortest transformation sequence - BFS
- Merge k sorted lists - min-heap
- Binary tree path-sum variants
- Valid parentheses with multiple bracket types
- CS fundamentals: paging/virtual memory, database transactions and isolation levels, TCP handshake
System design / LLD
- Design a URL shortener, then extend to rate limiting
- Design a parking lot system (LLD/OOD, class relationships)
- Design an LRU/LFU cache as a standalone system
- Design a notification or messaging service
- Meeting Rooms II (min-heap / sweep) and multi-floor parking lot variants
- Undo/redo for a text editor with bounded history
Behavioural (technical rounds and AA round)
- Tell me about a project you’re most proud of, and what you’d change about it
- Describe a time you disagreed with your team’s technical direction
- Tell me about a time you didn’t know something you needed to - how did you close that gap?
- Tell me about a time you failed at something and what changed afterward
- Why Microsoft?
Practical tips for Microsoft
- Practice explaining trade-offs out loud, not just reaching a working solution - Microsoft interviewers probe the “why” behind a choice as much as the code itself.
- Don’t skip CS fundamentals assuming only DSA gets tested; paging, transactions, and networking basics show up across technical rounds.
- For the AA round, prepare 2-3 stories that each end with a concrete change you made, not just an honest account of what went wrong - that closing beat is what growth-mindset framing rewards.
- Treat an AA invite as encouraging, not as the interview being over - it is a real, veto-capable evaluation.
- If a technical round feels average, don’t assume the loop is lost - candidates report the AA round can offset a mixed earlier round.
HR interview
After the technical rounds and the As Appropriate round, Microsoft usually closes with a short HR conversation covering logistics, motivation, and a couple of closing behavioural questions. Prepare those answers on the dedicated page rather than cramming them into this hub.
Sample answers for high-frequency questions
Use these as frames, not scripts - interviewers probe follow-ups.
Q. How do you design an LRU cache with O(1) get and put?
A. Combine a hash map with a doubly linked list. The hash map maps each key to the list node holding its value, giving O(1) lookup; the doubly linked list keeps nodes in recency order with the most recently used at the head and the least recently used at the tail. On get, look the key up in the map, unlink its node, and move it to the head. On put, if the key exists update the value and move it to the head; otherwise create a node, insert at the head, and add it to the map - and if the size now exceeds capacity, remove the tail node and delete its key from the map. The list must be doubly linked so that unlinking a node in the middle is O(1) without traversing to find its predecessor. Use sentinel head and tail nodes to avoid null checks at the boundaries.
Q. How do you count the number of islands in a grid?
A. Treat the grid as an implicit graph where each land cell (“1”) is a node connected to its four orthogonal neighbours. Scan every cell; when you find an unvisited land cell, increment your island counter and run a BFS or DFS from it, marking every reachable land cell as visited so it is never counted again. A common trick is to sink the island by overwriting each visited “1” with “0” instead of keeping a separate visited array. The time complexity is O(rows times cols) because each cell is examined a constant number of times. Space is O(rows times cols) in the worst case - the BFS queue or the DFS recursion stack when the whole grid is one island. If the interviewer adds diagonal connectivity, only the neighbour offsets change, from 4 directions to 8.
Q. Why is BFS the right algorithm for the Word Ladder problem?
A. Word Ladder asks for the shortest transformation sequence from a begin word to an end word, changing one letter at a time with every intermediate word in a dictionary. Model each word as a node with edges to every dictionary word one letter away; because all edges have weight 1, BFS explores words in order of distance from the start, so the first time you reach the end word you have the shortest path - DFS would find some path but not necessarily the shortest. Rather than comparing every pair of words, generate neighbours by replacing each position with each of the 26 letters and checking a hash set of the dictionary, which costs O(L times 26) per word for word length L. Total complexity is roughly O(N times L times 26) for N words, and marking words as visited when you enqueue them (not when you dequeue) prevents duplicate work. A bidirectional BFS from both ends is the standard follow-up optimisation.
Q. How do you merge k sorted linked lists efficiently?
A. Push the head node of each of the k lists into a min-heap keyed by node value. Repeatedly pop the smallest node, append it to the output list, and push that node’s next node if it exists. Each of the N total nodes enters and leaves the heap once, and the heap never holds more than k entries, so the complexity is O(N log k) time and O(k) space. The naive approach of concatenating everything and sorting is O(N log N), and merging lists one at a time pairwise into an accumulator is O(N times k), so the heap is the answer interviewers are looking for. An equally good alternative is divide and conquer: merge the lists in pairs, halving the count each round, which also lands at O(N log k) with O(1) extra space.
Q. How do you approach a dynamic programming problem like coin change?
A. Coin change asks for the fewest coins summing to a target amount. Define the state first: dp[i] is the minimum number of coins needed to make amount i. The recurrence is dp[i] = 1 + min(dp[i - c]) over every coin c that is less than or equal to i, with the base case dp[0] = 0 and every other entry initialised to infinity, meaning unreachable. Fill the table from 1 up to the target; the answer is dp[amount], or -1 if it is still infinity. This is O(amount times number of coins) time and O(amount) space. The general method is the same for any DP: identify the state, write the recurrence that relates it to smaller states, establish base cases, choose bottom-up tabulation or top-down memoisation, then look for a space optimisation - many 2D tables collapse to one or two rows.
Tips from successful candidates
Interview tips
- Narrate trade-offs; expect “why” after every answer
- Only list projects you can defend under follow-ups
- Prepare 3-4 STAR stories for behavioural prompts
HR tips
- Know why Microsoft, not just why the industry
- Be clear on location / notice period / higher studies
- Practise answers on the dedicated HR page
Sources
These links are research inputs we used to map round structure and recurring questions - not copied page mirrors. We reorganized reports into process tables, outcome notes, and prep takeaways for Microsoft.
Cross-check the current drive mail or careers posting for timings and pattern changes.
For the company overview and FAQs, see the Microsoft hub. For behavioural STAR prompts, use the Microsoft HR page. For OA drills, use Microsoft on placementpapers.app.