Amazon Online Assessment 2026: Questions Breakdown and Prep Guide

Think the Amazon OA is just two coding problems and you're done? Not anymore. In 2026, Amazon's assessment is a multi-part gauntlet — coding challenges, a Work Simulation where you triage emails and debug scenarios under Leadership Principles pressure, and a Work Style survey. Here's the part that catches people off guard: passing all test cases doesn't guarantee you advance. Many rejections trace back to the simulation, not the code.

If you're only grinding LeetCode, you're preparing for half the test. Here's exactly what the 2026 Amazon OA looks like and how to pass every section of it.

What Changed in 2026 (and Why It Matters)

Amazon restructured the OA into distinct parts, and the non-coding sections now carry serious weight.

The OA is no longer just coding. Depending on the role and location, you'll face a multi-part assessment: a coding section (2 problems, 70-90 minutes), a Work Simulation (~50 minutes), and a Work Style Assessment (15-20 minutes). For SDE II, the format is 90 minutes of coding + 20 minutes of Systems Design scenarios + an 8-minute Work Style Survey. Check your invite email carefully — the structure varies.

Work Simulation matters as much as code. This is the biggest shift. The Work Simulation drops you into a simulated inbox with emails and messages from teammates and managers. You triage, respond, debug, and make prioritization decisions — all evaluated against Amazon's Leadership Principles. Candidates who ace the coding and bomb the simulation get rejected. Amazon has been explicit about this.

No pseudo code. No copy-paste. Amazon now requires syntactically correct code and monitors for copy-paste behavior. They expect original work written in real-time. Languages supported: Python, Java, C++, C#, JavaScript, Ruby, Swift, and C.

Pro tip: The Work Style Assessment is a situational judgment test mapped to Leadership Principles. There are no "right" answers in isolation — Amazon is looking for consistency with their culture. Think "Customer Obsession," "Ownership," and "Bias for Action" with every response.

When to Expect the OA for Your Role

The OA targets technical and leadership-adjacent roles. Here's the pattern:

Entry-level SDE I/II — expect it 100% of the time. The OA is the first technical filter after your resume clears. You'll typically receive the invite within 1-2 weeks of applying.

Data Scientists and Analysts — standard OA with domain-specific twists. Expect SQL or data manipulation alongside algorithmic problems.

Applied Scientists / ML Engineers — OA covers general DSA, with ML-specific questions appearing in later interview rounds.

Operations / Technical Program Managers — OA may include the Work Simulation and Work Style Assessment without heavy coding, depending on the role.

Some candidates may request waiver eligibility based on previous Amazon assessments, but treat preparation as mandatory regardless. Waivers are rare and unreliable.

Roles Commonly Requiring OA

Amazon uses the OA broadly across technical hiring:

• Software Development Engineer (SDE) I & II — the most common OA recipient
• Data Scientists / Analysts — standard OA with potential data-specific questions
• Applied Scientists / ML Engineers — general DSA in OA, specialized questions later
• Operations / Technical Program Managers — Work Simulation-heavy variant

Non-technical roles (product, design, HR) use different assessment formats and typically don't include the coding OA.

The Correct Way to Prep and Pass the OA Questions

Amazon's coding questions follow well-documented patterns. The trick isn't memorizing solutions — it's recognizing which pattern a problem is testing within the first 60 seconds of reading it.

1. Master core data structures and algorithms. Amazon's OA leans on arrays, hash maps, trees, graphs, sliding window, dynamic programming, and binary search. You don't need to solve 500 problems. You need to deeply understand ~10 patterns and execute them cleanly under time pressure.

2. Practice under timed conditions. Set a timer for 75 minutes and solve 2 medium-level problems. If you can't finish both, diagnose why — is it pattern recognition, implementation speed, or edge cases? Each failure mode has a different fix.

3. Don't skip the Work Simulation prep. This is where most candidates lose. Practice making prioritization decisions through an LP lens. For every scenario, ask: "What would someone with strong Ownership and Customer Obsession do here?" Amazon publishes their Leadership Principles — study them until the framework is instinctive.

4. Review Amazon-specific OA patterns. Amazon reuses question structures year over year. The specific inputs change, but the underlying patterns (two sum variants, interval merging, tree traversal, DP optimization) are consistent. Lodely maps company-specific prep directly to Amazon's OA patterns — the exact question types, the LP-aligned Work Simulation scenarios, and the coding patterns that keep showing up year after year.

5. Write real code, not pseudo code. Practice writing syntactically correct, compilable solutions from the start. Amazon flags pseudo code submissions. Pick your strongest language and write clean, variable-named code every time you practice.

Compiled List of Amazon OA Questions (2026 Edition)

These are the confirmed question types actively showing up in Amazon's OA. We've included LeetCode equivalents so you can practice the exact patterns.

1. Two Sum / Pair Sum Variations — Array/Hashmap → LeetCode #1
2. Longest Substring Without Repeating Characters — String/Sliding Window → LeetCode #3
3. Merge Intervals — Array/Sorting → LeetCode #56
4. Binary Tree Maximum Depth — Tree/DFS/Recursion → LeetCode #104
5. Coin Change / Minimum Coins — Dynamic Programming → LeetCode #322
6. Linked List Cycle Detection — Two-Pointer → LeetCode #141
7. Top K Frequent Elements — Heap/Hashmap → LeetCode #347
8. Sliding Window Maximum — Deque/Sliding Window → LeetCode #239
9. Number of Islands — Graph BFS/DFS → LeetCode #200
10. Product of Array Except Self — Prefix/Suffix → LeetCode #238
11. Valid Parentheses — Stack → LeetCode #20
12. Find Minimum in Rotated Sorted Array — Binary Search → LeetCode #153
13. Climbing Stairs — DP/Recursion → LeetCode #70
14. String Compression — Two-Pointer → LeetCode #443

Amazon's OA difficulty for SDE I sits at LeetCode Easy to Medium. SDE II pushes into Medium to Hard territory, occasionally with a Systems Design scenario question added.

Amazon Interview Questions

Recently asked in real interviews

These questions were asked recently in real Amazon interviews. Practice these and 4,000+ other questions from 1,000+ companies on Lodely.

Design a rate limiter.

system-design Medium

Move all zeros to the end of an array.

algorithmscoding Easy

Design Amazon Prime video.

system-design Medium

Given an array, find the two sum.

algorithmscoding Easy

Explore All Questions

Free to get started

1. Two Sum Variation

Type: Array / Hashmap

‍Difficulty: Easy-Medium

Find all unique pairs in an array that sum to a target value. The naive O(n²) approach works but won't pass time constraints on large inputs. The trick: use a hashmap for O(n) lookup, storing complements as you iterate. The subtle part is handling duplicates — if the array contains repeated values, you need to track whether you've already used an element. Sort first if the problem asks for unique pairs.

What this tests: Array manipulation, hashmap efficiency, and whether you think about edge cases (empty array, no valid pairs, all elements identical).

LeetCode cousin: Two Sum — the classic. Amazon's variant often asks for all pairs or unique pairs rather than just one.

2. Longest Substring Without Repeating Characters

Type: String / Sliding Window

‍Difficulty: Medium

Find the length of the longest substring with no repeating characters. Maintain a sliding window with two pointers and a hashmap tracking the last-seen index of each character. When you hit a repeat, jump the left pointer past the previous occurrence. This gives you O(n) time.

What this tests: Sliding window technique, state tracking, and whether you handle edge cases like empty strings or strings of all identical characters.

LeetCode cousin: Longest Substring Without Repeating Characters — direct match. Practice until the window mechanics feel automatic.

3. Merge Intervals

Type: Array / Sorting / Interval Logic

‍Difficulty: Medium

Given a collection of intervals, merge all overlapping ones. Sort by start time, then iterate — if the current interval overlaps with the previous, extend the end. Otherwise, push a new interval. The sorting is O(n log n) and the merge pass is O(n).

What this tests: Sorting, interval reasoning, and edge-case handling (single interval, fully nested intervals, adjacent but non-overlapping).

LeetCode cousin: Merge Intervals — Amazon has used this pattern consistently for years.

4. Binary Tree Depth

Type: Tree / DFS / Recursion

‍Difficulty: Easy

Find the maximum depth from root to the farthest leaf. Recursive DFS: return 1 + max(depth(left), depth(right)). Handle null nodes by returning 0. Alternatively, use iterative BFS with a level counter.

What this tests: Tree traversal fundamentals, recursion, and null-pointer handling. Amazon uses this as a warm-up question — expect it as Q1 with a harder Q2 following.

LeetCode cousin: Maximum Depth of Binary Tree — if you can't solve this in under 5 minutes, you need more tree practice before attempting the OA.

5. Coin Change

Type: Dynamic Programming

‍Difficulty: Medium

Given coin denominations and a target amount, find the minimum number of coins needed (return -1 if impossible). Build a DP array where dp[i] stores the minimum coins to make amount i. For each amount, iterate through coin denominations and take the minimum. Bottom-up iteration is cleaner than top-down recursion for this problem.

What this tests: DP fundamentals — can you identify overlapping subproblems, define a recurrence, and implement it without off-by-one errors? Amazon uses Coin Change variants to test whether candidates can decompose optimization problems.

LeetCode cousin: Coin Change — direct match. Master this and you'll recognize the pattern in Amazon's DP variants.

The Work Simulation — What Most Candidates Overlook

This section is ~50 minutes and simulates a day in an Amazon engineer's inbox. You'll see emails from teammates, messages from managers, bug reports, prioritization requests, and design tradeoff scenarios. The format is MCQs and multiple-select questions — no coding.

What it evaluates: Every response is scored against Amazon's Leadership Principles. They're looking for patterns like: Do you escalate appropriately? Do you prioritize customer impact over engineering convenience? Do you take ownership of ambiguous problems?

How to prep: Read Amazon's 16 Leadership Principles until you can name them from memory. For each scenario you encounter, ask: "Which LP is this testing?" Common ones: Customer Obsession (prioritize customer-facing bugs), Ownership (don't punt problems to other teams), Bias for Action (make a decision with incomplete info rather than waiting), and Dive Deep (ask for root cause, not surface-level fixes).

The critical mistake: Treating this section as an afterthought. Many candidates spend 100% of their prep time on coding and 0% on the simulation. Amazon has confirmed that Work Simulation performance is a key factor in pass/fail decisions.

What Comes After the OA

Technical Phone/Video Interview (45-60 minutes). 1-2 algorithmic problems plus behavioral questions. Emphasis on thinking out loud — Amazon wants to hear your reasoning, not just your answer.

Onsite Loop / Bar-Raiser (4-6 interviews, 45-60 min each). This is the real gauntlet: coding problems (Medium to Hard), system design for senior roles, and behavioral interviews grounded in Leadership Principles. The Bar-Raiser is a specially trained interviewer who ensures the hiring bar stays high. Prepare 5-6 STAR-format stories mapping to different LPs.

Post-Loop and Offer. Interviewers submit independent evaluations. The hiring committee makes a collective decision. Timeline: typically 4-6 weeks from OA to offer. Lodely covers the entire Amazon interview pipeline — coding, system design, and LP behavioral prep — so you're not scrambling between five platforms mid-process.

Amazon Compensation — What You're Playing For

Here's what Amazon is paying in 2026, per Levels.fyi:

• SDE I (L4): $183K median total compensation
• SDE II (L5): $272K median TC
• Senior SDE (L6): ~$400K+ TC
• Principal+ (L7+): up to $1.66M+ TC
• SWE Manager: $310K–$1.89M TC

Amazon's compensation structure is back-loaded on RSUs (stock vests ramp up in years 3-4), so the real value compounds over time. The difference between passing and failing this OA is a career trajectory worth millions in lifetime earnings.

Conclusion

The 2026 Amazon OA is more than a coding test — it's a multi-part assessment where the Work Simulation carries as much weight as your algorithm skills. Prep for both. Master the 14 coding patterns above, practice writing clean, syntactically correct code under time pressure, and study Leadership Principles until your instinct aligns with Amazon's culture.

If you want a structured path through Amazon-specific prep instead of piecing it together from random LeetCode lists, Lodely's Amazon prep guides cover the coding patterns, Work Simulation scenarios, and LP behavioral prep in one place. The OA is step one — nail it, and you're playing for $183K–$1.66M+ in total comp.