Amazon Interview Questions: 9 Real Q&A + Prep Tips (2026)
Curated Amazon (Amazon India) interview questions with model answers.
Industry: E-commerce, Cloud Computing, Digital Services. Difficulty: Hard. Hiring for: Software Development Engineer I (SDE-1), Graduate Software Engineer, Associate Software Engineer. Average package: ₹28-45 LPA (SDE-1 Fresher/Entry-level, including stock and bonus).
Selection process
- Online Assessment (DSA, Coding, Debugging)
- Technical Interview 1 (Data Structures & Algorithms)
- Technical Interview 2 (DSA & Low-Level Design)
- Bar Raiser Round (Leadership Principles & Technical Deep Dive)
- HR Discussion (Compensation & Logistics)
Real interview questions and answers
Technical: Given an array of integers, find the contiguous subarray (containing at least one number) which has the largest sum.
This is a classic problem solvable with Kadane's Algorithm. The approach involves iterating through the array, maintaining `current_max` and `global_max`. At each element, `current_max` is updated to `max(num, current_max + num)`. `global_max` is then updated to `max(global_max, current_max)`. This handles both positive and negative numbers efficiently. Time complexity is O(N) as we traverse the array once, and space complexity is O(1). Edge cases like arrays with all negative numbers must be handled, where the largest sum would be the single largest negative number.
Technical: Design a data structure that supports insert, delete, search, and getRandom in O(1) average time.
To achieve O(1) for all operations, a combination of a `HashMap` and an `ArrayList` is ideal. The `HashMap` stores the value-to-index mapping (value -> index in `ArrayList`), enabling O(1) search and quick index lookup for deletion. The `ArrayList` stores the values. For `insert`, add to `ArrayList` and update `HashMap`. For `delete`, swap the element to be deleted with the last element in `ArrayList`, remove the last, and update `HashMap` entries. `getRandom` is O(1) using `ArrayList` index and a random number generator. This handles average case O(1) for all.
Technical: Design a URL shortener like Bitly.
A URL shortener requires a system to map long URLs to short, unique codes. Key components include an API gateway, a URL hashing service, and a database. When a long URL is provided, a unique short code is generated (e.g., using Base62 encoding of an auto-incrementing ID or a hash function). This mapping is stored in a database (e.g., NoSQL for scalability). Upon receiving a short URL, the system retrieves the corresponding long URL from the database and performs a 301/302 redirect. Considerations include collision handling, custom short URLs, analytics, and scalability for high traffic.
Behavioral: Tell me about a time you took a calculated risk that failed. What did you learn?
During a hackathon, our team aimed to build a real-time analytics dashboard. To speed up development, I advocated for using a relatively new, less documented streaming library, believing its advertised performance benefits would be crucial. The risk was its novelty. While implementation was initially fast, we encountered obscure integration bugs and performance issues under load that consumed significant time to debug, ultimately preventing us from delivering all features. I learned the critical importance of thorough proof-of-concept testing and evaluating community support for new technologies, even when under tight deadlines, to ensure project stability and timely delivery.
Behavioral: Describe a situation where you had to disagree with your manager or a team member. How did you handle it?
In a previous project, my manager proposed a database schema change that, while seemingly simpler, would have led to significant data redundancy and query inefficiencies in the long run. I respectfully disagreed, preparing a detailed analysis of the potential performance impact and an alternative, normalized schema design. I presented the pros and cons of both approaches with supporting data and anticipated future scaling challenges. After a constructive discussion, my manager appreciated the foresight and we proceeded with the more robust, normalized design. This experience reinforced the 'Have Backbone; Disagree and Commit' principle.
Behavioral: Tell me about a time you went above and beyond for a customer.
While interning, a critical bug was reported by a key client impacting their core operations, just before a major holiday. The issue was complex, involving an obscure edge case in our payment gateway integration. Recognizing the urgency and impact, I voluntarily worked extended hours, collaborating closely with the QA and operations teams. I meticulously debugged, identified the root cause, and pushed a hotfix within 12 hours. The client was extremely grateful, and their operations resumed smoothly. This experience solidified my commitment to 'Customer Obsession' and ensuring user satisfaction, even under pressure.
Behavioral: Give an example of a time you simplified a complex process or solution.
Our team had a manual data aggregation process for generating weekly client reports, which was error-prone and took approximately 6-8 hours. I observed this inefficiency and proposed automating it. I developed a Python script that integrated with various APIs, extracted relevant data, performed necessary transformations, and generated the reports automatically. This solution reduced the manual effort to less than 30 minutes, significantly improved report accuracy, and freed up team members for more strategic tasks. This project demonstrated my 'Invent and Simplify' approach to problem-solving and delivering tangible value.
Behavioral: Describe a challenging problem you faced and how you solved it. What was the outcome?
During my final year project, our web application experienced significant performance degradation under load, with API response times spiking to over 5 seconds. This was a critical challenge for user experience. I initiated a deep dive, using profiling tools to pinpoint bottlenecks. I discovered inefficient database queries and an N+1 query problem. My solution involved optimizing SQL queries, implementing proper indexing, and introducing a caching layer for frequently accessed data. The outcome was a drastic improvement: API response times dropped to under 500ms, enhancing user satisfaction and demonstrating 'Ownership' in problem-solving.
HR: Why Amazon?
I'm drawn to Amazon's culture of innovation, customer obsession, and its immense scale, particularly in India. The opportunity to work on challenging, high-impact problems that affect millions of users, from e-commerce to cloud computing with AWS, is incredibly exciting. Amazon's emphasis on data-driven decisions and its Leadership Principles resonate deeply with my own values for continuous learning and delivering results. I believe my problem-solving skills and passion for building robust software align perfectly with contributing to Amazon's forward-thinking engineering teams and growing within a dynamic environment.
Preparation tips
- Master Data Structures & Algorithms: Focus on LeetCode Medium/Hard problems across arrays, strings, trees, graphs, dynamic programming, and greedy algorithms. Aim for optimal time and space complexity.
- Practice Low-Level System Design (LLD): Be prepared to design common systems like a URL shortener, parking lot, or an e-commerce checkout. Emphasize API design, database schema, and core components.
- Internalize Amazon's Leadership Principles (LPs): Prepare 2-3 detailed STAR (Situation, Task, Action, Result) stories for each of Amazon's 16 LPs. Interviewers will explicitly ask LP-based behavioral questions.
- Conduct Mock Interviews: Practice articulating your thought process clearly for technical problems and delivering concise, impactful STAR stories for behavioral questions. Focus on communication and handling edge cases.
- Focus on Time Management & Edge Cases: During online assessments and technical rounds, optimize for both speed and accuracy. Always discuss edge cases and constraints with the interviewer to demonstrate thoroughness.
Common questions about Amazon interviews
What's the typical SDE-1 compensation at Amazon India?
For SDE-1 freshers or entry-level roles, the typical total compensation at Amazon India ranges from ₹28 LPA to ₹45 LPA. This package usually includes a base salary, joining bonus, and Restricted Stock Units (RSUs) vested over four years, making it highly competitive in the Indian market.
How difficult are Amazon SDE-1 interviews in India?
Amazon SDE-1 interviews are generally considered challenging (Hard). They demand strong proficiency in Data Structures & Algorithms, basic Low-Level Design skills, and a deep understanding of Amazon's Leadership Principles. Candidates must excel in both technical problem-solving and behavioral responses.
Do I need to be from a Tier-1 college to get into Amazon India SDE-1?
While a Tier-1 background can be an advantage, it's not strictly necessary. Amazon India hires from various colleges. What truly matters are strong DSA skills, a solid understanding of computer science fundamentals, compelling projects, and the ability to articulate your experiences effectively, especially aligning with Leadership Principles.
How long does Amazon India's SDE-1 hiring process usually take?
The entire SDE-1 hiring process at Amazon India typically takes 4 to 8 weeks, from the online assessment to the final offer. This duration can vary based on interviewer availability, the number of candidates, and internal process timelines. Timely follow-ups can sometimes expedite the process.