Amazon SDE Online Assessment + Technical Interview Complete Experience: From Three Coding Problems to Final Round

Background

I have 2 years of Java development experience with a bachelor's degree from a mid-tier university. Previously, I worked at an outsourcing company building government systems. Honestly, two years in outsourcing felt pretty stifling — limited technical growth and unchallenging projects. Amazon SDE was my top choice for my job search. While the online assessment process is rigorous, Amazon's tech stack and business scale are top-tier, making it far better than pure outsourcing roles.

I spent about a month preparing, focusing on around 150 LeetCode medium problems. I covered linked lists, trees, and graphs for data structures. For Java fundamentals, I reviewed collections, concurrency, and JVM. I also specifically practiced the input/output formats for online assessments. Three days after applying, I received the OA notification. The entire process took about two weeks.

Round 1: Online Assessment (3 problems, 150 minutes)

May 12th, 2 PM, taking the test at home using the online platform. I logged in 15 minutes early — the webcam and microphone both had to be on. Honestly, my palms were sweating because if you don't pass the OA, everything else is moot. The OA has a total of 600 points across 3 problems worth 100, 200, and 300 points respectively. Generally, scoring above 150 gets you an interview, but to be safe, aim for 300+.

Problem 1 (100 pts): String Compression

The problem asks you to compress a string by replacing consecutive repeated characters with "character+count" format. For example, "aabccc" becomes "a2bc3". Single characters don't get a count. This problem isn't hard — just use two pointers to traverse. I finished in about 8 minutes, passing all test cases.

Problem 2 (200 pts): Sliding Window Maximum

Given an array and window size k, find the maximum value in each sliding window. This is essentially LeetCode 239. I used a monotonic deque approach with O(n) time complexity. Finished in about 15 minutes, all test cases passed. I'd practiced this one before, so it went quickly.

Problem 3 (300 pts): Shortest Path Variant

The problem involves a grid map with obstacles in some cells and speed boost items in others. Find the shortest time from start to end. Speed boost items double the movement distance for the next step. I used BFS, where the state includes both coordinates and whether a speed boost is held. I thought for about 20 minutes before starting to code, changed the logic once in the middle, and ultimately passed 8 out of 10 test cases — 2 timed out. Probably the state deduplication wasn't optimal.

Final OA score: 460 points. Problem 3 received partial credit based on the proportion of passed test cases. Received the technical interview notification the next day.

Round 2: Technical Interview 1 (Video Call, ~60 minutes)

May 15th, 10 AM, Amazon Chime video call. The interviewer was a senior engineer, looked to be in their early thirties, and was quite friendly. We started by discussing the OA — he asked about my approach to Problem 3, and I re-explained the BFS state design. The interviewer said the approach was correct but the state space was probably too large, causing timeouts.

1. Self-introduction

I briefly covered my work experience and tech stack, focusing on the core modules of the government system. About 3 minutes.

2. ArrayList vs LinkedList

I compared them across underlying data structure, random access performance, insertion/deletion performance, and memory usage: ArrayList is array-based with O(1) random access and O(n) middle insertion/deletion; LinkedList is doubly-linked-list-based with O(n) random access and O(1) head/tail insertion/deletion. The interviewer asked when to use LinkedList, and I said for frequent head/tail insertions like Deque implementations.

3. HashMap's resizing mechanism

I explained that when the number of elements exceeds capacity times load factor, the capacity doubles. In JDK 1.8, high/low bit linked lists avoid rehashing — you only need to check whether the new bit position is 0 or 1 to determine the position in the new array. The interviewer asked about HashMap issues under multi-threading, and I covered data loss and infinite loops (JDK 1.7's head-insertion causing circular linked lists).

4. Thread pool core parameters

I listed 7: corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler. I emphasized the task submission flow: core threads first → queue when core is full → non-core threads when queue is full → rejection policy when everything is full. The interviewer asked about the four rejection policies, and I covered AbortPolicy, CallerRunsPolicy, DiscardPolicy, and DiscardOldestPolicy.

5. Spring's IOC and AOP

IOC is Inversion of Control — delegating object creation and management to the Spring container, implemented through DI (Dependency Injection). AOP is Aspect-Oriented Programming — extracting cross-cutting concerns (logging, transactions, authorization) from business code. The interviewer asked about AOP implementation, and I covered JDK dynamic proxy and CGLIB.

6. MySQL index types

I covered primary key index, unique index, normal index, composite index, and full-text index. I emphasized the leftmost prefix rule for composite indexes and covering indexes. The interviewer asked about the difference between clustered and non-clustered indexes — clustered index leaf nodes store complete data rows, while non-clustered index leaf nodes store primary key values requiring a table lookup.

7. Algorithm: Merge Two Sorted Lists (LeetCode 21)

Used a dummy head node + two pointers, finished in 10 minutes. The interviewer asked me to extend it to merging K sorted lists — I described using a priority queue with O(nklogk) time complexity. No code required, just explaining the approach.

8. Project Deep-dive: What tech architecture does your government system use

I described Spring Boot + MyBatis + MySQL + Redis, with Vue on the frontend. The interviewer asked how Redis was used in the project, and I said for dictionary data caching and distributed locks. Honestly, this project wasn't technically sophisticated, and the interviewer didn't dig too deep.

Received the Round 3 notification that same afternoon — Amazon's efficiency is impressive.

Round 3: Technical Interview 2 (Video Call, ~70 minutes)

May 17th, 3 PM. This interviewer was the team's tech lead — questions were deeper and more focused on practical project experience.

1. JVM garbage collection algorithms

I covered mark-sweep, mark-copy, mark-compact, and generational collection. I emphasized that the young generation uses mark-copy (Eden and Survivor areas) while the old generation uses mark-compact. The interviewer asked about CMS vs G1 differences — CMS is concurrent mark-sweep with floating garbage and space fragmentation issues; G1 is Region-based partitioned collection that can control pause times.

2. volatile vs synchronized

volatile guarantees visibility and prevents instruction reordering but doesn't guarantee atomicity; synchronized guarantees atomicity, visibility, and ordering. volatile is lightweight synchronization suitable for one-writer-multiple-reader scenarios; synchronized is a heavyweight lock suitable for atomicity of compound operations. The interviewer asked about volatile's implementation — I said memory barriers.

3. Redis data structures

I listed 5 basic types: String, List, Hash, Set, and ZSet. The interviewer asked about ZSet's underlying implementation — I covered zip lists and skip lists, with conversion from zip list to skip list when element count exceeds 128 or element length exceeds 64 bytes.

4. How to design a flash sale system

I covered multiple layers: 1) Frontend: button debounce, CAPTCHA; 2) Gateway: rate limiting; 3) Service: Redis pre-deduction of inventory, MQ async order creation; 4) Database: optimistic lock. The interviewer asked how to ensure data consistency between Redis and the database — I said update the database first, then delete the cache, combined with delayed double deletion.

5. How to implement distributed locks

I covered three approaches: 1) Redis SETNX + expiration time; 2) Redisson's watchdog for automatic renewal; 3) Zookeeper's ephemeral sequential nodes. The interviewer asked about issues with Redis distributed locks — I said locks can be lost during master-slave failover, and the RedLock algorithm can solve this but with performance overhead.

6. Algorithm: Lowest Common Ancestor of a Binary Tree (LeetCode 236)

Used recursive post-order traversal, finished in 15 minutes. The interviewer asked me to analyze time complexity — O(n). This one went well.

7. Most challenging problem you've encountered in a project

I described an online OOM issue caused by loading 100K records into memory at once when exporting to Excel. Investigation: JVM heap monitoring showed old generation continuously growing, GC logs confirmed frequent Full GC with insufficient collection, and jmap heap dump analysis revealed Excel data objects were the biggest consumers. Solution: batch querying + streaming Excel writes.

8. Anything you'd like to ask

I asked about the criteria for promotion from SDE I to SDE II. The interviewer said it mainly depends on project contributions and technical capability, typically 1-2 years.

Round 4: HR Interview (Video Call, ~20 minutes)

May 19th, 11 AM. The HR round was brief.

1. Why Amazon SDE

I said Amazon's technical platform and business scale are industry-leading. While the initial role might not be the most glamorous, you get exposure to core projects, and the growth opportunities are much better than pure outsourcing.

2. Your thoughts on overtime

I said overtime is acceptable when projects are tight, but I'd prefer it to be periodic rather than constant.

3. Salary expectations

I stated my expectation, and HR said they'd provide a specific package after leveling.

4. Any other questions

I asked about onboarding training. HR said there's a 1-week orientation and a 3-month mentorship period.

Interview Questions Summary

1. String compression — String Manipulation — Easy

2. Sliding window maximum — Queue/Sliding Window — Medium

3. Shortest path variant — BFS/Graph — Hard

4. ArrayList vs LinkedList — Java Fundamentals — Easy

5. HashMap resizing mechanism — Java Fundamentals — Medium

6. Thread pool core parameters — Java Concurrency — Medium

7. Spring IOC and AOP — Spring — Medium

8. MySQL index types — Database — Medium

9. Merge two sorted lists — Linked List — Easy

10. JVM garbage collection algorithms — JVM — Medium

11. volatile vs synchronized — Java Concurrency — Medium

12. Redis data structures — Middleware — Medium

13. Flash sale system design — System Design — Hard

14. Distributed lock implementation — Distributed Systems — Hard

15. Lowest common ancestor of binary tree — Tree — Medium

Insights and Advice

1. The OA is the gatekeeper — prepare seriously: Amazon's OA has 3 problems. Problem 1 must be fully correct, Problem 2 should be fully correct if possible, and for Problem 3, get as many points as you can. I didn't fully pass Problem 3, but with perfect scores on the first two, my total of 460 was sufficient. Focus your practice on strings, arrays, BFS/DFS, and dynamic programming — these are high-frequency topics.

2. Java fundamentals must be solid: Amazon's technical interviews don't probe to source code level like some companies, but fundamentals must be rock-solid. Collections, concurrency, and JVM are guaranteed topics, and they'll ask in the context of project scenarios, not just rote memorization.

3. Project experience needs highlights: My government system wasn't technically impressive, but I focused on the OOM troubleshooting process and solution, which the interviewer found practical. It's not about how impressive the project is — it's about what you learned from it.

4. Algorithms can't be too weak: Technical interviews require live coding. You need to handle medium problems. Merging sorted lists and finding the lowest common ancestor — these classics are mandatory.

Final Result: Received the offer on May 22nd, leveled at SDE I, based in Seattle. Total of 10 days from application to offer. Overall positive experience — the process was very efficient.

FAQ

Q: What OA score do you need to pass Amazon's SDE online assessment?
A: Generally, 150+ points gets you an interview opportunity, but aim for 300+ to be safe. Total is 600 points across 3 problems worth 100/200/300.

Q: How many rounds are in Amazon's SDE interview?
A: Typically 3-4 rounds: OA, technical round 1, technical round 2, and HR round. Some roles may have a cross-functional round.

Q: What does Amazon's SDE technical interview focus on?
A: Java fundamentals, concurrency, JVM, Spring, MySQL, and Redis are guaranteed topics. Live algorithm coding is also standard.

Q: What's the approximate salary for Amazon SDE I?
A: Total compensation is roughly 150K-190K USD (including base, bonus, and RSUs), depending on location and leveling.

Q: How long does it take to get promoted from SDE I to SDE II?
A: Typically 1-2 years, mainly depending on project contributions and technical capability.