abhinav.dev
My StoryMock InterviewsSystem DesignInterview ExperiencesGet notified
← All interview experiences
AmazonOffer

SDE-2 (SDE II) — Interview Experience

May 2026Hyderabad, India4 min read4 rounds
Leadership PrinciplesData StructuresSystem DesignBar Raiser

I interviewed for an Amazon SDE-2 role and came away with the offer. Below is a round-by-round breakdown — the timeline, what was asked in each round, what the interviewers were really probing for, and the verdict.

Timeline

  • Referral / application: mid-May
  • Onsite loop (virtual, 4 rounds): third week of May
  • Offer call: ~2 business days after the loop
  • End to end: ~8 business days

Round 1 — Coding (Data Structures & Algorithms)

  • Format: 60 minutes on Amazon's own live-coding platform (similar to LeetCode).
  • Asked: two problems, both medium–hard:
    • A variation of Number of Islands — a graph problem (LeetCode 200).
    • A variation of Coin Change II — a DP problem (LeetCode 518).
    • Two Leadership Principles: Earn Trust and Ownership.
  • What they probed: whether I stated assumptions and complexity before coding — I talked through edge cases first. Be ready for follow-ups; they push on how you'd optimize. The Leadership Principles (LPs) are a major part of every round — expect two per round, so prepare STAR stories from your real projects and past work ahead of time.
  • Verdict: Positive.

Round 2 — High Level Design (HLD)

  • Format: 60 minutes on Bluescape, an interactive whiteboard (similar to Excalidraw).
  • Asked: design a service that collects gig-worker data from platforms like Swiggy, Zomato, Ola, Uber, and Rapido, verifies each worker's PAN/identity, and serves that verified data back to requesting companies — plus a way for those companies to pay the service.
    • Gather functional and non-functional requirements.
    • Lay out the components, with API and database discussions.
    • Scale it to hundreds of millions of users.
    • Two Leadership Principles: Bias for Action and Dive Deep.
  • What they probed: scaling and trade-offs over component trivia — how I'd ingest data from many sources, keep identity verification consistent and idempotent, and scale reads to hundreds of millions. Driving the requirements conversation myself scored better than waiting to be prompted.
  • Verdict: Positive.

Round 3 — Low Level Design (LLD)

  • Format: 60 minutes on Bluescape (the same interactive whiteboard).
  • Asked: design an elevator system.
    • How the elevator moves, where it stops, and what input it takes.
    • The algorithm behind a working elevator.
    • Two Leadership Principles: Insist on the Highest Standards and Deliver Results.
  • What they probed: functional and non-functional requirements first, then the entities (classes) I could identify in the problem and the methods on each. Finally, they had me code two of the important functions — moveLift and dispatchLiftForRequest.
  • Verdict: Positive.

Round 4 — Bar Raiser

  • Format: 60 minutes on Amazon's own live-coding platform.
  • Asked:
    • One DSA problem: on a long, scrollable page of content, find the word that occurs most frequently at any given point in time.
    • Two Leadership Principles: Customer Obsession and Learn and Be Curious.
  • What they probed: depth. Every story drew two or three layers of follow-up — "why that approach," "what did the data say," "what did you learn." Surface-level answers fall apart here. This round felt decisive.
  • Verdict: Positive.

Verdict and my suggestions

Outcome: selected — offer accepted. If I did it again:

  1. Start behavioral prep on day one, not the week before — it carried the loop. The LPs matter as much as DSA and system design at Amazon.
  2. Focus your DSA topics. Amazon leans toward trees, graphs, and DP — I'd drill those in the week or two before the interview.
  3. Pick a system-design framework and stick to it: functional requirements → non-functional requirements → core entities and APIs → design (covering the functional requirements) → deep dive (scaling, covering the non-functional ones).

How I prepared

  • ~6 weeks, evenings and weekends.
  • DSA: ~120 problems, weighted toward arrays, hashmaps, trees, graphs, and dynamic programming. Amazon leans practical, not tricky.
  • Behavioral: I wrote two STAR stories per Leadership Principle and rehearsed them out loud. This was the highest-leverage thing I did.
  • System design: reviewed the standard framework — requirements → API → data model → high-level design → deep dives — and practiced two designs a day.