Assessment tips
- Confirm the current Amazon pattern from the drive mail before practising old papers
- Finish one problem or section fully before starting the next
- Revise the fundamentals listed in the round table on this page
Amazon Interview Experience 2026
Overview
How Amazon’s SDE interviews actually run, synthesized from recent candidate reports and Amazon’s public Leadership Principles hiring guidance. Amazon runs large-scale campus and off-campus SDE-1 drives in India, so this loop is common, not a rare, boutique process. We reorganized rounds, added prep notes, and flagged team/level variance - treat this as a prep map, not a script.
Reported total compensation for an India-based SDE-1 fresher hire is in the ₹26-32 LPA range (Levels.fyi median ~₹26L; base commonly ₹18-22L plus sign-on bonus and RSUs), though offers vary by college tier and location - treat this as a reported range, not a guarantee.
Online Assessment breakdown (SDE campus / new grad)
Based on Amazon’s SDE OA guidance and 2025-2026 candidate reports:
| OA section | Typical time | Reported content |
|---|---|---|
| Coding | ~70-100 min | Two problems: classic DSA plus occasional codebase/repo tasks (e.g. fix or extend an LRU cache for product search) |
| Work Styles | ~15 min | Multiple-choice work-preference and values alignment; stay consistent across answers |
| Work Simulation | ~60 min | Prioritise outages, respond to stakeholder emails, choose designs under latency/memory constraints |
| Feedback survey | ~5 min | Mandatory; incomplete submission can delay results |
Recent coding examples (candidate-reported): greedy + parametric search on warehouse configuration; graph clone with random pointers; partial passes often still rejected - treat hidden tests seriously.
Round-wise process
| Round | Duration | What it tests |
|---|---|---|
| Online Assessment (OA) | ~2-3 hrs total | Coding + Work Styles + Work Simulation (+ feedback survey) |
| Virtual onsite - Coding (1-2 rounds) | 45-60 min each | DSA (medium-hard) + 1-2 Leadership Principle questions |
| Virtual onsite - Design | 45-60 min | OOD for SDE-1; scalable system design for SDE-2+ |
| Bar Raiser | 45-75 min | Deep-dive Leadership Principles only, cross-checked against every other round |
| Hiring manager / offer | 20-30 min | Team fit, location, compensation, close |
Real interview experiences
Experience 1: SDE-1 (2025)
Profile: B.Tech CSE, tier-1 college, 2 internships, steady DSA practice, campus drive
Online Assessment
- Coding: maximum sum subarray with at most k elements, and cloning a graph with random pointers. Both needed all test cases passing, not just a partial solution.
- Work-simulation module: email-style prompts on prioritizing conflicting tasks and responding to a customer escalation.
- Behavioural MCQs framed around ownership and customer obsession - no free text, just scenario choices.
Virtual onsite - coding
- Design a data structure supporting insert/delete/getRandom in O(1) - hashmap + array-list approach.
- Longest substring with at most k distinct characters (sliding window), with a follow-up on optimising space.
- A Leadership Principle question slipped in mid-round: “Tell me about a time you went above and beyond for a customer.”
Virtual onsite - design
- Design a bookstore system (OOD): classes, relationships, methods, then a follow-up on handling concurrent orders.
Bar Raiser
- Design an LRU cache (medium-hard), then “How would you scale this bookstore system to millions of users?”
- Multiple deep follow-ups on a “took ownership of a project” story - the interviewer kept asking “what else did you consider, and why not that instead?”
Result: Selected
Takeaways
- What decided it: Distinct Leadership Principle stories (especially Ownership / Customer Obsession) that survived Bar Raiser follow-ups
- Common fail: Reusing one “led a project” anecdote across coding and Bar Raiser rounds
- How to practise: Map 6-8 STAR stories to different LPs; rehearse 8-10 follow-ups on a single story without contradicting details
Experience 2: SDE-1 (2024-2025)
Profile: B.Tech IT, tier-2 college, 1 internship, off-campus application
What differed
- OA coding leaned harder on graphs: Word Ladder-style shortest transformation, and merging k sorted lists.
- The design round asked for a simplified Twitter-style feed instead of a bookstore - same OOD depth, different domain.
- The Bar Raiser mixed one graph problem with unusually deep behavioural probing on a single “disagreed with a decision” story - three separate follow-up questions on that one answer.
Mistakes that hurt other candidates in the same drive
- Treating Leadership Principle questions as filler instead of real evaluation criteria in the technical rounds
- Reusing the same STAR story across two different rounds - Bar Raisers can see prior interviewer feedback
- Jumping into the design round without asking about scale or constraints first
Result: Selected
Takeaways
- What decided it: Clear technical thought process plus LP stories that survived deep “what else did you consider” probes
- Common fail: Treating LP questions in technical rounds as filler, or jumping into design without scale constraints
- How to practise: Pair every medium DSA drill with one LP prompt; open design answers by listing scale and constraints first
Experience 3: SDE-1 (2025-2026, OA-heavy path)
Profile: B.Tech CSE, tier-1 college, strong LeetCode prep, campus re-applicant after one OA rejection
Online Assessment
- Problem 1: optimisation combining greedy placement and binary search on capacity (warehouse-style narrative); ran out of time optimising after 11/15 visible tests passed - rejected at OA stage
- Second attempt (three months later): Problem 1 medium graph, Problem 2 debug/implement cache layer in provided repo; passed all tests on both
- Work Simulation: chose options that escalated customer-impacting bugs first, documented trade-offs in chat responses
- Work Styles: answered consistently with “ownership” and “high standards” themes without contradicting earlier choices
Virtual onsite (after OA pass)
- Coding: Remove duplicate letters variant returning largest lexicographic string (monotonic stack twist on LeetCode 316)
- Same round: Dive Deep and Bias for Action LP questions immediately after coding
- Design: bookstore OOD with concurrent order handling follow-up
- Bar Raiser: 45+ minutes behavioural only - deep follow-ups on one disagreement story and one customer-impact story; interviewer asked for metrics and alternatives considered
Result: Selected on second attempt
Takeaways
- What decided it: Clearing OA hidden tests on the second attempt, plus fresh Bar Raiser stories and consistent Work Simulation / Work Styles answers
- Common fail: Stopping after partial OA passes, or contradicting Work Styles choices against earlier simulation answers
- How to practise: Finish OA-style problems for all tests; treat Work Simulation emails as scored Customer Obsession drills
Bar Raiser preparation checklist
- 6-8 STAR stories mapped to distinct Leadership Principles (include 2 failures)
- Each story has numbers, your specific action (not “we”), and trade-offs rejected
- No story repeat across coding, design, and Bar Raiser rounds
- Ready for 8-10 follow-ups on one answer without contradicting earlier details
- Dive Deep technical narrative with concrete artifacts (logs, dashboards, queries)
- Questions for interviewer about team scope and bar for SDE-1 (shows Earn Trust / curiosity)
Questions that come up often
Coding / technical
- Maximum sum subarray with at most k elements
- Clone a graph with random pointers
- Longest substring with at most k distinct characters - sliding window
- Design an LRU cache - hashmap + doubly linked list
- Merge k sorted lists
- Design a data structure supporting insert/delete/getRandom in O(1)
System design / OOD
- Design a parking lot or bookstore system (OOD, SDE-1)
- Design a URL shortener or distributed cache
- Design a scalable order-processing system (SDE-2+)
Leadership Principles / behavioural
- Tell me about a time you went above and beyond for a customer (Customer Obsession)
- Describe a decision you made with incomplete data (Bias for Action)
- Tell me about a time you disagreed with your team’s direction (Have Backbone; Disagree and Commit)
- Give an example where you simplified something overly complex (Invent and Simplify)
- Tell me about the highest standard you’ve held a project to (Insist on the Highest Standards)
Practical tips for Amazon
- Solve the OA’s coding problems for all test cases, not just the visible ones - partial credit is less forgiving here.
- Treat the work-simulation module as a real evaluation, not a formality - it’s scored against the Leadership Principles too.
- Prepare a different STAR story for each Leadership Principle you’re likely to be asked about, and never repeat one across rounds.
- For design rounds, ask about scale and constraints before sketching a solution - Amazon interviewers note candidates who jump straight to an answer.
- In the Bar Raiser, expect the interviewer to keep pulling on one story with “what else did you consider” - have real alternatives ready, not just the option you picked.
HR interview
Amazon doesn’t run a separate generic HR round - Leadership Principles evaluation is spread across every stage, and the Bar Raiser doubles as the deepest behavioural check. Prepare STAR frameworks for the Leadership Principles on the dedicated page.
Sample answers for high-frequency questions
Use these as frames, not scripts - interviewers probe follow-ups.
Q. How do you design an LRU cache with O(1) get and put?
A. Combine a hash map with a doubly linked list. The hash map maps a key to the list node holding that key’s value, giving O(1) lookup; the doubly linked list keeps nodes in recency order with the most recently used at the head and the least recently used at the tail. On a get, look the node up and move it to the head. On a put, update the node and move it to the head if the key exists, otherwise create a node at the head and, if the cache is over capacity, remove the tail node and delete its key from the map. The list must be doubly linked so that unlinking a node found via the map is O(1) rather than requiring a scan.
Q. How do you find the longest substring with at most k distinct characters?
A. Slide a window while keeping a hash map of character counts inside it. Move the right pointer one character at a time and increment its count; while the map holds more than k distinct keys, decrement the count at the left pointer and remove the key when its count hits zero, advancing the left pointer. After each shrink the window is valid, so update the best length. Every character enters and leaves the window at most once, so the time is O(n) and the space is O(k).
Q. How do you build a data structure with insert, delete, and getRandom in O(1)?
A. Use a dynamic array of values plus a hash map from value to its index in that array. Insert appends to the end of the array and records the index in the map. Delete looks up the index, swaps the last array element into that slot, updates the moved element’s index in the map, pops the last element, and erases the key, which avoids the O(n) shift a naive removal would cost. getRandom simply picks a uniformly random index into the array, which works because the array stays densely packed with no holes.
Q. How do you compute the maximum path sum in a binary tree?
A. Do a post-order DFS where each call returns the best downward path sum starting at that node and going into at most one child, which is the node’s value plus the larger of its two child returns, clamped at zero so a negative branch is dropped rather than dragged along. Separately, at every node, consider the path that turns at that node, which is node value plus both clamped child contributions, and keep a running global maximum of those. The answer is that global maximum, not the return value of the root call. Time is O(n) since each node is visited once, and space is O(h) for the recursion stack, where h is the tree height.
Q. How do you merge k sorted linked lists?
A. Push the head node of each of the k lists into a min-heap keyed by node value. Repeatedly pop the smallest node, append it to the output list, and push that node’s next node if it exists. The heap never holds more than k nodes, so with N total nodes the time is O(N log k) and the extra space is O(k). The alternative is divide and conquer, merging lists pairwise in rounds, which reaches the same O(N log k) with O(1) extra space beyond recursion.
Tips from successful candidates
Interview tips
- Narrate trade-offs; expect “why” after every answer
- Only list projects you can defend under follow-ups
- Prepare 3-4 STAR stories for behavioural prompts
HR tips
- Know why Amazon, not just why the industry
- Be clear on location / notice period / higher studies
- Practise answers on the dedicated HR page
Sources
These links are research inputs we used to map round structure and recurring questions - not copied page mirrors. We reorganized reports into process tables, outcome notes, and prep takeaways for Amazon.
Cross-check the current drive mail or careers posting for timings and pattern changes.
For the company overview and FAQs, see the Amazon hub. For behavioural STAR prompts, use the Amazon HR page. For OA drills, use Amazon on placementpapers.app.