Microsoft SWE Intern & University Graduate — Interview Pattern, Syllabus & Prep Roadmap 2026
Microsoft's hiring process for students and recent graduates focuses on strong DSA, clean coding, problem-solving, and alignment with their growth mindset culture. While Intern roles (Explore/Engage) prioritise learning potential and fundamentals, University Graduate roles include design and deep behavioural evaluation through the 'As Appropriate' (AA) round.
Intern: OA (60–90 min) + 2 Technical Interviews (45 min each). New Grad: OA + Technical Screen + Final Loop (4–5 rounds of coding, design, behavioural + 'As Appropriate' round).
Last updated:
Exam Pattern
Intern: OA (60–90 min) + 2 Technical Interviews (45 min each). New Grad: OA + Technical Screen + Final Loop (4–5 rounds of coding, design, behavioural + 'As Appropriate' round).
| Section | Questions | Time | Type | Difficulty |
|---|---|---|---|---|
| SWE Intern · Online Assessment | 2–3 problems | 60–90 min | Coding | Easy–Medium |
| SWE Intern · Technical Interviews (x2) | 1–2 problems each | 45 min each | Coding & Fundamentals | Easy–Medium |
| University Graduate · Online Assessment | 2–3 problems | 60–90 min | Coding | Medium |
| University Graduate · Technical Screen | 1–2 problems | 45–60 min | Coding | Medium |
| University Graduate · Final Loop (x4–5) | Varies | 45 min each | Coding, Design, Behavioural | Medium–Hard |
| University Graduate · As Appropriate (AA) | Varies | 45 min | Final Decision / Culture | Medium |
Section-Wise Syllabus
Everything that appears in the assessment, grouped by section.
1. Coding Foundation
Arrays & Strings
- • Prefix sums
- • Difference arrays
- • Two pointers
- • Sliding window
- • Hashing
- • Sorting-based optimisation
- • Subarrays & subsequences
- • Palindromes
- • Anagrams
- • String matching
- • Minimum window
- • Coordinate compression
- • In-place array operations
Linked Lists, Stacks & Queues
- • Reverse linked list
- • Reverse in groups of k
- • Detect a cycle
- • Find cycle-entry node
- • Merge sorted lists
- • Merge k sorted lists
- • Clone random-pointer list
- • Palindrome linked list
- • Balanced parentheses
- • Min stack
- • Next greater element
- • Largest rectangle in histogram
- • Sliding-window maximum
- • Queue using stacks
- • Expression evaluation
2. Advanced DSA
Trees & Graphs
- • Recursive and iterative traversals
- • Level-order traversal
- • Height and diameter
- • Lowest common ancestor
- • Validate BST
- • Serialize and deserialize
- • Build tree from traversals
- • Root-to-leaf path sum
- • Maximum path sum
- • Vertical and boundary traversal
- • Tree views
- • BFS and DFS
- • Connected components
- • Cycle detection
- • Topological sorting
- • Course scheduling
- • Shortest path (Dijkstra)
- • DSU
- • Strongly connected components
DP & Recursion
- • 1D DP
- • Grid DP
- • House robber
- • Coin change
- • 0/1 knapsack
- • LIS & LCS
- • Edit distance
- • Word break
- • Stock buy-sell
- • Partition DP
- • Tree DP
- • Subsets & Permutations
- • N-Queens
- • Word search
- • Sudoku solver
Advanced Structures
- • Heaps (Top K elements)
- • Median from data stream
- • Trie (Autocomplete)
- • Segment tree
- • Fenwick tree
- • LRU cache
- • Union-find
3. Technical & Design
Core CS
- • OOP (Encapsulation, Polymorphism, SOLID)
- • OS (Process vs Thread, Deadlocks, Paging, Mutex/Semaphore)
- • DBMS (ACID, Normalisation, Indexing, Transactions)
- • Networks (TCP/UDP, HTTP/HTTPS, DNS, Load Balancing)
Low-Level Design (LLD)
- • Parking lot
- • Elevator system
- • Library system
- • Notification service
- • LRU cache design
- • Rate limiter
- • Meeting-room scheduler
- • Design patterns (Factory, Strategy, Observer, State)
Lightweight System Design
- • URL shortener
- • Distributed cache
- • Chat system
- • Search autocomplete
- • News feed
- • Collaborative document service
- • API gateway
- • Metrics service
4. Behavioural & Culture
Microsoft Principles
- • Growth mindset
- • Customer focus
- • Collaboration
- • Ownership
- • Inclusion
- • Learning from failure
Project Preparation
- • Architecture & Data structures
- • Individual contribution
- • Biggest bug & trade-offs
- • Complexity & Testing
- • Deployment & Monitoring
Most Asked Topics
Highest-frequency areas across recent test papers.
Smallest missing positive
Target O(n) time and O(1) extra space using in-place placement.
Minimum window substring
Classic sliding window problem with a frequency map.
Median from a stream
Efficiently finding the median using two heaps (Min-heap and Max-heap).
Lowest Common Ancestor
Recursive traversal in binary trees to find the first common ancestor.
Directed graph cycle
Cycle detection using DFS colouring or topological sort (Kahn's algorithm).
LRU Cache design
Combining a Hash map and a Doubly Linked List for O(1) access and update.
STAR-format behavioural
Tell me about a difficult problem, a failure, or a disagreement with a teammate.
Growth Mindset
Microsoft's core cultural value—show how you learn from feedback and failure.
Free Resources
Curated practice links per section.
System & Low-Level Design
Culture & Careers
50+ DSA Practice Problems
Solve in order — arrays and strings first, then sorting and recursion.
Arrays & Strings
- Two-sum and three-sum
- Longest substring without repetition
- Minimum window substring
- Maximum subarray sum (Kadane)
- Product of array except self
- Smallest missing positive integer
- Group anagrams
- Subarray sum equals K
- Merge intervals
- Longest consecutive sequence
- Trapping rainwater
- Meeting rooms
Linked Lists & Stacks
- Reverse linked list
- Reverse in groups of k
- Detect a cycle
- Find cycle-entry node
- Merge sorted lists
- Merge k sorted lists
- Clone random-pointer list
- Palindrome linked list
- Balanced parentheses
- Min stack
- Next greater element
- Largest rectangle in histogram
- Sliding-window maximum
Trees & Graphs
- Level-order traversal
- Height and diameter of tree
- Lowest common ancestor
- Validate BST
- Serialize and deserialize binary tree
- Build tree from traversals
- Number of islands
- Shortest path in weighted graph (Dijkstra)
- Course scheduling
- Directed graph cycle detection
- Word ladder
DP & Recursion
- House robber
- Coin change
- 0/1 knapsack
- LIS and LCS
- Edit distance
- Word break
- Subsets and Permutations
- N-Queens
- Word search
Previous Year Questions & Patterns
Repeat coding questions with the expected approach.
Coding Problems
- Find the smallest missing positive integer in O(n) time and O(1) space.
- Find the minimum window containing all characters of another string.
- Find the median from a stream using two heaps.
- Implement an autocomplete dictionary using a Trie plus ranking.
- Clone a graph using BFS/DFS with old-to-new mapping.
- Find the lowest common ancestor in a binary tree.
- Detect a cycle in a directed graph.
- Merge K sorted lists using a Min-heap.
Technical & Design
- Explain process versus thread and context switching.
- What is a race condition and how to prevent it?
- Difference between mutex and semaphore.
- What are ACID properties in DBMS?
- Explain database indexing and isolation levels.
- TCP versus UDP: when to use which?
- What happens after you enter a URL in the browser?
- Design a parking lot or an elevator system.
- Design a rate limiter using token bucket or leaky bucket.
Behavioural (STAR format)
- Tell me about a difficult technical problem you solved.
- Describe a time you disagreed with a teammate and how you handled it.
- Tell me about a failure and what you learned from it.
- Describe a time you took initiative on a project.
- Why Microsoft? Which product interests you the most?
- Describe a time you helped another person grow or succeed.
20+ SQL Query Bank
Write these out by hand — joins and subqueries are asked in both the test and the interview.
Database Concepts
Basic selection
SELECT * FROM Employees WHERE Department = 'Azure' AND Salary > 100000;Join example
SELECT e.Name, d.DeptName
FROM Employees e
INNER JOIN Departments d ON e.DeptID = d.ID;Aggregation
SELECT Department, COUNT(*) as Headcount, AVG(Salary) as AvgSalary
FROM Employees
GROUP BY Department
HAVING COUNT(*) > 10;Schema & Constraints
Creating index
CREATE INDEX idx_user_email ON Users(Email);Unique constraint
ALTER TABLE Products ADD CONSTRAINT UC_ProductCode UNIQUE (Code);DBMS & Core Interview Q&A
Short answers you should be able to say out loud.
What is the difference between Clustered and Non-Clustered indexing?
Clustered index determines the physical order of data in the table (one per table), while Non-Clustered index creates a separate structure to point to the data.
What are ACID properties?
Atomicity, Consistency, Isolation, and Durability—ensuring reliable database transactions.
What is a deadlock in DBMS?
A situation where two or more transactions are waiting for each other to release locks, causing a circular dependency.
Explain database normalization.
The process of organizing data to reduce redundancy and improve data integrity (1NF, 2NF, 3NF, BCNF).
OOPs Concepts + 10 Code Snippets
Theory plus the exact snippets asked in the technical round.
SOLID Principles
Single responsibility, Open-closed, Liskov substitution, Interface segregation, and Dependency inversion.
Composition vs Inheritance
Preferring composition (has-a) over inheritance (is-a) to build more flexible and decoupled systems.
Polymorphism
Allowing objects of different types to be treated as objects of a common base type, often via overriding or interfaces.
Dependency Injection
A design pattern where an object's dependencies are provided externally rather than created internally, enhancing testability.
Lowest Common Ancestor (Binary Tree)
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null || root == p || root == q) return root;
TreeNode left = lowestCommonAncestor(root.left, p, q);
TreeNode right = lowestCommonAncestor(root.right, p, q);
if (left != null && right != null) return root;
return left != null ? left : right;
}LRU Cache Skeleton (Hash Map + DLL)
class LRUCache {
int capacity;
list<pair<int, int>> cache;
unordered_map<int, list<pair<int, int>>::iterator> map;
public:
LRUCache(int cap) : capacity(cap) {}
int get(int key) {
if (map.find(key) == map.end()) return -1;
cache.splice(cache.begin(), cache, map[key]);
return map[key]->second;
}
void put(int key, int value) {
if (map.find(key) != map.end()) {
cache.splice(cache.begin(), cache, map[key]);
map[key]->second = value;
return;
}
if (cache.size() == capacity) {
map.erase(cache.back().first);
cache.pop_back();
}
cache.push_front({key, value});
map[key] = cache.begin();
}
};Operating System Basics
Scheduling, deadlock and memory management essentials.
Process & Thread Management
- • Process vs Thread: isolated memory vs shared memory space.
- • Context switching: the overhead of saving and loading execution states.
- • CPU Scheduling: FCFS, SJF, Round Robin, Priority scheduling.
Memory & Synchronisation
- • Paging and Virtual Memory: mapping logical addresses to physical memory.
- • Deadlock conditions: Mutual exclusion, Hold and wait, No preemption, Circular wait.
- • Mutex vs Semaphore: binary lock vs counter-based resource management.
4-Week Preparation Roadmap
From zero to test-ready in 28 days.
Foundation
- Arrays, Strings, Linked Lists, Stacks, Queues
- Time & Space Complexity analysis
- Easy-Medium LeetCode problems
Goal: Master basic data structures and coding accuracy.
Advanced DSA
- Trees, Graphs, Heaps, Recursion, DP
- Graph traversals (BFS/DFS) and shortest paths
- Medium-Hard LeetCode problems
Goal: Build strong problem-solving skills for complex algorithms.
Design & Fundamentals
- OOP, OS, DBMS, Networks
- Low-Level Design (LLD) patterns
- Lightweight System Design scenarios
Goal: Bridge the gap between coding and engineering design.
Revision & Mocks
- Mock interviews
- Behavioural STAR-format stories
- Project deep-dives
- Timed Online Assessments
Goal: Polish communication and handle high-pressure environments.
Exam Day Strategy
Score targets and time allocation.
Section targets
- Online Assessment: Finish easy problems quickly to save time for the harder one; ensure all edge cases are handled.
- Technical Rounds: Think out loud; discuss your approach before coding; write clean, modular code with meaningful names.
- Behavioural Rounds: Be authentic; focus on 'I' (your contribution) but show collaboration; align with Microsoft's growth mindset.
Coding time split (50 min)
- 10 min: Clarify problem & discuss approach
- 25 min: Coding with clean logic
- 10 min: Dry run & edge cases
Interview Process
What follows the online test.
Initial Screening
- • Recruiter check for eligibility and background.
- • Possible brief technical screen.
Online Assessment
- • 2–3 coding problems on Codility or HackerRank.
- • Focus on efficiency and correctness.
Final Loop
- • 4–5 virtual on-site interviews.
- • Coding, System/Low-Level Design, and Behavioural evaluation.
- • The 'As Appropriate' (AA) round with a senior lead/manager.
Mock Test Plan
Four simulations to run before the real test.
DSA Mock
- • 45 min technical interview with 1 LeetCode Medium/Hard problem.
- • Live coding and complexity discussion.
Design Mock
- • Design a scalable service like a Rate Limiter or a Parking Lot.
- • LLD class structure and SOLID principle application.
Final Checklist
Tick all of these before test day.
Recent Interview Experiences
First-hand write-ups from students who actually sat the Microsoft process.
Be the first to share a Microsoft interview experience.
Frequently Asked Questions
Is Microsoft harder than other Big Tech?
Microsoft has a high bar for coding and cultural fit (growth mindset), but the environment is very supportive of learning.
Does every role include system design?
SWE Intern roles usually focus on DSA and LLD, while University Graduate roles often include lightweight system design.
What is the 'As Appropriate' round?
It's a final interview with a senior leader who ensures consistency in hiring and focuses heavily on culture and long-term potential.
Want the full structured prep for Microsoft?
The Premium Vault covers Aptitude, Core CS, DSA, SQL and HR rounds with module-wise courses and drill sheets.
Related Prep
Next steps chosen from the Microsoft pattern and other Big Tech / Product recruiters.
Other Big Tech / Product companies
Core CS subjects for this pattern
DBMS & SQL Essentials
Normalisation, keys, transactions and the SQL queries asked in written rounds.
OOPs Essentials for Interviews
The four pillars with the exact code snippets interviewers ask you to explain.
Operating System Essentials
Processes, scheduling, deadlock and memory management in interview-ready form.
Recommended practice path