Interview Prep
6 Microsoft OA Reports 2026: Real Questions & Challenges
Qian Zhou · Marketing Specialist ·

What should you expect from a Microsoft Software Engineer Online Assessment in 2026? Knowing which coding patterns to practice is useful, but understanding how those problems appear in actual assessments can make preparation more focused. Even familiar algorithms can become challenging when candidates need to interpret unfamiliar requirements and produce efficient solutions under time pressure.
This guide draws on six Microsoft SWE coding assessment reports shared on Screna between April and September 2026. It examines real candidate-reported questions, identifies the challenges behind different assessment outcomes, and offers practical preparation strategies for internship, new graduate, and intermediate-level SWE candidates.
1. Microsoft SWE OA Quick Overview
What questions appear in Microsoft SWE OAs? Candidate reports cover a range of algorithmic problems, from array manipulation and interval scheduling to permutation checks and graph optimization. One permutation question also appeared in two Uber SWE OA reports, showing that preparing transferable coding patterns can be useful across companies.
What makes these assessments challenging? Recognizing an algorithm is only part of the task. Candidates also need to choose efficient implementations, handle problem-specific requirements, and manage their time. The reported outcomes show that completing one question successfully does not necessarily mean the remaining questions will go as smoothly.
How many questions are there, and how long is the OA? Two of the six reports explicitly describe assessments with two coding questions. However, the available evidence does not establish a standard question count or fixed duration for Microsoft SWE OAs.
How should candidates prepare? Focus on understanding algorithmic patterns rather than memorizing individual solutions. Practice evaluating complexity, testing edge cases, and completing coding problems under self-imposed time limits. Candidate experiences can help prioritize preparation topics, while role-specific mock interviews can support preparation for later interview stages.

2. Real Microsoft OA Questions From Candidate Reports
Six Microsoft SWE coding assessment reports from April to September 2026, categorized under Online Assessment on Screna, cover several coding patterns, including prefix sums, greedy algorithms, binary search, permutations, weighted graphs, and interval scheduling.
Prefix Sum, Greedy, and Interval Problems
Prefix Sum and Greedy Array Questions
Prefix sums and greedy algorithms appeared in a two-question Microsoft New Grad OA. According to an August 2026 candidate report, the first question involved prefix sums, and the candidate passed all 15 test cases. The second was an array problem involving minimum and maximum constraints that required greedy reasoning, but none of the 15 test cases passed. The report does not provide complete problem statements, so the specific requirements and optimal solutions cannot be confirmed.
Calendar Event Overlap
Calendar scheduling appeared in an April 2026 Microsoft coding experience. The task was to determine whether a new event could be inserted into a collection of existing non-overlapping events without creating a conflict. Although the core problem involved interval overlap, the candidate also reported spending considerable time handling standard input and output. This example highlights the importance of understanding interval boundaries and implementing input parsing correctly under time pressure.
Binary Search and Permutation Problems
Maximum Subsequence Length Under a Sum Limit
Repeated queries introduced an efficiency challenge in a June 2026 Microsoft coding report. Given an integer array and multiple queries, the task was to find the maximum length of a subsequence whose sum did not exceed each query value. The candidate's O(n × m) approach resulted in Time Limit Exceeded, making this one of the clearest examples of performance constraints in the selected reports. For nonnegative arrays, sorting and prefix sums can support efficient query processing with binary search, although the report does not fully establish the input value constraints.
Permutation Contiguous Segment
The permutation-contiguity problem asks whether the values from 1 through k occupy a contiguous segment of a permutation for every k from 1 to n. A May 2026 Microsoft SWE OA report described this task, which requires checking the positions of a growing set of values rather than simply examining adjacent elements. An efficient approach is to track the minimum and maximum positions of values 1 through k, allowing each result to be determined in constant time after preprocessing.
The same permutation-contiguity problem also appeared in two 2026 Uber SWE OA reports. In both the Microsoft OA experience and the Uber reports, candidates had to check whether the values from 1 through k occupied consecutive positions in a permutation for every k from 1 to n. The task required evaluating all prefixes of the value range, rather than checking whether the entire permutation was contiguous. This is a notable overlap across the two companies' reported coding assessments. It also makes position tracking a useful pattern to practice beyond a single company's OA. More examples can be found in Screna's Uber OA report roundup.
Graph Problems and Algorithmic Optimization
Minimum-Weight Cycle for Each Node
Graph optimization appeared in a May 2026 Microsoft SWE OA report. Given a weighted graph, the task was to find the minimum-weight cycle for each node, with each cycle starting and ending at that node while visiting at least one other node. The required output was 0 when no qualifying cycle existed. The candidate reported difficulty developing an efficient implementation, highlighting the difficulty of finding valid minimum-weight cycles while keeping the solution efficient. The report does not fully specify graph directionality or every restriction on valid cycles.
Choosing the Right Data Structure
Algorithmic efficiency also affected a September 2026 Microsoft SWE internship OA. The candidate passed all reported test cases on the first question but encountered performance problems on the second, where an inefficient data structure choice caused some tests to fail. The exact question was not disclosed, so the report is most useful as an example of how data structure selection can affect assessment results.
3. What Makes Microsoft OA Questions Challenging?
Across the six reports, the most consistent challenges involved algorithmic efficiency, implementation accuracy, and time management. Several candidates encountered difficulties even when they recognized the general type of problem they were solving.
Brute Force Solutions and Time Limit Exceeded
Several reports raised performance-related concerns, although the specific outcomes differed. The clearest confirmed TLE case involved an O(n × m) solution to a repeated-query problem. The permutation problem also illustrates how repeated scans can increase computational cost as input sizes grow. Another candidate reported failed tests associated with data structure efficiency, while the weighted graph problem raised concerns about computational complexity. These examples show why candidates should evaluate time complexity before implementation, particularly when a problem involves repeated queries or large input sizes. Only one of the six reports explicitly confirms a Time Limit Exceeded result.
Graph Edge Cases and Implementation Challenges
Graph problems can require additional reasoning beyond identifying a familiar algorithm. In the reported minimum-cycle problem, the main challenge was finding valid cycles under the problem's restrictions while maintaining acceptable efficiency. Candidates preparing for similar questions should consider disconnected components, nodes without qualifying cycles, and graphs containing multiple possible paths. These are suggested practice scenarios rather than confirmed Microsoft hidden test cases, since the original report did not provide a verified breakdown of failed tests.
The Second Coding Question and Time Pressure
Two of the six Microsoft reports explicitly described online assessments containing two coding questions. Both candidates completed the first question successfully but encountered difficulties with the second.
An August 2026 Microsoft New Grad OA report and a September 2026 SWE Internship OA report provide the following comparison:
| Candidate report | First question | Second question |
|---|---|---|
| New Grad OA, August 2026 | Prefix sum, 15/15 tests passed | Greedy array, 0/15 tests passed |
| SWE Internship OA, September 2026 | All reported tests passed | Some tests failed due to inefficient data structure selection |
The two reports suggest that completing an initial question successfully does not guarantee the same outcome on the next. Time allocation was also a challenge in the calendar scheduling experience, where input handling consumed a substantial portion of the available time. Practicing algorithm selection, complexity analysis, and implementation under self-imposed time limits may help candidates prepare for these situations. However, the available reports do not establish a standard two-question format or a fixed difficulty progression for Microsoft OAs.
4. How to Prepare for the Microsoft Online Assessment
Preparing for a Microsoft SWE Online Assessment requires more than practicing individual coding questions. A useful approach is to organize preparation around common algorithmic patterns, develop a consistent problem-solving process, and practice working within a time limit.
Practice Coding Patterns Relevant to Microsoft OAs
Start with the coding patterns most relevant to the role. For Microsoft SWE candidates, useful practice areas include arrays, prefix sums, greedy algorithms, binary search, interval problems, permutations, and graphs. Rather than memorizing solutions, focus on recognizing when each technique applies and how changes in the problem constraints affect the approach.
Screna's Microsoft interview questions provide candidate-reported examples that can help identify relevant topics. Use these reports to build a practice list, then work through additional problems with similar algorithmic requirements. For each problem, make sure you can explain why your approach works and what its time and space complexity will be.
Optimize Solutions and Test Edge Cases
Once you have a working solution, review its efficiency before considering the problem complete. Check the input constraints, identify repeated operations, and determine whether a different algorithm or data structure could reduce unnecessary work. This is particularly useful when moving from a straightforward solution to one that can handle larger inputs.
Build a consistent testing routine as well. Try minimum-size inputs, boundary values, empty or single-element cases when permitted, and inputs that may expose incorrect assumptions. Avoid relying only on sample tests. A solution should be checked for both correctness and performance before submission.
Practice Two-Question Assessments Under Time Pressure
Timed practice helps turn individual problem-solving skills into a repeatable assessment routine. One option is to complete two coding problems in a single session, using a self-imposed time limit rather than assuming Microsoft has a fixed assessment duration.
During each session, read both questions before deciding how to allocate your time. Reserve time for implementation and testing, and avoid spending the entire session refining one solution. Afterward, review where time was spent and whether you could have reached a correct, efficient solution more quickly.
You can also use Screna's Microsoft interview experiences to understand how candidates describe their assessments and the broader interview process. For preparation beyond coding, Screna's AI Mock allows you to enter a target role and job description for a question-and-answer-based mock interview. It can help you practice explaining your technical decisions and discussing relevant experience, although it does not replicate an OA coding environment.