Microsoft Software Engineer interview typically runs 3–5 rounds: online assessment, recruiter/hiring manager screen, coding rounds, system design, and behavioral. The process spans 1–5 weeks and is distinguished by mixing LLD, HLD, and DSA in the same loop.
$110K
Avg. Base Comp
$214K
Avg. Total Comp
4-5
Typical Rounds
2-6 weeks
Process Length
What stands out most across the Microsoft SWE experiences we've collected is how consistently the loop blends breadth with depth. This isn't a company that will let you coast on LeetCode fluency alone. Multiple candidates reported that design conversations — both high-level architecture and low-level class design — appeared in the same loop as DSA rounds, and the design prompts were grounded in real-world systems: a movie ticket booking platform, a multiplayer tic-tac-toe game, a ride-sharing service like Uber. These aren't abstract whiteboard exercises; interviewers expect you to reason through interfaces, classes, and tradeoffs in real time.
A recurring theme is that resume depth matters as much as coding performance. Nearly every candidate mentioned a round where the interviewer went deep on past projects — not just what they built, but why they made specific technical decisions, how they handled distributed systems, and what tradeoffs they accepted. One candidate was asked directly about machine learning experience and distributed systems in what was framed as a hiring manager screen. Another noted that behavioral questions were almost always anchored to resume items rather than generic prompts. If you have anything on your CV you can't defend technically, that's a liability here.
The one genuinely surprising signal we've seen is the appearance of less conventional topics — memory management questions, AI-assisted coding exercises where the candidate had to explain generated code rather than write from scratch. These aren't the norm, but they signal that Microsoft is increasingly interested in reasoning and communication over raw implementation speed. Interviewers across multiple reports were described as forgiving of imperfect code, but unforgiving of candidates who couldn't articulate their thinking clearly. That's the real bar here.
Synthetized from 8 candidates reports by our editorial team.
Had an interview recently?
Share your experience. Unlock the full guide.
Real interview reports from people who went through the Microsoft process.
When I actually sat down for the Microsoft interview process, it felt a lot more conversational than I expected, but definitely not easy. The process had 5 rounds in total. It started with an online assessment on HackerRank, which had 2 medium-hard coding problems. After clearing that, I had a recruiter screen, and then the final full loop consisted of 3 coding rounds and 1 system design round.
One thing I noticed throughout the loop was that every round started with a couple of behavioral questions. They were not just basic "tell me about yourself" questions either. The interviewers asked a lot of follow-up questions based on my answers, so it felt like they were trying to understand how I actually worked in real situations, not just whether I had prepared some STAR-format stories.
The first coding round was low-level design of an LRU Cache. I was comfortable with the general idea because it is a common problem, but the interviewer pushed on the implementation details. They wanted to see if I could clearly explain the use of a hashmap with a doubly linked list, how eviction would work, and how to keep both get and put operations efficient. I felt fairly confident here, but I had to be careful not to rush because small mistakes in pointer handling can easily mess up the whole solution.
The second coding round was Coin Change using dynamic programming. This was the round where I felt the most pressure. I knew the standard DP approach, but the interviewer asked follow-ups around edge cases, initialization, and why a certain recurrence made sense. I had to slow down and explain my thought process step by step. It was not enough to just write the code; they really wanted to see whether I understood why the solution worked.
The third coding round was a graph problem involving multi-source DFS. This one surprised me a bit because I initially started thinking in terms of a single-source traversal, but then realized that the problem needed multiple starting points. I talked through the approach, clarified the assumptions, and then adjusted my solution. The interviewer seemed more interested in how I corrected my direction than whether I got the perfect solution immediately.
The system design round was URL shortener. The discussion started at a high level with requirements and APIs, then moved into database schema, encoding strategy, read/write patterns, scalability, caching, and handling collisions. I felt more confident in this round than I expected because the problem is familiar, but the follow-up questions made it clear that they were looking for tradeoffs, not a memorized design. For example, we discussed how to generate short URLs, how to avoid collisions, what to cache, and how the system would behave under high traffic.
What surprised me the most was how much emphasis they placed on communication. Even in coding rounds, they cared a lot about whether I could explain my assumptions, discuss edge cases, and respond well when challenged. The interview did not feel like a trick-question contest, but it also did not feel relaxed. They kept pushing whenever an answer was too surface-level.
I felt most confident in the LRU Cache and URL shortener rounds because I had seen those patterns before and could explain the tradeoffs clearly. I felt less confident during the Coin Change and multi-source DFS rounds, especially when follow-ups forced me to go deeper than the standard solution.
Overall, the process was challenging but fair. My biggest takeaway is that for Microsoft, just knowing the solution is not enough. You need to be able to explain why your approach works, handle follow-up questions calmly, and show how you think when the problem becomes less straightforward.
Share your own interview experience to unlock all reports, or subscribe for full access.
Sourced from candidate reports and verified by our team.
Topics based on recent interview experiences.
Featured question at Microsoft
Given two sorted lists, write a function to merge them into one sorted list.
| Question | |
|---|---|
| Random SQL Sample | |
| Find the Missing Number | |
| Raining in Seattle | |
| Minimum Change | |
| Scrambled Tickets | |
| Download Facts | |
| Employee Salaries (ETL Error) | |
| Employee Project Budgets | |
| Find Bigrams | |
| Bagging vs Boosting | |
| Lowest Paid | |
| P-value to a Layman | |
| The Brackets Problem | |
| Project Budget Error | |
| Google Maps Improvement | |
| N-gram Dictionary | |
| Cyclic Detection | |
| Binary Tree Conversion | |
| Hurdles In Data Projects | |
| Find Duplicate Numbers in a List | |
| Longest Increasing Subsequence | |
| Good Grades and Favorite Colors | |
| Swapping Nodes | |
| Sequentially Fill in Integers | |
| Greatest Common Denominator | |
| Merge N Sorted Lists | |
| Type I and II Errors | |
| Design a query-retrieval system | |
| Target Value Search |
Synthesized from candidate reports. Individual experiences may vary.
A coding challenge with 2-3 LeetCode-style problems ranging from easy to medium-hard difficulty. This is typically the first filter before any human contact and may include string manipulation, linked list, or dynamic programming questions.
A brief conversation with an HR recruiter covering logistics, background, and interest in the role. This stage is mostly administrative and used to confirm fit before scheduling technical rounds.
A conversation with the hiring manager that is heavily focused on resume and past projects, including technical decisions, distributed systems knowledge, and sometimes a system design or medium-level coding question.
A series of back-to-back technical interviews covering DSA coding (LeetCode easy to hard), system design (e.g., movie ticket booking, ride-sharing service), low-level design (e.g., multiplayer tic-tac-toe, class and interface design), and behavioral questions tied to resume projects. Some rounds are hybrid, mixing coding with behavioral or design elements.