Amazon Online Assessment 2026: Full OA Pattern + Tips

Quick answer (updated 8 June 2026): Amazon's SDE-1 Online Assessment in 2026 is a single proctored session, usually 2 to 3.5 hours, with three to four parts: a coding section with two DSA problems, a work-style survey mapped to the Leadership Principles, and in some batches a code-debugging section and a logical-reasoning section. Coding is auto-graded with partial scoring on hidden test cases. The structure below is compiled from 2022 to 2025 India candidate reports, not an official spec, so confirm the exact sections and timing in your assessment invite from amazon.jobs.

The OA is the filter that rejects most applicants before a human ever sees you. Clear it and you reach the interview loop; miss the auto-graded threshold and you are out silently. This guide breaks down every section and the timing strategy that gets you through.

Amazon OA Structure for SDE-1 Freshers

Based on 2022 to 2025 candidate reports for India SDE-1 batches, the OA typically contains these parts within one proctored session:

Sections and timings are candidate-reported (2022 to 2025 India SDE-1) and vary by batch. Some loops drop the debugging and reasoning parts. Your invite email lists the exact sections; treat it as binding.

The session is proctored, often via webcam and screen monitoring. Read the platform instructions before the timer starts, because once you begin a section you usually cannot go back to a previous one.

Section 1: Coding (the part that matters most)

Two DSA problems, typically one medium and one medium-hard, drawn from the high-frequency Amazon patterns: arrays and two-pointer, sliding window, hashing, trees, graphs, and dynamic programming.

Key facts from candidate reports:

• Partial scoring applies. Each problem has hidden test cases; you earn marks per passing case. A solution that handles 70 percent of cases beats one that crashes on all of them.
• Languages: typically C++, Java, and Python are offered. Use your fastest.
• No interviewer. You cannot ask clarifying questions, so read constraints carefully. Constraints tell you the expected complexity (n up to 10^5 means roughly O(n log n) or better).

Timing strategy: spend the first three minutes reading both problems. Solve the one you recognise first to lock in marks, then return to the harder one. Always write edge-case handling (empty input, single element, large values) because hidden tests target exactly those.

Section 2: Work-Style Survey

Around 80 statements rated on a Likert scale (strongly disagree to strongly agree). These map to Amazon's 16 Leadership Principles and screen for cultural alignment.

How to approach it, based on candidate reports:

• There is no objectively "correct" answer, but extreme or contradictory responses flag as inconsistent.
• Lean toward action, ownership, customer focus, and candour, which mirror the LPs, but stay honest and internally consistent.
• Avoid pegging every answer to the extreme end. Calibrated responses read as more credible.
• Some statements are paired to catch inconsistency; answer as the same person throughout.

This section is not just a formality. Candidate reports indicate Amazon weights LP alignment, and a poor or inconsistent survey can sink an otherwise strong OA.

Section 3: Code Debugging (some batches)

A set of six to eight short code snippets each contain a bug; you fix them to pass. These test reading comprehension and language fluency more than algorithm design.

Strategy: do not rewrite the snippet. Find the single intended bug, an off-by-one, a wrong operator, an uninitialised variable, a flipped condition. Run the provided example mentally to locate where output diverges from expectation. These are quick marks if you stay disciplined.

Section 4: Logical Reasoning (some batches)

Around 20 questions: number and letter series, syllogisms, seating arrangements, and basic data interpretation. Standard aptitude material.

This section is time-pressured, so do not over-invest in any single question. Mark and move. The reasoning section rarely carries the weight of the coding section, but a very low score here can still hurt borderline candidates.

Worked Example: A Typical OA Coding Problem

Problem: Given an array, return the maximum sum of any contiguous subarray of length exactly k.

Approach: Fixed-size sliding window. Compute the first window's sum, then slide by adding the incoming element and subtracting the outgoing one, tracking the maximum.

def max_sum_window(nums, k):
    if len(nums) < k:
        return None
    window = sum(nums[:k])
    best = window
    for i in range(k, len(nums)):
        window += nums[i] - nums[i - k]
        best = max(best, window)
    return best

Complexity: O(n) time, O(1) space. The brute-force recomputation of each window is O(n times k) and may time out on large inputs, which is exactly the kind of edge case Amazon's hidden tests target.

7 Timing and Test-Taking Tips

1. Read all coding problems first. Lock in the one you can solve fast before the clock pressures you.
2. Check constraints to infer complexity. They tell you the expected solution class.
3. Submit early and often. Partial scoring rewards incremental progress; do not wait for a perfect solution.
4. Handle edge cases explicitly. Empty input, single element, duplicates, large or negative values.
5. Stay consistent on the survey. Paired statements catch contradictions.
6. Do not panic on the debugging section. Find the one intended bug, do not rewrite.
7. Manage the proctoring rules. Stay in frame, no second monitor, no tab switching, or you risk auto-flagging.

How to Prepare for the Amazon OA

• Drill the high-frequency patterns until you can code them cold: sliding window, two-pointer, hashing, BFS/DFS, basic DP.
• Take at least three full-length timed mock OAs to build the 90-minute coding stamina.
• Read all 16 Leadership Principles so the work-style survey feels natural, not like guessing.
• Practice debugging by deliberately introducing bugs into your own solved problems and finding them under a timer.

See the Amazon syllabus 2026 for the topic-wise breakdown and the Amazon coding round questions 2026 for worked patterns.

Eligibility and Key Dates (Reference)

Amazon hires freshers through on-campus and off-campus SDE drives across the year. The reference criteria below are compiled from candidate reports for 2024 to 2025 India cycles and vary by drive; the binding eligibility is whatever the specific job notification on amazon.jobs states.

Eligibility figures are candidate-reported references (2024 to 2025), not official cutoffs. Amazon runs OA windows in multiple batches through the year; watch amazon.jobs and verified channels for live drives and exact dates. The job notification is binding.

More Worked OA Problems

Problem 1: Two Sum (Hashing)

Single-pass complement lookup, a common OA opener.

def two_sum(nums, target):
    seen = {}
    for i, x in enumerate(nums):
        if target - x in seen:
            return [seen[target - x], i]
        seen[x] = i
    return []

Time O(n), space O(n).

Problem 2: Number of Islands (Graph DFS)

Count connected land components by sinking each on first contact.

def num_islands(grid):
    rows, cols = len(grid), len(grid[0])
    count = 0

    def sink(r, c):
        if 0 <= r < rows and 0 <= c < cols and grid[r][c] == '1':
            grid[r][c] = '0'
            for dr, dc in ((1,0),(-1,0),(0,1),(0,-1)):
                sink(r + dr, c + dc)

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == '1':
                count += 1
                sink(r, c)
    return count

Time O(rows times cols). Grid problems are common in Amazon OAs.

Problem 3: Coin Change (DP)

Fewest coins to make an amount; bottom-up DP.

def coin_change(coins, amount):
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0
    for a in range(1, amount + 1):
        for c in coins:
            if c <= a:
                dp[a] = min(dp[a], dp[a - c] + 1)
    return dp[amount] if dp[amount] != float('inf') else -1

Time O(amount times coins). A frequent harder-slot OA problem.

How to Read Constraints and Manage the Clock

Two habits separate candidates who clear the Amazon OA from those who run out of time: reading constraints to choose the right approach, and disciplined clock management across the whole assessment. Both are learnable, and practising them is often more valuable than grinding additional problems.

Constraints are the OA's biggest hint, because there is no interviewer to ask. The size of the input tells you the complexity you are allowed. If an array can hold up to around ten to the fifth elements, an O(n squared) double loop will likely time out, and you should aim for O(n log n) or O(n) using sorting, a hash map, or a two-pointer or sliding-window technique. If the input is small, a brute force may pass and is worth submitting for partial credit while you refine. Reading the constraints first, before designing, prevents the common failure of writing an elegant but too-slow solution that passes the samples and fails the hidden large tests.

Clock management is the second habit. With two problems in roughly 90 minutes plus a survey, you cannot afford to sink 70 minutes into one problem. A workable rule is to read both problems early, solve the one you recognise first to bank marks, then give the harder one a fixed budget; if you are stuck near the end, submit your best partial solution rather than leaving it blank, since partial scoring rewards every passing test case. Reserve a few minutes at the end for edge cases and, where present, the work-style survey, which still counts. Candidates who manage time and exploit partial scoring routinely outscore stronger coders who mismanage the clock.

Why Candidates Lose Marks in the Amazon OA

Candidate reports point to recurring reasons strong candidates underperform:

• Leaving a problem blank. Partial scoring rewards passing some test cases; always submit a working partial solution.
• Skipping edge cases. Empty array, single element, all negatives, and overflow are common hidden tests.
• Rushing the survey. Inconsistent or extreme work-style answers can sink an otherwise strong OA.
• Misreading constraints. Constraints tell you the expected complexity; ignoring them leads to time-outs.
• Proctoring violations. Tab switching, a second monitor, or leaving the frame can auto-flag your attempt.

Preparation Timeline (6 to 8 Weeks)

• Weeks 1 to 2: Foundations. Arrays, two-pointer, sliding window, hashing. Solve 30 to 40 problems and read the 16 Leadership Principles.
• Weeks 3 to 4: Core DSA. Trees, BFS and DFS, graphs, and grid problems. Build 90-minute coding stamina.
• Weeks 5 to 6: DP and mocks. Coin change, knapsack, and longest-common-subsequence style problems, plus full timed mock OAs.
• Weeks 7 to 8: Polish. Three full mock OAs (two coding plus survey), debugging practice, and calibrated work-style answers.

Related Resources

• Amazon coding round questions 2026, the DSA patterns with full solutions
• Amazon leadership principles interview 2026, STAR answers for the behavioural rounds
• Amazon off campus drive 2026, eligibility, timeline, and hiring cycle
• Amazon placement papers 2026, solved past-drive papers
• Amazon syllabus 2026, topic coverage for the OA
• How to crack Amazon fresher coding round, strategy companion

FAQs: Amazon Online Assessment 2026

Q: How long is the Amazon SDE Online Assessment?

Candidate reports for 2022 to 2025 India batches describe a single session of roughly 2 to 3.5 hours depending on which sections are included. The coding section alone is usually 70 to 105 minutes. Your invite email states the exact duration.

Q: Is the Amazon OA proctored?

Yes, candidate reports describe webcam and screen proctoring. Stay in frame, avoid tab switching, and do not use a second monitor, since these can trigger automatic flags that disqualify your attempt.

Q: Does the work-style survey actually count?

Candidate reports indicate it does. It maps to Amazon's Leadership Principles, and inconsistent or extreme responses can hurt an otherwise strong candidate. Answer honestly and consistently, leaning toward ownership and customer focus.

Q: What score do I need to clear the Amazon OA?

Amazon does not publish a cutoff, and it varies by batch and role volume. Candidate reports suggest you generally need to substantially clear at least one coding problem and make solid progress on the second, plus a consistent survey. Maximise partial-credit test cases rather than chasing a single perfect solution.

Q: Can I go back to a previous section in the OA?

Usually no. Most candidate reports describe sections that lock once you move on. Finish each section before advancing, and read the platform's specific instructions at the start of your assessment.

Q: What happens if I fail the Amazon OA?

You typically receive a silent rejection or no further contact. Candidate reports mention a cooling-off period, often cited as 6 to 12 months, before you can reattempt for the same role family. Prepare properly before attempting rather than applying speculatively.

Q: How should I split my time across the two coding problems?

Spend the first few minutes reading both, then solve the one you recognise to bank marks before tackling the harder one. Because partial scoring applies, it is usually better to get strong coverage on both than to perfect one and leave the other blank.

Q: Do I need to handle every edge case in the OA?

Yes, as far as you can. Hidden test cases specifically target edge cases, empty input, single element, all negatives, large values, and overflow, so explicitly handling them often lifts your score more than micro-optimising the main logic.

Q: How much does the work-style survey actually affect my result?

Candidate reports indicate it carries real weight, since it maps to Amazon's Leadership Principles. Answer honestly and consistently, leaning toward ownership and customer focus; inconsistent or extreme responses can hurt a strong coding performance.