Microsoft Placement Papers: 2026 Test Pattern and Syllabus

Microsoft’s campus online assessment has exactly two coding problems and a 60-minute timer. No aptitude, no verbal reasoning, no logical reasoning filler that IT-services recruiters typically stack onto their tests. A strong performance on two problems determines whether you get an interview slot.

That stripped-down format is actually harder to prepare for than a multi-section test, because there is no section to skip and no easy marks to bank. This guide covers the 2026 test pattern, the topic-by-topic syllabus, and a preparation plan that fits inside a typical final-year placement window.

Recruitment Rounds at a Glance

Microsoft’s full campus process runs in 4 to 5 rounds. The online assessment is the entry gate; clearing it moves you into a sequence of technical and HR rounds. The Microsoft Careers India page lists current open roles and campus programme details.

Round	Format	Duration	What it tests
Online Assessment (OA)	2 coding problems	60 min	DSA, problem-solving
Technical Interview 1	Live coding + discussion	45–60 min	Trees, arrays, DP
Technical Interview 2	Deeper DS or design	45–60 min	Graphs, OOP, systems
HR Interview	Conversation	30 min	Communication, fit

Some batches include a fifth round, a hiring manager or problem-design round, depending on the role (SWE, SDET, or PM) and the year’s headcount.

For a detailed walkthrough of what each round looks like from a candidate’s perspective, see the Microsoft campus recruitment process guide.

What the Online Assessment Tests

The OA is purely algorithmic. There are two problems, both requiring working code that passes automated test cases. No MCQs, no fill-in-the-blank, no essay responses.

Platforms Microsoft has used for campus drives include HackerRank and CodePair, though this varies by campus and year. Whatever the platform, the evaluation criteria are the same: correctness first, then time complexity, then code readability.

The two problems are not equal in difficulty. One is typically a medium-difficulty problem on a standard DSA topic; the second is harder and often involves dynamic programming, graph traversal, or a non-obvious reduction. Both problems are solvable in C++, Java, or Python; C++ and Java are the dominant choices among candidates who clear the OA, primarily because standard library tools for trees and graphs are more concise in those languages.

Key facts about the OA format:

• 2 problems, 60 minutes total
• Language options: C++, Java, Python (and sometimes C, C#)
• No partial credit by default; a solution either passes all test cases or not, though some platforms give partial credit for partial test cases
• No debugging aids; you write from scratch

DSA Topics by Priority

The Microsoft OA does not have a published syllabus, but the pattern across recent campus drives is consistent enough to build a working topic list. Priority here reflects how often these topics appear, not how difficult they are.

Topic	Priority	Common sub-types
Binary Trees and BST	High	Inorder/preorder traversal, LCA, height-balanced construction
Arrays and Strings	High	Rotated sorted array, subarray problems, two-pointer
Linked Lists	High	Reversal, merge, cycle detection, modification patterns
Dynamic Programming	High	Knapsack variants, longest subsequence, interval DP
Graphs	Medium	BFS/DFS, connected components, shortest path
Recursion and Backtracking	Medium	Power set, permutations, N-queens
Bit Manipulation	Medium	Counting set bits, XOR tricks
Hashing	Medium	Duplicate detection, frequency maps
DBMS and OS Concepts	Low	Process vs. thread, transaction isolation (written round)
Object-Oriented Design	Low	Class design, calendar/scheduling problems

For worked examples and code walkthroughs on the high-priority topics, the 20 most-asked data structures interview questions collection covers most of the canonical problem types.

Sample Question Types From Past Papers

These question types have appeared in Microsoft campus drives across multiple years. They represent the style and difficulty level of the OA, not a guarantee of future questions.

Array and Binary Search problems:

• Given a rotated sorted integer array, find the position of a given key using a modified binary search. Return -1 if not found.
• Given an array of size K where every number is between 1 and K, check for duplicates without extra space.
• Count the number of 1-bits in a K-bit number.

Binary Tree and BST problems:

• Find the inorder successor of a given node in a binary search tree.
• Given a sorted integer array, construct a height-balanced binary search tree.
• Given a binary tree, find the subtree that is the largest BST (by node count).

Linked List problems:

• Modify a linked list to retain the first a nodes, delete the next b nodes, and repeat until the end.

Recursion and Design problems:

• Generate the power set of a given set, both iteratively and recursively.
• Design a class for calendar incidents that repeat every N days and return all incidents between two dates.

These are not the same as “memorise this problem, it will appear.” Microsoft engineers write new variants each year. The value in this list is pattern recognition: if you can solve the BST height-balance problem, you can solve its variants. If you understand the retain-and-delete linked list pattern, you have the pointer-manipulation framework for a wide range of linked list modification questions.

Six-Week Preparation Plan

This plan assumes roughly 1.5 to 2 hours of focused practice per day alongside regular coursework.

Week 1: Arrays and Strings

• Cover two-pointer, sliding window, and binary search patterns
• Solve 20 to 25 problems in this category on LeetCode (Easy to Medium)
• Focus: getting comfortable writing clean loops and edge-case handling

Week 2: Linked Lists

• Cover reversal, merge, cycle detection, and modification patterns
• Solve 15 to 20 problems
• Write each solution in your preferred language from scratch, not by copying

Week 3: Trees and BST

• Cover traversals (inorder, preorder, postorder), LCA, height-balanced construction
• Solve 20 to 25 problems
• Explicitly code the recursive and iterative versions of each traversal

Week 4: Dynamic Programming

• Cover 1D DP (Fibonacci, house robber, climb stairs), 2D DP (grid paths, LCS), and knapsack
• Solve 15 to 20 problems
• For each problem, write the recurrence relation before coding

Week 5: Graphs and Backtracking

• Cover BFS/DFS, connected components, power set, permutations
• Solve 15 to 20 mixed problems
• At least 5 graph problems and 5 backtracking problems

Week 6: Full Mock and Review

• Use the LeetCode Microsoft company tag to filter recent Microsoft-tagged problems
• Simulate the OA: pick 2 problems, set a 60-minute timer, submit
• Review mistakes, identify which topic category each mistake falls under
• Spend the last 2 to 3 days on DBMS and OS basics for the written round

The 60-minute simulation in Week 6 matters more than the individual-problem drilling. Most OA failures come down to time management, not knowledge gaps. Spending 50 minutes on the first problem and running out of clock on the second is the pattern.

Applying the Same Skills to AI Projects

The recursive decomposition that DP questions train (breaking a large problem into sub-problems, tracking intermediate state, reasoning about time complexity) is the same cognitive approach AI engineers use when building retrieval pipelines and agent systems. If you want to add an LLM project to your resume before the interview cycle begins, TinkerLLM is a ₹299 entry point with hands-on builds. The problem-solving preparation you are already doing for the OA transfers more directly than you might expect.