Microsoft Online Assessment (Codility): What to Expect in 2026

The Microsoft online assessment (OA) is a timed, browser-based coding test that some Microsoft applicants take before any live interview, most often internship and new-grad software engineering candidates. Candidates most commonly report it on Codility, with two or three problems in about 60 to 90 minutes, scored automatically against hidden test cases for correctness and, on algorithmic tasks, performance. Microsoft does not publish the format, so your invitation email is the final word on platform, timing and rules.

This guide pulls together what Microsoft says officially, what Codility documents about scoring, and what candidates consistently report, then turns it into a prep plan. One ground rule up front: you complete the assessment on your own, under Microsoft's rules and the instructions in your invite. Everything below is preparation you do beforehand.

The Microsoft OA at a glance

Formats have shifted over the years and vary by region, team and hiring season, so treat these ranges as a planning envelope rather than a promise.

Who gets the Microsoft OA

Microsoft's own careers pages don't describe an online assessment by name. The student interviewing page says some openings ask you to write code or share examples of your work, and that specific preparation details arrive when you're invited. The technical interviewing page focuses on the live rounds. So the OA details here come from candidate reports and Codility's documentation, not from Microsoft.

Across those reports, the pattern is fairly consistent:

• Internships and new-grad roles are where the OA shows up most. In high-volume university hiring it works as the first technical filter before interviews. The Microsoft new grad interview process guide shows where it sits in that pipeline.
• Hiring events: some candidates report taking the OA shortly before a day of interviews.
• Experienced SDE roles get one less predictably. Some candidates report an OA with a debugging task; others go straight to a recruiter call and a technical phone screen.
• Some candidates skip it entirely. If your recruiter schedules a phone screen first, that is normal too.

If you have OAs from several companies lined up, our new grad online assessment guide covers how they differ.

What the questions look like

Candidates describe two kinds of tasks.

Algorithm tasks

These make up most of the test: a written problem statement, a function to fill in (on Codility it is usually named solution), a couple of examples, and a block of assumptions at the bottom that gives the range of N and of each value. Topics candidates commonly mention:

• Arrays and strings: counting, scanning, in-place updates, substring and subsequence questions
• Hashing, sorting, two pointers and prefix sums
• Dynamic programming, which comes up often enough in reports to deserve real prep time
• Trees, linked lists and graph traversal
• Bit manipulation and simple math

Debugging tasks

Some experienced-hire candidates report a task that hands you a short program with a bug and limits how many lines you may change (one 2024 report cites no more than two). The bugs tend to be the classic ones: an off-by-one boundary, a wrong starting value, a missed empty-input case. Read the line limit before you touch anything.

These are rules of thumb rather than platform guarantees, but they rarely steer you wrong.

How scoring works: correctness and performance

Codility's candidate documentation explains its scoring model, and it is worth understanding because it changes how you should spend your time.

• Hidden tests decide the score. After you submit, each task runs against test cases you never see. The more of them you pass, the higher your task score.
• Correctness tests check results on moderate-size inputs, including corner cases.
• Performance tests, on algorithmic tasks, run large inputs to check that your running time scales. On tasks without performance tests, correctness is the whole score.
• The example test doesn't count. An "OK" after you click Run only means your code compiled and handled the sample. Passing the example and still scoring poorly is common.
• Your code has to compile. When the timer runs out, whatever is in the editor is submitted automatically, and code that doesn't compile can't be evaluated.
• Submission is final. Once you submit a task you can't edit it, and the timer covers the whole assessment, not each task.

Here is what that means in practice. Say the task is to count the pairs of equal values in an array A, with N up to 100,000:

# Correct, but O(N^2)
def solution(A):
    count = 0
    for i in range(len(A)):
        for j in range(i + 1, len(A)):
            if A[i] == A[j]:
                count += 1
    return count

# Same answers in O(N): count each value, then add up the pairs
from collections import Counter

def solution(A):
    return sum(c * (c - 1) // 2 for c in Counter(A).values())

Both versions return the same answers, so both pass the correctness tests. At N = 100,000 the nested loop makes roughly five billion comparisons and fails the performance tests; the counting version makes one pass. That difference can be the gap between a partial score and a full one.

The score Microsoft requires isn't public. On Codility the employer sets its own bar, and cutoffs quoted on prep sites don't come from Microsoft. Aim for full correctness on every task, then the best complexity you can reach.

Ground rules: take it on your own

The OA is an individual test. Complete it yourself, in one sitting, under Microsoft's rules and whatever the invite and the platform's start screen specify. That means no help from other people, no AI tools and no outside code during the assessment. Practice tools, mock partners and AI tutors belong in the weeks before the test, not in the test window.

• Monitoring varies. Codility lets employers turn on integrity features such as tab-switch and copy-paste tracking, webcam snapshots or screen recording. Read the start screen to see what applies to your test.
• Write code you can explain. The live rounds that follow ask you to talk through edge cases and time complexity, so clear names and a simple structure pay off twice.
• Set up properly. Plan on a laptop or desktop with a current browser, a stable connection and a quiet block of time longer than the stated limit.
• Ask about accommodations early. Microsoft's interviewing guidance explains how to request accommodations, including for third-party virtual platforms. Raise it with your recruiter before you start, not after.

A three-week prep plan

If you already solve LeetCode mediums comfortably, compress this to a week of Codility-style practice and timed runs. If you're starting cold, stretch it.

Dynamic programming turns up in enough candidate reports that it deserves focused time. If it is your weak spot, work through the dynamic programming patterns guide during days 9 to 12 and re-solve each problem two days later from a blank editor.

Test-day strategy

1. Skim every task first. Spend the first few minutes reading all of them, including the assumptions blocks, then start with the one you're most sure of.
2. Bank correctness, then optimize. A correct brute force earns the correctness tests. Once it works, keep a copy in a comment and replace it with the faster version.
3. Write your own tests. Add custom cases for the minimum size, a single element, all-equal values, negatives and zeros, duplicates and the maximum values. Large values also catch integer overflow in Java and C++.
4. Keep it compiling. Run the code every few minutes. If time runs out mid-edit, code that doesn't compile can't be scored.
5. Budget the clock. With two tasks in about 90 minutes, a reasonable split is about 40 minutes each with ten minutes held back for a final check. Adjust to your actual limit.
6. Don't submit early. Submission locks the task. Submit when you've tested edge cases, not when the example passes.
7. Use your strongest language. Microsoft's technical interviewing guidance says you'll be asked to code only in the language you're strong in, and the same logic applies here.

After the OA: what comes next

Timelines vary, and Microsoft doesn't publish one for the OA. Its student interviewing page says your recruiter can help you understand the timeline for hearing back. If you pass, the next step is typically a recruiter call, a technical phone screen or the virtual interview loop. The Microsoft interview process and loops guide walks through each round.

The live rounds test skills the OA never touches. Microsoft describes its coding interview as a short 45-minute round in which interviewers look at how you clarify the problem, plan before you code, write clean code and test it yourself, corner cases included. Explaining your reasoning out loud is the new part. To rehearse it, a free AI mock interview in CoPilot Interview builds questions from your résumé and the job description, reads them aloud and scores each spoken answer with what worked and what to improve.

FAQ

Does every Microsoft applicant take an online assessment?

No. Candidates most often report the OA for internship and new-grad software roles and hiring events, while others go straight to a recruiter call, a phone screen or interviews. Your invite or recruiter will tell you whether you have one.

Is the Microsoft OA always on Codility?

Codility is the platform candidates report most often, but some recent reports describe HackerRank instead. The invitation email names the platform, so practice in that one.

How many questions are on the Microsoft OA, and how long is it?

Most reports describe two or three problems in about 60 to 90 minutes, sometimes including a short debugging task, though some tests run shorter or longer. The timer covers the whole assessment, not each question.

How is the Microsoft Codility test scored?

Each task runs against hidden test cases after you submit. Codility scores correctness on moderate-size inputs, including corner cases, and on algorithmic tasks also scores performance on large inputs; the visible example test does not count.

What score do I need to pass the Microsoft OA?

Microsoft does not publish a cutoff, and on Codility each employer sets its own bar. Aim for full correctness on every task and the best time complexity you can reach.

Can I use AI tools or get help during the Microsoft OA?

No. Complete the assessment on your own under Microsoft's rules and the instructions in your invite. Use practice tools and study partners only while preparing beforehand.