Home › Blog › Amazon Coding Interview Questions

FAANG Prep

Amazon Coding Interview Questions: The Real Bar

Six representative problems, the OOD round most candidates forget exists, and what Bar Raisers actually score the conversation on.

CoPilot Interview Engineering Team · Published May 17, 2026 · 14 min read

Amazon's interview loop is the most operationalized in tech. Five rounds, a fixed format, Leadership Principles integrated everywhere, and a Bar Raiser with veto power. The coding problems themselves are usually approachable - the friction comes from the fact that every coding round also costs you 15 minutes on behavioral questions, and the Bar Raiser is scoring your stories as carefully as your code.

This guide covers the six problem types Amazon asks most often (across SDE-I, II, and III loops since 2024), the object-oriented design round that catches candidates off guard, and the small judgment calls that separate a hire-strong from a no-hire when the algorithm itself is correct.

How Amazon's coding rounds differ from other FAANG

Three structural differences worth knowing before you sit down:

1. The 50/50 split. Every coding round at Amazon is half technical and half behavioral. The interviewer opens with one or two Leadership Principle questions, then transitions to the coding problem. The split is rarely formalized as "fifteen minutes of LP then forty-five of code" - it's interleaved. If you blow through the LP segment in two minutes with weak stories, you've already lost score in that round even if your code is perfect.

2. The Bar Raiser is a real veto. Other FAANGs have hiring committees that weigh interviewer feedback. Amazon's Bar Raiser is one specific senior engineer from a different organization who has trained 50+ candidates and has the authority to overrule the team. Their job is to ensure you would raise the bar - meaning be better than the average current SDE on the target team, not just meet the bar. A "lean hire" without Bar Raiser endorsement becomes a no-hire.

3. The OOD round is its own thing. Distinct from the system design round that L5+ candidates get. The OOD round asks you to design class structures and method signatures for a concrete real-world object (parking lot, elevator, deck of cards, vending machine). Algorithm complexity matters less; SOLID principles and clean interfaces matter more.

The full interview process by level

LevelLoop formatRounds
SDE-I (L4 / new grad)Online assessment + 1-2 phone screens + 4-round onsite2 coding + 1 OOD + 1 hiring manager (LP-heavy)
SDE-II (L5)1-2 phone screens + 5-round onsite2 coding + 1 OOD + 1 system design + 1 Bar Raiser
SDE-III (L6)2 phone screens + 5-6 round onsite1 coding + 2 system design + 1 OOD + 1 Bar Raiser + 1 hiring manager
Principal SDE (L7)Full onsite1 coding + 2 system design + 1 deep-dive on prior project + Bar Raiser + hiring manager

The phone screen is conducted on Amazon Chime, not Zoom. The onsite is conducted on Chime as well (Amazon stopped flying candidates onsite during 2022 and never restored in-person at scale).

Problem 1: Number of islands

Question: Given an m x n 2D grid of '1' (land) and '0' (water), count the number of islands. An island is surrounded by water and formed by connecting adjacent lands horizontally or vertically.

This is the most-reported single question across Amazon SDE-I and SDE-II loops since 2023.

def numIslands(grid):
    if not grid or not grid[0]:
        return 0
    rows, cols = len(grid), len(grid[0])
    count = 0

    def dfs(r, c):
        if r < 0 or r >= rows or c < 0 or c >= cols or grid[r][c] != '1':
            return
        grid[r][c] = '0'  # mark visited
        dfs(r + 1, c); dfs(r - 1, c); dfs(r, c + 1); dfs(r, c - 1)

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

The follow-up that filters strong from average: "What if the grid is too large to fit in memory?" The expected pivot is to union-find with disk-backed storage, or to process the grid in row-strips with a boundary-merge step. You don't have to implement it - but if you can't name the approach, the Bar Raiser flags it.

Problem 2: LRU cache

Almost as common as number of islands. Same problem as in our Netflix coding interview guide; same hash-map-plus-doubly-linked-list solution. What Amazon does differently is the framing: they describe a concrete use case (product page cache, session cache, configuration cache) and ask you to design the API first, then implement.

Spend the first three minutes on API design before writing implementation. The interviewer is watching for "Customer Obsession" - did you ask who uses this and what they need? An LRU cache for read-heavy traffic looks different from one for write-heavy.

Problem 3: Merge intervals

Question: Given an array of intervals where each interval is [start, end], merge all overlapping intervals and return an array of non-overlapping intervals that cover all the input intervals.

def merge(intervals):
    if not intervals:
        return []
    intervals.sort(key=lambda x: x[0])
    result = [intervals[0]]
    for start, end in intervals[1:]:
        if start <= result[-1][1]:
            result[-1][1] = max(result[-1][1], end)
        else:
            result.append([start, end])
    return result

The edge cases Amazon will probe:

Problem 4: Trapping rain water

Question: Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.

The naive O(n) space solution uses two arrays for max-left and max-right. The optimal O(1) space solution uses two pointers walking inward.

def trap(height):
    if not height:
        return 0
    left, right = 0, len(height) - 1
    left_max = right_max = water = 0
    while left < right:
        if height[left] < height[right]:
            if height[left] >= left_max:
                left_max = height[left]
            else:
                water += left_max - height[left]
            left += 1
        else:
            if height[right] >= right_max:
                right_max = height[right]
            else:
                water += right_max - height[right]
            right -= 1
    return water

What Amazon grades: can you reason about why the two-pointer approach is correct? The invariant is "the side with the smaller height is bounded by the max we've seen on that side." Many candidates write the code from memory without being able to explain why it works. The Bar Raiser will ask.

Problem 5: Word ladder

Question: Given two words beginWord and endWord, and a dictionary, return the length of shortest transformation sequence from begin to end, changing one letter at a time. Each intermediate word must be in the dictionary.

This is a BFS problem. The trick is recognizing the graph: nodes are words, edges connect words that differ by exactly one letter. Building this graph naively is O(n^2 * w) where n is word count and w is word length. The Amazon-level optimization is to use a pattern-based adjacency: for each word, generate patterns like "h*t", "*ot", "ho*" and group words by pattern.

from collections import defaultdict, deque

def ladderLength(beginWord, endWord, wordList):
    if endWord not in wordList:
        return 0
    word_set = set(wordList)
    patterns = defaultdict(list)
    L = len(beginWord)
    for word in word_set:
        for i in range(L):
            patterns[word[:i] + '*' + word[i+1:]].append(word)

    queue = deque([(beginWord, 1)])
    visited = {beginWord}
    while queue:
        word, depth = queue.popleft()
        for i in range(L):
            pattern = word[:i] + '*' + word[i+1:]
            for neighbor in patterns[pattern]:
                if neighbor == endWord:
                    return depth + 1
                if neighbor not in visited:
                    visited.add(neighbor)
                    queue.append((neighbor, depth + 1))
    return 0

If you can implement the pattern-based optimization without prompting, you're signaling SDE-II readiness. If you start with the naive O(n^2) and the interviewer has to guide you, that's SDE-I.

Problem 6: OOD round - design a parking lot

Question: Design the classes for a parking lot. Multiple levels, multiple spot sizes (compact, regular, large, motorcycle), entry/exit gates, payment.

This is not a coding-from-scratch round. You're sketching classes on a virtual whiteboard. The interviewer wants to see:

Common OOD prompts beyond parking lot: design an elevator system, design a deck of cards plus a Blackjack game, design an in-memory file system, design Twitter, design a vending machine, design a chess board.

How Leadership Principles weave into every round

You will hear at least one Leadership Principle question in every technical round. The most-asked LPs in coding rounds are:

The remaining LPs (Invent and Simplify, Frugality, Earn Trust, Insist on the Highest Standards, Think Big, Have Backbone, Hire and Develop the Best, Deliver Results, Learn and Be Curious, Strive to be Earth's Best Employer, Success and Scale Bring Broad Responsibility) appear in the dedicated behavioral round and the hiring manager round. Have one story for each. We cover the full prep in our Amazon behavioral interview guide.

Common pitfalls that get the no-hire

The bar by level

LevelCoding barLP barSystem design
SDE-I (L4)Solve LeetCode medium with light guidance2-3 strong STAR storiesNot assessed
SDE-II (L5)Solve medium independently; handle one hard follow-upOne story per critical LPDesign something at the scale of a single service
SDE-III (L6)Solve medium-hard; reason about distributed/scaled variantsMultiple stories per LP; show maturity in reflectionDesign a multi-service system; discuss trade-offs
Principal (L7)One coding round only; emphasis on architectureCross-organizational influence storiesDesign at the scale of AWS / Prime Video

30-day prep plan if you have an Amazon onsite scheduled

  1. Week 1: Drill all 15 patterns from our LeetCode patterns post. Solve 3 medium problems per pattern. That's 45 problems.
  2. Week 2: Pick the 8 problems Amazon asks most (number of islands, LRU cache, merge intervals, trapping rain water, word ladder, two sum, course schedule, reorder logs). Solve each three times, three days apart.
  3. Week 3: OOD warmup. Solve parking lot, elevator, deck of cards, in-memory file system, vending machine. Time yourself: 40 minutes each.
  4. Week 4: Write one STAR story per Leadership Principle. Memorize the 6-7 you'll lean on most. Run a solo mock interview with the timer.

Get structured coding answers and LP framing in your live Amazon loop

CoPilot Interview surfaces solutions and STAR-framed talking points during real Amazon Chime interviews. Free for Windows and macOS.

Download free

FAQ

What level of LeetCode questions does Amazon ask?

Roughly 70% medium, 20% easy with hard follow-ups, and 10% hard. For SDE-I (new grad / L4), expect more medium-easy and stronger weight on Leadership Principles. For SDE-II (L5), the median problem moves up the difficulty curve and a system design round is added. SDE-III adds a second design round.

What is the Amazon Bar Raiser and how does it work?

The Bar Raiser is a senior engineer from a different team trained to evaluate Leadership Principles and long-term hire signal. They sit in on at least one round and have veto power over hire decisions. Their goal is to ensure the candidate raises the bar of the team they join. In practice they ask deeper behavioral follow-ups and look for evidence that you would be a better-than-median engineer on the target team.

Does Amazon ask object-oriented design (OOD) questions?

Yes - this is the round many candidates forget about. Expect one round (sometimes labeled "design" but distinct from system design) where you design classes and interfaces for something like a parking lot, an elevator, a deck of cards, or an in-memory file system. The focus is class boundaries, inheritance vs composition, and SOLID principles, not algorithms.

How much do Leadership Principles matter in the coding rounds?

More than at any other FAANG. Every round at Amazon includes at least 10-15 minutes of Leadership Principle questions before or after the coding problem. The most-asked LPs in technical rounds are Customer Obsession, Ownership, Dive Deep, and Bias for Action. Have one specific story prepared for each of the 16 LPs - see our detailed Amazon behavioral guide.

What programming languages does Amazon allow?

Any major language: Java, Python, C++, JavaScript/TypeScript, Go, Rust, C#, Kotlin, Scala. The internal codebase is heavy Java, so picking Java signals familiarity, but interviewers explicitly do not penalize language choice. Use what you know best.

Related guides