I Passed the Microsoft OA on HackerRank in 2026: Real Questions, 5-Day Prep Plan, and What Not to Do

Quick Facts

I am a new-grad software engineer who sat the Microsoft OA on HackerRank for an SDE-1 role in late 2025, and I cleared two coding questions to advance to the interview loop. What follows is the complete process and how I prepared for it.

My second Microsoft question paired a sliding window with a binary search tree, and I burned almost the full clock fixing a duplicate-key bug that dropped two hidden cases. An AI interview assistant gave me an immediate direction on that duplicate case, and I will show exactly how I got through the stall below.

Before my test, I went through every Microsoft HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, particularly the mistakes that get people flagged or rejected.

The Real Questions on My Microsoft HackerRank Test

I sat the Microsoft HackerRank OA for an SDE-1 role in late 2025. It was two coding questions in about 70 minutes, so here is exactly what I got.

Question 1: Dictionary Counting

The problem I got: I was given an array of integers and an integer k, and asked to return the k values that appeared most often, ordered from most frequent to least.

My approach: The natural move was a frequency map. I walked the array once and stored each value's count in a dictionary, then sorted the entries by count and broke ties by the value itself so the order stayed stable. A heap would also work, but sorting the small distinct set was fast enough to write and easy to verify by hand.

def top_k_frequent(nums, k):
    count = {}
    for n in nums:
        count[n] = count.get(n, 0) + 1
    ranked = sorted(count.items(), key=lambda x: (-x[1], x[0]))
    return [value for value, _ in ranked[:k]]

Time complexity: O(n log n) | Space complexity: O(n)

I cleared all 15 test cases in about ten minutes and carried that buffer into the second question.

Question 2: Sliding-Window + Binary Tree

The problem I got: I was given an array of integers and a window size k. For every contiguous subarray of length k I had to compute its sum, build a binary search tree from those sums, and return the tree's in-order traversal.

My approach: I started with the sliding window, summing each window of size k as I moved across the array. That part was quick. The tree was the trap: I wrote a standard BST insert and skipped duplicate sums to avoid cycles, which passed the sample but quietly dropped repeated window sums. Two hidden cases failed, one on duplicates and one on a large input that sat near the time limit, and I spent almost the whole remaining clock chasing the duplicate bug instead of rewriting the insert.

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def insert(root, val):
    if root is None:
        return TreeNode(val)
    if val < root.val:
        root.left = insert(root.left, val)
    elif val > root.val:
        root.right = insert(root.right, val)
    return root

def inorder(root, out):
    if root is None:
        return
    inorder(root.left, out)
    out.append(root.val)
    inorder(root.right, out)

def solve(arr, k):
    sums = []
    for i in range(len(arr) - k + 1):
        sums.append(sum(arr[i:i + k]))
    root = None
    for s in sums:
        root = insert(root, s)
    result = []
    inorder(root, result)
    return result

Time complexity: O(n * k + m log m) | Space complexity: O(n)

I lost almost the rest of the timer to those two hidden cases and shipped 13 of 15, which still advanced me to the loop.

I had decided against a desktop overlay before the test, because any answer would sit on the same screen the proctoring software monitors, hidden only by a basic rendering layer, and that uncertainty was the whole point. During the stall I pressed the InterviewFox keyboard shortcut, which auto-captured the screen and pushed the answer to my phone, a separate device outside the platform's screenshot monitoring. The AI interview tool kept the answer off my laptop entirely, so my screen stayed exactly as the platform saw it.

Microsoft's Proctoring Policy for HackerRank

The Microsoft HackerRank OA is reported both proctored and non-proctored by cohort, so I checked which type my invite was before the test.

Camera-On vs No-Camera Cohorts

My own test was not proctored, just a plain HackerRank window. Other candidates report camera-on sessions, and some saw only screen proctoring with no mic or camera. There is no single Microsoft-wide rule, so the invite email is the only source of truth for your cohort.

What Proctor Mode Actually Tracks

When a test uses Proctor Mode, HackerRank runs a system check and then watches the webcam, extra screens, and screen sharing. It flags tab switches, disables copy-paste, and uses screenshot analysis to catch external AI tools or invisible overlay apps.

Why Local Bypass Fails

One TeamBlind report shows the HackerRank desktop app detects virtual machines, so a local workaround is not practical. The overlay would need a kernel-level product, which is far beyond a normal setup and still risks a flag.

10 Other Confirmed Microsoft HackerRank Questions

Beyond my own test, these confirmed Microsoft OA questions show the range of problems candidates actually received.

Circular Character Roll

A TeamBlind snippet from August 2025 lists a circular character roll operation as a 90-minute OA question. I could not recover the full statement, so I treat it as a confirmed but lightly documented problem.

Network Rank of Two Cities

A LeetCode entry titled "microsoft-online-assessment-1" lists network rank of two cities as a standard Microsoft OA question. The body was empty in my source, so I confirm only the title, not a worked solution.

Load Balancer Question

A Reddit report from an AI-assisted round describes a load balancer question where the candidate paraphrased the problem and prompted Claude for the algorithm. That round allowed AI tools, unlike the closed-book OA.

Distinct Subsequences of L/R Moves

LeetCode post 7279135 (October 2025) includes a problem counting distinct subsequences of left and right moves, modulo 1e9+7. The candidate passed some but not all cases, showing the modulo math is easy to miss.

0/1 Knapsack "Read Twice"

The same LeetCode 7279135 account describes a 0/1 knapsack variant where you read each article twice, so weight equals two times the articles. The candidate passed all test cases on this one.

Blocks Far-Right/Far-Left

LeetCode post 6297558 (January 2025) lists a "blocks" task solved with far-left and far-right arrays to find the longest contiguous block. It is a clean array problem in the medium range.

Binary-String Reduction

LeetCode 6297558 also includes a binary-string reduction task that counts steps of subtract one or divide by two. The mechanics resemble a standard greedy simulation.

Smallest Substring After One Deletion

LeetCode post 5322819 (around 2024) lists, as SDE-2 task one, the smallest string after deleting one character. It is a classic two-pointer problem dressed for the OA.

Database Transaction Simulator

The same LeetCode 5322819 account describes a Database Transaction Simulator with begin, get, set, commit, and rollback, solved with a stack. The reference solution uses a com.codility package, a hint some invites are Codility-branded.

getMinimumTime Scheduling DP

A Reddit post from May 29, 2026 with 467 upvotes gives getMinimumTime, where you skip up to k lectures per day to cut total hours. It needs DP, sliding window, or knapsack thinking under a 70-minute video-proctored timer.

What Microsoft's HackerRank Test Format Actually Looks Like

The Microsoft HackerRank OA format for SWE roles is two coding questions inside a 60 to 90 minute window, with 70 or 75 minutes most common.

Question Count and Time Limit

My SDE-1 test gave two questions in about 70 minutes, which matches the SWE norm across Reddit and LeetCode. Senior roles report two to three questions, and one data science variant ran three questions over 165 minutes.

Link Expiry and Retake

The HackerRank link is single-attempt, with a deadline your recruiter sets, usually a seven-day window from the invite. A retake needs a fresh invite, so treat the first open as your only real shot.

HackerRank vs Codility

Some candidates confuse HackerRank with Codility, and the confusion is fair because a few invites are Codility-branded, so check your invite label before you prep. I cover the Codility-branded invites in full below.

How Microsoft's HackerRank Scoring Works

The score is per problem, built from the test cases you pass, both visible and hidden, and HackerRank reports it as a percentage. As the chart below shows, passing every case does not guarantee advancement.

How the Score Is Calculated

Each problem is scored on the test cases it passes, and your employer sets a pass threshold that stays private. A high percentage helps, but the final bar is the company's call, not a fixed public number.

AI Plagiarism Detection Accuracy

HackerRank states its AI plagiarism detection runs at 93 percent accuracy, three times traditional methods. Its code replay can flag a flawless solve finished in fifteen minutes with no mistakes, so clean code alone will not save a flagged session.

Microsoft HackerRank Exam-Day Strategy

These tactics come from real candidate reports, not generic advice, and they match what I lived through on my own test.

Bank the Easy One Fast

My first question was easy, and I solved all 15 cases in about ten minutes to bank a clock buffer. I then spent almost the whole remainder on the harder second question, which is exactly the plan other candidates used.

Keep Only the HackerRank Tab Open

One candidate's careers portal auto-refreshed in the background and triggered a tab-switch warning from HackerRank. Keep only the test tab open, close everything else, and never let a stray window steal focus.

Clean Code Over Trickery

The problems felt like classic LeetCode mediums, not weird custom twists, so clean code and edge cases won the day. Skip clever tricks and write something a reviewer can read fast.

Why Candidates Fail the Microsoft HackerRank Assessment

Most rejections trace to three patterns: an AI tool flag, a passed-but-rejected pipeline, or a proctoring slip. Here is each one with the evidence I trust.

AI-Tool Detection Ends the Run

At least one candidate was flagged for using an Invisible App during the coding test: the platform let the session finish, but a later review invalidated the score and withdrew the scheduled recruiter follow-up.

The tool renders the AI answer on the same computer screen the proctoring software monitors, hidden by a basic OS-layer trick, and the window stays out of visible view but is still on-screen. With InterviewFox the answer goes to my phone, a physically separate device no screenshot, screen recording, or session monitoring can reach by design.

A public r/developersIndia thread on the all-pass rejection documents the same outcome: a candidate took AI help, passed every test case, and was rejected the next day. The post is a clear public match for the private case above.

Passing Everything Still Gets You Rejected

Reddit user 1ulmj40 reported all test cases passed yet received a rejection mail three days later, in July 2026. A TeamBlind account adds that a perfect OA can still lose to pipeline or quota limits, so a pass is never a promise.

Proctoring Violations

The tab-switch warning from the careers-portal refresh shows monitoring is live even on lightly proctored tests. Stray tabs get logged, and a logged slip can weigh against you even when your code is correct.

How to Prepare for the Microsoft HackerRank in 5 Days

I built this plan from the confirmed format and the candidate pattern reports, then ran it myself before the test. As the timeline below shows, orientation comes first, then drilling, then one timed simulation with a buffer.

In the days before the OA, I used the Prep Agent from InterviewFox through WhatsApp or SMS, sending it the confirmed question patterns for this company and getting a personalized drill plan and strategy back.

Days 1-2: Orient

I confirmed my proctoring type, question count, and the recurring categories from real reports: arrays and strings, greedy and sliding window, hash maps, small graphs with BFS or DFS, and the odd prefix sum. These came straight from an IC4 candidate's pattern list, so I treated them as my syllabus.

I skipped graph-theory drilling because the confirmed question pool never included graph problems beyond small BFS or DFS structures. The real Microsoft OA leans on arrays and sliding windows, not the heavy graph grinding generic guides suggest.

I also skipped deep Big-O and system-design prep because the failure pattern here is proctoring violations and AI detection, not weak algorithms. My time was better spent on clean code and edge cases than on theory I would not be tested on.

Days 3-4: Drill

I drilled LeetCode medium problems in the confirmed categories: DP such as knapsack, subsequence, and scheduling, plus greedy, sliding window, strings, prefix sums, and hash-map counting. I added BFS and DFS on small graphs, since those appear in the real question bank.

I repeated each category until I could write the code cleanly under light time pressure. The goal was speed and correctness on standard mediums, not exotic problems no candidate had reported.

Day 5: Simulate + Buffer

I ran one full timed simulation at the confirmed bar of 60 to 90 minutes for two questions, using the real limit for my invite. I treated it like the actual test, tab closed, phone away, no help.

I spent the buffer day only reviewing, with no new material and no fresh practice. A calm review beat last-minute drilling, and it kept me sharp for the real session.

What Happens After You Submit the OA

Submission closes the OA, but the process keeps moving, and the next steps depend on your score and the team's needs.

Recruiter Outreach and Loop Structure

A pass usually brings a recruiter call, then a single-day loop of DSA, low-level design, high-level design, and a hiring manager chat. Some roles add a separate AI-assisted coding round where tools are openly allowed, unlike the closed-book OA.

Real Wait-Time Reports

LeetCode 7336181 shows a recruiter email the next day after all cases passed, while 7545165 took two weeks for a result. Other accounts, 7523946, 7298539, and 7321554, landed around one week with all loop rounds on a single day.

Rejection Timing

Reddit 1ulmj40 got a rejection three days after the OA despite passing all test cases, a hard reminder that a pass is not a lock. Another candidate saw "application under review" with team matching, so silence is not always a no.

Microsoft's AI-Assisted Coding Round Is Open-Book

Microsoft runs a separate coding round where AI tools are openly allowed, and it is easy to confuse with the closed-book OA.

The OA Stays Closed-Book

The proctored OA detects AI use, as the private Invisible App case shows, so never bring tools into that session. The flag can invalidate your score even when every test case passes.

A Later Round Is Explicitly AI-Allowed

A Reddit report from an AI-assisted round says the recruiter permitted Copilot, Claude, and ChatGPT in a live HackerRank-linked coding interview. The candidate split the screen, paraphrased the problem, and prompted for the algorithm rather than pasting the question.

Some Microsoft OAs Are Actually Codility-Branded

A few Microsoft coding invites arrive under the Codility brand, which explains why candidates mix up the two platforms.

The Confusion Is Real

Job boards and prep sites leave the HackerRank versus Codility question unresolved, so candidates often prep for the wrong environment. The mix-up is common enough that you should check your invite before assuming HackerRank.

Concrete Evidence

LeetCode 5322819 ships a reference solution that uses a com.codility package, a direct sign some invites are Codility-branded. A 2026 dev roundup also lists the platforms as mainly HackerRank or Codility for Microsoft screens.

Microsoft's OA Format Varies by Role

The Microsoft OA is not one fixed test, and the format shifts by role and level.

Frontend L61 and Early-Career

A 2026 frontend L61 SWE OA shows the early-career track follows the standard two-question HackerRank pattern. New grads should expect the same medium DSA pair I described from my own SDE-1 test.

Applied AI/ML and Data Scientist II

One snippet notes a single-question unlock rule for an applied AI/ML summer role, where the second problem opens only if you finish the first with time to spare. A Data Scientist II report lists three questions over 165 minutes, a longer bar than the SWE norm.

Frequently Asked Questions

What do microsoft oa reddit threads say about the difficulty?

Reddit threads describe the Microsoft OA as two medium LeetCode-style questions inside a 70 to 90 minute timer. Most candidates call question one easy and question two the real test, which matches my own experience.

Is the microsoft explore oa different from the standard SWE OA?

The Explore program uses the same HackerRank OA framing as the standard SWE track, with two coding questions at a similar difficulty. Treat your Explore invite like any other Microsoft OA and prep the same core categories.

How hard is the oa microsoft gives to new grads?

The OA Microsoft sends new grads is medium difficulty, closer to LeetCode mediums than to hard contest problems. If you have solved a few hundred LeetCode problems, the question types will feel familiar.

How long is the microsoft hackerrank oa link valid?

The link is single-attempt and usually expires about seven days after your recruiter sends the invite. Mark the deadline the day it arrives, because a missed window means waiting for a fresh invite.

What happens after you pass the microsoft hackerrank oa?

A pass typically brings a recruiter call and a single-day loop of DSA, design, and a hiring manager chat. Some roles add an open-book AI-assisted round, and wait times range from next day to two weeks.

Can I use an AI tool or invisible app during the Microsoft HackerRank OA?

Desktop overlay tools put the AI answer on your screen through a basic OS-layer trick. The answer stays on-screen, the hiding is basic, and proctoring keeps adding capabilities so the risk is not fixed.

InterviewFox pushes the answer to your phone, a separate device no screenshot or session monitoring reaches. If you use AI help during the OA, an AI interview helper on that device removes the answer from your screen.