Amazon·Software Engineer·Online Assessment (OA)·Junior

JuniorPending

Jul 2026

Summary

Went through Amazon's HackOn OA for an SDE Intern role. There were two sections: a DSA problem and a dev problem. Cleared all test cases on the DSA side but only got 3 out of 6 on the dev section, so now I'm wondering if anyone actually cleared both and what stack they used.

Questions Asked (1)

What approach and tech stack did you use to pass all test cases in the HackOn dev section?

Technical Trade-offsSystem Design

Author's notes

Got 3/6 on the dev section and I'm still not sure if it was a logic issue or something about the stack I picked.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Structure your answer around the problem-solving journey: start with understanding the problem constraints, then explain your tech stack choices with clear justifications, and finally discuss how you iteratively optimized your solution to pass all test cases. Treat this like a mini system design + coding walkthrough, emphasizing your decision-making process over just the outcome. Be specific about trade-offs you considered, as Amazon values data-driven and principled engineering decisions.

Pro tip: Don't just list what you used — explain *why* you chose each tool or algorithm over alternatives, and mention any edge cases or failing test cases you debugged. Interviewers at Amazon are evaluating your thought process and ownership (a core Leadership Principle), not just whether you passed.

1. Set the Context

Briefly describe the HackOn challenge — the problem domain, input/output constraints, and what made it non-trivial. This shows you understood the problem deeply before jumping to a solution.

2. Explain Your Initial Approach

Walk through your first solution attempt — the algorithm or data structure you chose and why it seemed appropriate. Mention any brute-force or naive approach you considered and why you moved past it.

3. Justify Your Tech Stack

Explain your language and library choices (e.g., Python for rapid prototyping, C++ for performance, specific data structures like heaps or tries) and how they aligned with the problem's time/space constraints.

4. Discuss Optimization and Debugging

Describe how you identified bottlenecks — such as TLE (Time Limit Exceeded) or WA (Wrong Answer) — and the specific optimizations you applied (e.g., memoization, binary search, pruning). This demonstrates iterative problem-solving.

5. Reflect on Trade-offs and Learnings

Summarize the key trade-offs you made (e.g., time vs. space complexity, code readability vs. performance) and what you would do differently. This shows engineering maturity and a growth mindset.

Key Points to Mention

Algorithm selection rationale — why you chose a specific algorithm (e.g., dynamic programming, greedy, graph traversal) over alternatives given the constraints
Time and space complexity analysis — explicitly stating Big-O complexity and how it fit within the problem's limits
Edge case handling — specific edge cases you identified (empty inputs, overflow, duplicate values) and how you addressed them
Tech stack justification — language choice (e.g., C++ for speed, Python for quick implementation) and any standard library utilities leveraged
Iterative debugging process — how you used sample test cases, stress testing, or custom test cases to identify and fix failures
Trade-offs considered — any conscious decisions between competing approaches, such as sacrificing memory for speed or simplicity for correctness

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.