Microsoft Placement Papers 2026: SDE-1 OA, Loop and AA Round Guide

Microsoft India SDE-1 2026 total CTC (Year 1) is candidate-reported at approximately 28 to 38 LPA, based on Levels.fyi India offer data from 2025-26. The standard loop runs 1 online coding test plus 3 to 4 technical rounds and 1 HR round. Minimum CGPA is typically 7.0 to 7.5. All figures below are candidate-reported or sourced from Levels.fyi; confirm your specific offer against the drive notification.

Updated for 2026-05-14

Cross-checked against the Microsoft Careers students page, GeeksforGeeks Microsoft interview reports, Levels.fyi India compensation data and PapersAdda Hiring Pulse candidate threads on 14 May 2026. The current cycle notes:

• Microsoft India is actively hiring SDE-1 for Copilot integration teams across Azure, Microsoft 365 and Bing. Engineers with ML fundamentals and LLM-application experience have a small but real advantage in round-three depth questions.
• Core SDE-1 hiring remains DSA and CS-fundamentals focused. The four-round loop structure is stable from 2024 to 2026.
• MSIDC Hyderabad remains the largest Microsoft engineering location outside the US and owns full product areas including Azure subsystems, Bing, Microsoft 365, Windows and Teams. It is not a support-engineering office.

Microsoft's interview reputation is genuine. Multiple verified candidate threads cite that Microsoft interviewers are trained to clarify problem statements and unblock candidates on syntax, not to apply hostile-grilling pressure. The bar is rigorous, the experience is fair. This guide compiles the round-by-round structure, OA format and salary bands grounded in publicly verifiable sources for the 2026 hiring season.

Source pages last verified on 14 May 2026.

Exact Eligibility Criteria

Microsoft also runs the Explore Program for pre-final year students (2nd/3rd year), a summer internship combining program management, software engineering, and product design. Explore has its own simpler selection process (coding + PM round) and is a strong pipeline to full-time SDE roles.

Insider Selection Process (2026)

1. Resume Screening / Campus Shortlisting, CGPA filter, relevant project screening
2. Online Coding Test, HackerRank, 3 coding problems + MCQs (some campuses skip MCQs)
3. Technical Round 1, 45 min, coding (1-2 problems) + CS fundamentals
4. Technical Round 2, 45 min, coding (1-2 harder problems) + OOP/OS/DBMS concepts
5. Technical Round 3, 45 min, problem-solving focus + behavioral questions begin
6. Technical Round 4 (optional), System design for senior/M.Tech candidates; or additional coding
7. As-Appropriate (AA) Round, Conducted by Principal Engineer or Senior Manager; final recommendation
8. HR Round, Compensation, policies, cultural alignment

The AA Round is equivalent to Amazon's Bar Raiser, an independent evaluator not on the hiring team. They write an "AA: Strong Hire / Hire / No-Hire" recommendation that carries heavy weight. Unlike Amazon's Bar Raiser who focuses heavily on LP behavioral, Microsoft's AA often has a technical coding or design component.

Exam Pattern, Online Coding Test

The MCQ section covers: OS (process scheduling, deadlocks, memory management), DBMS (SQL queries, normalization, indexing), OOP (inheritance, polymorphism, virtual functions), Computer Networks (TCP/IP, OSI, HTTP), and C++/Java output prediction questions.

Solved Questions, Proven Patterns from Real Interviews

These questions reflect patterns documented in verified Microsoft interview reports from GeeksforGeeks and Glassdoor (2024 to 2026). Each problem below has the expected complexity bound and the canonical interview-grade solution that Microsoft interviewers look for.

Section 1: Coding, Easy to Medium

Q1. Reverse a Linked List in Groups of K

Given the head of a linked list, reverse the nodes of the list k at a time and return the modified list.

Example: 1→2→3→4→5, k=2 → 2→1→4→3→5

def reverse_k_group(head, k):
    # Check if there are at least k nodes remaining
    count = 0
    node = head
    while node and count < k:
        node = node.next
        count += 1

    if count < k:
        return head  # don't reverse incomplete group

    # Reverse k nodes
    prev, curr = None, head
    for _ in range(k):
        nxt = curr.next
        curr.next = prev
        prev = curr
        curr = nxt

    # head is now the tail of reversed group
    # Recursively reverse the rest and attach
    head.next = reverse_k_group(curr, k)
    return prev

# Time: O(n)  Space: O(n/k) recursion stack

Q2. Maximum Depth of Binary Tree

Given the root of a binary tree, return its maximum depth (number of nodes along the longest path from root to a leaf node).

def max_depth(root):
    if not root:
        return 0
    return 1 + max(max_depth(root.left), max_depth(root.right))

# Iterative BFS approach
from collections import deque
def max_depth_bfs(root):
    if not root:
        return 0
    queue = deque([root])
    depth = 0
    while queue:
        depth += 1
        for _ in range(len(queue)):
            node = queue.popleft()
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
    return depth

# Time: O(n)  Space: O(h) for recursive, O(w) for BFS (w = max width)

Q3. Find All Anagrams in a String

Given strings s and p, return all start indices of p's anagrams in s.

Example: s = "cbaebabacd", p = "abc" → [0, 6]

from collections import Counter

def find_anagrams(s, p):
    if len(p) > len(s):
        return []

    p_count = Counter(p)
    window = Counter(s[:len(p)])
    result = []

    if window == p_count:
        result.append(0)

    for i in range(len(p), len(s)):
        # Add new character to window
        window[s[i]] += 1
        # Remove old character from window
        old = s[i - len(p)]
        window[old] -= 1
        if window[old] == 0:
            del window[old]

        if window == p_count:
            result.append(i - len(p) + 1)

    return result

# Time: O(n)  Space: O(1), at most 26 letters

Q4. Binary Search Tree, Validate

Given the root of a binary tree, determine if it is a valid BST. A valid BST has: left subtree values < root, right subtree values > root, and both subtrees are also valid BSTs.

def is_valid_bst(root, min_val=float('-inf'), max_val=float('inf')):
    if not root:
        return True
    if root.val <= min_val or root.val >= max_val:
        return False
    return (is_valid_bst(root.left, min_val, root.val) and
            is_valid_bst(root.right, root.val, max_val))

# Time: O(n)  Space: O(h)
# Key: pass valid range constraints down the tree, not just compare with parent

Q5. Maximum Subarray Sum (Kadane's Algorithm)

Find the contiguous subarray with the largest sum. Return the sum.

Example: [-2,1,-3,4,-1,2,1,-5,4] → Output: 6 (subarray [4,-1,2,1])

def max_subarray(nums):
    max_sum = curr_sum = nums[0]
    for num in nums[1:]:
        curr_sum = max(num, curr_sum + num)
        max_sum = max(max_sum, curr_sum)
    return max_sum

# Time: O(n)  Space: O(1)
# curr_sum > num means it's better to extend current subarray
# num > curr_sum means start a new subarray from current position

Section 2: Medium-Hard Coding, Where the Bar Gets Raised

Keep reading, this difficulty level appears in Rounds 2-3 and is where most candidates either shine or stumble.

Q6. Lowest Common Ancestor of Binary Tree

Given a binary tree and two nodes p and q, find their lowest common ancestor (LCA).

def lowest_common_ancestor(root, p, q):
    if not root or root == p or root == q:
        return root

    left = lowest_common_ancestor(root.left, p, q)
    right = lowest_common_ancestor(root.right, p, q)

    # If both sides returned non-null, root is LCA
    if left and right:
        return root
    # Otherwise, return the non-null side
    return left if left else right

# Time: O(n)  Space: O(h)
# Elegance: single DFS, bottom-up propagation handles all cases

Q7. Matrix Rotation (90 degrees clockwise)

Rotate an n×n matrix 90 degrees clockwise in-place.

def rotate(matrix):
    n = len(matrix)
    # Step 1: Transpose (swap across main diagonal)
    for i in range(n):
        for j in range(i + 1, n):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

    # Step 2: Reverse each row
    for row in matrix:
        row.reverse()

# Time: O(n²)  Space: O(1), in-place
# 90° CCW: reverse each row first, then transpose
# 180°: reverse each row, then reverse matrix

Q8. Jump Game II (Minimum Jumps)

Given an array where nums[i] is the max jump length at position i, find the minimum number of jumps to reach the last index.

def jump(nums):
    jumps = 0
    current_end = 0
    farthest = 0

    for i in range(len(nums) - 1):
        farthest = max(farthest, i + nums[i])
        if i == current_end:
            jumps += 1
            current_end = farthest
            if current_end >= len(nums) - 1:
                break

    return jumps

# Time: O(n)  Space: O(1)
# Greedy: at each "jump boundary", extend to the farthest reachable point

Section 3: CS Fundamentals (MCQ Topics), The Secret Scoring Goldmine

Most candidates underestimate this section. These MCQs are easy marks if you've reviewed your OS, DBMS, and OOP basics. Don't throw away free points. For deeper CS fundamentals prep, also check our GATE CS Preparation Guide 2026.

Q9. What is the output of this C++ code?

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() { cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { cout << "Derived\n"; }
};

int main() {
    Base *b = new Derived();
    b->show();
}

Explanation: show() is declared virtual in Base. When called through a Base pointer pointing to a Derived object, the virtual dispatch mechanism calls Derived::show(). Without virtual, it would print "Base" (static dispatch).

Q10. DBMS, What is a Deadlock and how do databases prevent it?

Prevention strategies:

• Wait-Die: Older transactions wait; younger transactions are rolled back (die)
• Wound-Wait: Older transactions wound (force rollback) younger ones; younger wait
• Timeout: Rollback transactions that wait beyond a threshold
• Lock Ordering: All transactions request locks in the same global order

Detection: Maintain a wait-for graph; cycle = deadlock. Resolve by rolling back one transaction (victim selection: lowest cost/youngest).

Q11. OS, Explain the difference between a process and a thread.

Use processes for isolation (microservices, browser tabs). Use threads for parallelism within a task (web server handling requests, image processing).

Section 4: System Design (For Senior/M.Tech Candidates)

Q12. Design a URL Shortener (like bit.ly)

Functional Requirements: Short URL → long URL redirect; custom aliases; expiry; click analytics.

Scale: 100M URL shortenings/day, 10B redirections/day (100:1 read-write ratio).

Client → Load Balancer → Short URL Service
                              ↓
                    ID Generator (Snowflake-based)
                              ↓
                    Base62 Encoding → 7-char short code
                              ↓
                    SQL DB (url_id, short_code, long_url, expiry, user_id)
                              +
                    Cache (Redis): short_code → long_url (TTL = 1 day)
                              ↓
                    Redirect: 301 (permanent) or 302 (temporary, analytics-friendly)

Key decisions:

• 302 vs 301: 301 is cached by browser (faster, no analytics). 302 always hits server (slower, tracks every click).
• ID generation: Use distributed ID generator (Snowflake) to avoid hotspots. 7 characters of Base62 = 62^7 = 3.5 trillion combinations.
• Caching: 80% of traffic hits 20% of URLs (Pareto). Redis cache with 1-day TTL captures this effectively.
• Database: SQL (PostgreSQL) for ACID guarantees on URL creation. Read replicas for redirect lookups.

Q13. Design Tic-Tac-Toe (Object-Oriented Design)

Microsoft loves OOD questions that test class design, not just algorithms.

class TicTacToe:
    def __init__(self, n: int):
        self.n = n
        # Track row/col sums for each player (+1 for player1, -1 for player2)
        self.rows = [[0] * n for _ in range(2)]
        self.cols = [[0] * n for _ in range(2)]
        self.diag = [0, 0]    # [player1_diag, player2_diag]
        self.anti = [0, 0]

    def move(self, row: int, col: int, player: int) -> int:
        idx = player - 1
        sign = 1 if player == 1 else -1  # actually use idx

        self.rows[idx][row] += 1
        self.cols[idx][col] += 1
        if row == col:
            self.diag[idx] += 1
        if row + col == self.n - 1:
            self.anti[idx] += 1

        n = self.n
        if (self.rows[idx][row] == n or self.cols[idx][col] == n or
                self.diag[idx] == n or self.anti[idx] == n):
            return player
        return 0

# Time: O(1) per move  Space: O(n)

Section 5: Behavioral Questions

Q14. "Tell me about a project you're most proud of." (Technical deep-dive)

Microsoft interviewers follow up with very specific technical questions: "Why did you choose that algorithm?", "What was the time complexity?", "How did you handle X edge case?". Know every technical decision in your projects cold.

Q15. "How do you handle disagreement with a colleague or team lead?"

Microsoft's growth mindset culture values: listening first, presenting data/reasoning (not just opinions), willingness to be wrong, and following through on team decisions even if you disagreed. Show all four in your answer.

Q16. "Describe a time you learned something new quickly under pressure."

This maps to Microsoft's Learn It All vs. Know It All culture. Emphasize your learning process: how you identify knowledge gaps, what resources you use, and how quickly you can become productive. Concrete timeline + outcome matters.

Q17. "Where do you see yourself in 5 years at Microsoft?"

Acceptable answers show ambition tied to Microsoft's mission. Reference specific product areas (Azure, M365, Gaming/Xbox, Copilot), technical growth paths (SDE → Senior SDE → Principal), or impact goals (owning a product feature used by 100M users).

Q18. "Tell me about a time you failed."

Don't pick a non-failure disguised as a weakness. Pick a real failure. Show self-awareness, accountability (no deflecting blame), and concrete learning + behavioral change.

Salary & CTC Breakdown (SDE-1, MSIDC Hyderabad 2026), The Real Numbers

Microsoft's RSU vesting schedule (quarterly after 12-month cliff) is more favorable than Amazon's backloaded schedule. The actual Year 1 in-hand is higher relative to stated CTC compared to Amazon.

IDC Hyderabad vs. Other Locations: MSIDC Hyderabad is the largest Microsoft engineering center outside the US and works on core products (Windows, Azure, Bing, LinkedIn engineering). Some teams have competitive pay even within India standards.

SDE-2 (2-4 years): ₹38–55 LPA. Senior SDE (L62): ₹65–90 LPA. Principal SDE (L65): ₹1 Cr+.

10 Proven Interview Tips (From Candidates Who Got the Offer)

1. Microsoft prioritizes process over perfect solution. Start with a brute force, explain why it's suboptimal, then optimize. Interviewers want to see your thinking, not just the answer.

2. Practice drawing on a whiteboard or tablet. Microsoft virtual interviews often use a shared whiteboard (Whiteboard app or CoderPad). Practice coding without IDE assistance.

3. Review OOP principles deeply. Inheritance, polymorphism, encapsulation, abstraction, with C++ virtual functions and Java interface/abstract class distinctions. MCQ sections catch these.

4. Know SQL cold. JOIN types, GROUP BY vs HAVING, subqueries vs CTEs, window functions (ROW_NUMBER, RANK, LEAD/LAG). Microsoft loves SQL questions in technical rounds.

5. Prepare CS fundamentals as a single package. OS (scheduling, deadlocks, virtual memory) + DBMS (normalization up to 3NF, indexing, transactions/ACID) + Networking (TCP vs UDP, HTTP/HTTPS, DNS, REST vs SOAP), cover all in one study session.

6. Ask behavioral questions at the end of each round. Questions like "What does success look like in the first 90 days?" and "What's the team's biggest technical challenge right now?" signal genuine interest and are noted positively.

7. For OOD questions, start with requirements and use cases. Identify entities → define their relationships → define methods → then code. Never code before designing.

8. The AS-Appropriate round tests leadership instincts. Questions like "How do you prioritize competing features?" or "How would you mentor a junior engineer?" are common. Have frameworks ready (RICE for prioritization, pair programming + code review for mentoring).

9. Explore Program is a direct path to SDE. If you are in 2nd or 3rd year, apply to Explore aggressively. A high share of Explore interns convert to full-time SDE roles, per Microsoft India's publicly stated career-day material. The selection bar is lower than the regular SDE intern loop and the process is more holistic.

10. Microsoft cares about "growth mindset" explicitly. In behavioral rounds, always frame experiences as learning opportunities. "I failed at X, and here's what I changed" is stronger than "I succeeded at Y."

Previous Year Cutoffs, Track the Trend

Live Mock Test, May 2026 Edition

5 original questions written by Aditya Sharma, calibrated to the Microsoft 2026 batch difficulty. Click any option to lock your answer; solutions reveal after.