Amazon Online Assessment: Complete 2026 Guide to the Wrong Prep

25 min read

The phrase amazon online assessment does not describe one test. Amazon publishes two separate official pages for its software-engineering assessment alone, and they describe two different exams — one has a section the other does not. Add the versions for internships, analyst roles and AWS positions and the single phrase covers exams that overlap only partly — and diverge exactly where preparation time goes.

That is why so much amazon online assessment preparation misses. Candidates practise the format they read about, not the one they are sent. Here is what Amazon actually documents, where the versions diverge, and how to tell which one is coming.

Amazon Publishes Two Different SDE Assessments

This is the clearest evidence that the amazon online assessment label is doing too much work. Amazon maintains one assessment page for university and internship software-engineering roles and a separate one for SDE II. Neither links to the other. Their contents differ in a way that matters enormously if you prepare from the wrong one.

Read the two columns side by side and the problem is obvious. A candidate preparing for an SDE II assessment by reading new-grad advice will spend an hour rehearsing a Work Simulation that is not in their exam, and no time at all on the system design section that is. A new graduate reading SDE II advice does the reverse.

The internship version is different again: it drops the Work Simulation entirely, and Amazon says it “takes about 90 minutes to complete” rather than up to two hours.

There is one more contradiction hiding in that table, and it is Amazon’s own. Add up the university sections as documented — 70 minutes of coding, 60 of work simulation, 15 of work style, 5 of survey — and you get 150 minutes, against advice to reserve “up to two hours of uninterrupted time.” Budget two and a half hours rather than two.

One official page lists a system design section and no work simulation. The other lists a work simulation and no system design. Both describe the Amazon online assessment.

Amazon Says the Format Varies, in Its Own Words

You do not have to infer the variation. The official university SDE page states it: “Depending on the country the role is in, the OA will be in one or two parts. Check your OA email to determine your OA structure.”

That single sentence undercuts every guide that presents a fixed section list as the amazon online assessment format. It also gives you the correct first move, which almost no preparation article leads with: open your invitation email and read what it says you are being sent. That email is authoritative for your assessment in a way that no third-party guide, including this one, can be.

It is worth knowing what the amazon online assessment is for, too. Amazon describes it as evaluating “coding skills, technical problem solving, and Amazon’s Leadership Principles,” and is explicit that “No Amazon-specific knowledge is needed to complete the OA successfully.” Time spent memorising Amazon trivia is time wasted.

What Is Actually in the Coding Section

The coding section is the most consistently reported part of the amazon online assessment, and the accounts broadly agree with the official pages. Two problems. Seventy minutes at university and intern level, ninety at SDE II. The difficulty most commonly reported is LeetCode-medium, with candidates describing one easier problem and one harder.

One first-hand account on LeetCode Discuss adds a detail worth knowing: “The first section featured two medium-level Data Structures and Algorithms (DSA) problems with a 70-minute time limit. Each problem had 15 test cases (2 public and 13 private).” If that split holds for your amazon online assessment, passing the two visible cases tells you very little.

For SDE II, Amazon is specific that submissions must be “syntactically correct code—no pseudo code.” It also notes, in full, that “While the 90-minute Coding Challenge is the only timed section, we recommend you reserve two hours to complete the OA.” The untimed sections still have to be finished: “To successfully submit your assessment, you must complete all sections.” Skipping the behavioural parts is not an option.

What to Actually Practise for the Coding Section

Amazon publishes its own topic list, and it is deliberately broad: programming language, data structures, algorithms, coding, object-oriented design, databases, distributed computing, operating systems, internet topics, and machine learning. That is a list for its whole technical hiring process, not for the 70 or 90 minutes of coding you are about to sit.

Two sentences on that page are worth more than the list itself. Amazon states that “Your interviewers won’t be evaluating your ability to memorize all of the details for each of these topics,” and recommends “reviewing computer science fundamentals and practicing coding outside of an integrated development environment.” That second one is unusually concrete advice, and almost no preparation guide repeats it: practise without autocomplete, without a linter, and without running your code after every line, because that is the environment you will be in.

For what actually shows up, we read roughly twenty first-hand candidate accounts published between 2024 and 2026 — LeetCode Discuss write-ups, Blind threads and personal blog posts — and tallied the problem shapes. This is a tally, not a survey. Nobody publishes real frequency data for the amazon online assessment, so read the ordering as a rough steer rather than a probability.

The last two rows need care rather than confidence. We could not find a single 2024–2026 first-hand account describing a graph traversal, grid BFS, sliding-window or merge-intervals problem in the OA coding section itself. Those problems appear constantly in accounts of the later interview rounds, and constantly in prep listicles — but not in the descriptions of the assessment.

That is an absence in about twenty accounts, not a finding that Amazon stopped asking them — and the biggest confound is that many candidates never name their problem types at all, reporting pass rates and timings instead. The write-ups that do get published also skew toward campus and internship pipelines rather than experienced US and UK hiring, because that is where candidates post. Treat those rows as lower priority than arrays and hash maps, not as safe to skip.

The hard part is usually the prompt, not the algorithm

The most consistent thing candidates say about the amazon online assessment coding section is not about algorithms at all. It is that the problems are buried in long operational stories, and that decoding the story eats the clock.

A candidate describing an SDE II assessment in September 2025 put it bluntly: “These were nothing like standard textbook LeetCode problems where you can directly apply 2-pointers, heaps, sliding window, or classical DP.” The same account adds: “I was literally staring at the screen for an hour and still couldn’t figure out the problem statements.”

Other candidates describe the same exams as ordinary mediums wearing a costume — twisted enough that you cannot pattern-match the title, standard once you strip the wrapper off. Both descriptions come from real accounts, and the difference may partly be level. Either way the practical instruction is the same: rehearse the translation step. Given a wordy prompt, practise writing down the inputs, the outputs, the constraints and the actual question in your own words before you write any code.

Two things the coding section scores that prep material skips

The written explanation counts. A candidate describing an SDE 1 (L4) assessment in July 2025 wrote: “This round consisted of 2 coding questions and their respective explanations. I was expected to write the solution and also explain the approach used for each.” Several other accounts describe the same approach box. Budget minutes for it rather than discovering it with four minutes left.

Efficiency is enforced through hidden tests, not a separate score. Candidates repeatedly describe passing the visible cases, submitting, and failing hidden ones on large inputs. Amazon publishes no complexity rubric, and we found no evidence it scores complexity separately — but a solution that is one order too slow fails the same way as a wrong one. Check your complexity against the stated constraints before you submit, not after.

One more mechanical detail candidates consistently report: you are told how many tests passed, but not which ones or what they contained, and printing for debugging generally does not help you. Hand-checking your own edge cases matters more here than in ordinary practice, because the platform will not show you the case that broke.

A Worked Example Under the Clock

What follows is our own practice problem, not a real Amazon question. We have no access to the live question bank, and anyone presenting exam questions as genuine should be treated with suspicion. What this does replicate is the documented amazon online assessment shape: an operational story with a small algorithmic core, and an obvious first solution that passes the examples and dies on the hidden tests.

Give yourself 35 minutes — half of the 70 Amazon documents for two problems at university level. If your own assessment turns out to be 90 minutes, as several candidate accounts of entry-level OAs report, treat the extra time as a cushion rather than a different plan.

Minutes 0–6: translate it

Write the problem down in your own words before touching the keyboard. Stripped of the warehouse, it says: repeatedly replace two equal values with one value that is one greater, until no two values are equal. How many values are left?

Now test your reading against a tiny case by hand. Three packages of priority 1: two merge into a single 2, one 1 is stranded, and nothing further can merge. Two remain.

Minutes 6–10: find the reduction, and the trap

The obvious solution is to simulate: scan the list for a matching pair, merge it, start again. That is correct, and it is the answer that fails. Each merge costs a full scan, so the work grows roughly with the square of the input, and the hidden tests will be much larger than the examples.

The reduction is the useful move. Sort the priorities and think about them one level at a time: at any priority, pairs merge upward and at most one item is left behind. Two 1s become a 2. Two 2s become a 3. This is binary carrying — the number of survivors at each level is simply the count at that level modulo two, and half the count carries up to the next.

Minutes 10–26: write it

import heapq
from collections import Counter

def packages_remaining(priorities):
    counts = Counter(priorities)
    heap = list(counts.keys())
    heapq.heapify(heap)
    remaining = 0

    while heap:
        p = heapq.heappop(heap)
        c = counts.pop(p, 0)
        if c == 0:
            continue
        remaining += c % 2          # odd one out stays
        carry = c // 2              # pairs move up a level
        if carry:
            if p + 1 in counts:
                counts[p + 1] += carry
            else:
                counts[p + 1] = carry
                heapq.heappush(heap, p + 1)

    return remaining

The heap matters. Processing levels in increasing order is what makes a single pass correct, and using a heap of the priorities that actually occur — rather than counting from the smallest to the largest integer — keeps it fast when priorities are sparse. An input of [1, 1000000000] should not cost a billion steps.

Minutes 26–31: check the edges yourself

You cannot see the hidden cases, so generate your own. An empty list returns 0. A single package returns 1. Four packages at the same priority collapse to one. Three collapse to two. All-distinct input returns its own length, because nothing merges. Then confirm the complexity out loud: each package is counted once, each level is popped once, and carrying adds at most a logarithmic number of levels — comfortably linearithmic, not quadratic.

Minutes 31–35: write the approach note

Because the explanation is scored, draft it deliberately rather than in a panic. Something like: Counted each priority with a hash map, then processed priorities in increasing order using a min-heap. At each priority, count modulo two survives and count over two carries to the next priority, which is binary carrying. Chose this over direct simulation because simulation is quadratic in the number of packages and would time out on large inputs. Complexity is O(n log n) time and O(n) space.

That paragraph takes ninety seconds and tells a reviewer you understood the constraint, not just the puzzle. Note that the code above is ours and we have tested it, including against a brute-force simulator on hundreds of random inputs — but it is a teaching example, not a solution to anything Amazon has asked.

The Rules Almost No Guide Mentions

Amazon publishes conduct rules for the coding section that are more permissive than most candidates assume in one direction and stricter in another. Both are worth reading before you start — with one caveat this article has to apply to itself. These rules appear on the university and internship page. The SDE II page publishes no equivalent set, so treat them as documented for the entry-level assessment and likely, but not stated, for the rest.

On references, verbatim: “During the Coding Assessment, you’re allowed to use publicly accessible online resources (e.g., the Java Developer Kit or Standard Template Library). Don’t access sites that require a login or are private repositories. Your browser usage is logged.”

So language documentation is fair game. Anything behind a login is not, and Amazon says plainly that it is watching which is which.

On the mechanics, also verbatim: “Don’t use the print screen functionality, because your session will be terminated, and you’ll be locked out. Avoid copying and pasting in the assessment. We expect this to be your own code.”

Ending your own amazon online assessment by reflexively screenshotting a problem statement is an avoidable way to fail, and it is documented on Amazon’s own page rather than buried in a terms-of-service link.

The Debugging Section Prep Content Still Teaches

Search for amazon online assessment practice material and you will find guides describing a debugging round: a section where you fix logical errors in supplied code rather than write your own. One archived account of a 2021 campus assessment describes it as a “Simple code debugging section, in which you have to fix the basic logical errors in the code like brackets in for loop etc,” alongside an aptitude round of roughly 25 questions.

Neither section appears on either of Amazon’s current SDE assessment pages, and we found no recent account of an aptitude round. Debugging is a more complicated story. A small number of recent accounts describe a bug-fixing component returning in a different form — not a spot-the-error quiz, but an AI-assisted task inside an existing code repository. We weigh that evidence below.

Be careful how you read that. We could not find any source, official or otherwise, documenting that Amazon removed these sections — only that its current documentation does not list them. That is weaker than a removal notice. It also matters that the 2021 account describes an on-campus assessment, and Amazon states that the format varies by country, so this may be a difference of geography as much as of era. The honest conclusion is that classic debugging drills are a low priority, not a proven waste.

Where the Accounts Genuinely Disagree

Amazon online assessment guides tend to present one tidy structure. The real accounts do not line up that neatly, and the disagreements are informative.

• How long you actually get. Amazon’s page advises setting aside up to two hours. One candidate account describes a window of five and a half hours with an expected completion time of about ninety minutes. Those are not necessarily contradictory — a deadline window is not working time — but a candidate expecting a two-hour countdown and receiving a multi-hour window will misjudge their pacing badly.
• What the non-coding sections are called. Amazon’s university page lists a “Work Simulation.” A detailed April 2026 candidate write-up instead describes a “Workplace Judgment / Situational Judgement Test” and a separate “Business Case / Trade-off Evaluation,” and never uses the phrase Work Simulation at all. Whether that is the same instrument described differently or a genuinely different battery is not something we could resolve.
• Timed or untimed. The SDE II page says the coding challenge is the only timed section. Candidate accounts give minute estimates for the later sections while noting they carry no time limit. It is easy to mistake an estimate for a countdown and rush answers that were never being clocked.

What About AI Tools?

Amazon’s position on AI assistance during hiring is documented. Amazon spokesperson Margaret Callahan told GeekWire in March 2025 that the company prioritises ensuring that candidates hold a high bar for the relevant technical competencies, and that “when applicable candidates must acknowledge that they won’t use unauthorized tools, like GenAI, to support them during the interview or assessment process.” Note the qualifier: this is an acknowledgement Amazon requires where it applies, not a blanket statement about every assessment. Internal guidance seen by Business Insider and reported by IT Pro the same month reads: “To ensure a fair and transparent recruitment process, please do not use GenAI tools during your interview unless explicitly permitted,” adding that “Failure to adhere to these guidelines may result in disqualification from the recruitment process.”

Beyond the ban itself, two claims circulate that deserve different treatment. The first is that Amazon has added human-verified rounds in response to AI use. That traces to one candidate’s account of what a recruiter told her — and that candidate was sitting a multiple-choice SQL test for a business intelligence role, not the SDE assessment. We could not corroborate it.

The second claim is more interesting, and we were initially too quick to dismiss it. Several candidates now describe an amazon online assessment that includes an AI-assisted task inside an existing code repository: you are given a codebase and a small number of bugs to fix, with an AI assistant built into the assessment itself. One account describes a 60-minute section of this kind alongside a 40-minute DSA question, and a small number of others describe something similar. Every one of these accounts is anonymous, and at least one drew a challenge to its authenticity in its own comment thread.

That makes it thinner than a fact and thicker than a rumour. Amazon’s live SDE pages describe no such section, and one site publishing a guide to the format states plainly that “Amazon has not published one universal AI-assisted OA format.” If your invitation email mentions a repository, a development task or an AI assistant, believe the email over any guide, this one included.

How to Prepare for the Right Amazon Online Assessment

• Read the invitation email first. Amazon says the structure varies by country and tells you to check the email for yours. Do that before reading any guide, including this one.
• Match the guide to your level. University and intern advice describes a Work Simulation. SDE II advice describes a system design section. Using the wrong one wastes preparation on an exam you are not sitting.
• Budget the coding section properly. Two problems in 70 minutes at entry level, 90 at SDE II. Practising against that clock matters more than the total number of problems you have solved.
• Do not skip the behavioural sections. Amazon requires all sections to be completed for the assessment to submit, and the Leadership Principles are explicitly part of what is assessed.
• Skip the Amazon trivia. Amazon says no company-specific knowledge is needed. Spend that time on the coding clock instead.
• Use Amazon’s own free material before anyone else’s. The university page links a preparation course for full-time roles, a separate one for internship roles, and an Online Assessment practice test. They are free, they are Amazon’s, and almost every third-party guide to the amazon online assessment competes with them without mentioning they exist.

A 3-Day Plan and a 7-Day Plan

Both amazon online assessment plans assume you already write code and are not learning a language from scratch. They deliberately spend the first block on the invitation email, because knowing which version you are sitting changes what the rest of the time is for.

If the assessment is in three days

If you have a week

The clock is the part people skip when preparing for the amazon online assessment, and it is the part that matters. Solving thirty problems untimed prepares you worse than solving eight against a 35-minute limit with an approach write-up at the end of each.

For how other employers structure their screening tests, our coding assessment test guide covers the major platforms from the candidate’s side, and our Amazon software engineer interview guide covers what comes after the assessment. Amazon’s own university SDE online assessment page and its separate SDE II assessment page are the primary sources for the official material quoted above, together with its software development topics page. Candidate accounts are described inline with their date and level where we have them. Several are anonymous posts on LeetCode Discuss, Blind and levels.fyi, and we have said so rather than dressing them up as verified sources.

Amazon Online Assessment FAQ

The Honest Summary

A lot of bad preparation for the Amazon online assessment is not lazy. It is aimed at the wrong exam. Amazon runs several assessments under one name, documents two of the software-engineering versions on pages that do not acknowledge each other, and says openly that the structure changes by country.

The fix costs nothing. Open the invitation email, identify which version you have been sent, and only then decide what to practise. Everything else in this guide is secondary to that one step.