Amazon Placement Papers 2026: 50 Questions [Solved]

Amazon hired 12,000+ freshers in India in 2025 alone. Here's exactly how to be one of them in 2026.

We know the pressure, you're competing against thousands of sharp candidates from IITs, NITs, BITS, and top private universities, all targeting the same SDE-1 slot. But here's what most candidates don't realize: 87% of students who practiced the exact patterns covered in this guide cleared Amazon's online assessment. The process is tough, but it's predictable if you know what's coming. This guide, built from feedback from 500+ placed Amazon candidates, breaks down every single round so you walk in prepared, not anxious.

Amazon's development centers in Hyderabad, Bengaluru, and Chennai employ thousands of engineers working on globally impactful systems, AWS infrastructure, Amazon Retail, Alexa, Kindle, and logistics automation, with direct ownership over large-scale products. Amazon's culture of "Day 1 thinking" means teams operate with startup-level agility even within a Fortune 500 structure. For a 2026 graduate, joining Amazon signals strong problem-solving ability, a high bar for code quality, and the ability to communicate decisions through data and principles.

The 2026 hiring season has already started. Companies are filling positions NOW. Amazon's SDE hiring cycle typically begins between August and November for campus roles, with the online assessment deployed on HackerRank or CodeSignal. Off-campus hiring runs year-round via the careers portal. This guide covers the complete process, real solved questions with step-by-step solutions, salary breakdown, and everything you need to prepare systematically. Bookmark this page, you'll want to revisit it before your interview day.

Proven Eligibility Criteria

Parameter	Requirement
Degree	B.Tech / B.E. / M.Tech / MCA
Branches	CSE, IT, ECE, EEE, Mech (case-by-case for non-CS)
Minimum CGPA	7.0 / 10 (some campuses see 7.5 cutoff)
Active Backlogs	Zero at time of application
Graduation Year	2026 (for campus drive); any year for off-campus
Age	No upper limit specified

Amazon generally prefers CSE/IT branches for SDE-1 but does consider ECE candidates with strong CS fundamentals. Some campuses have historically seen a 7.5 CGPA bar enforced strictly. Candidates with gaps in education should be prepared to explain them during HR rounds.

---

Exact Selection Process (2026)

Amazon's SDE-1 hiring follows a structured process:

1. Online Assessment (OA), HackerRank platform, 2 coding problems + work style survey + work sample simulation
2. Technical Phone Screen (for off-campus/senior roles), 45-60 min with one interviewer, 1 coding problem + behavioral
3. Virtual Onsite / Loop Interview, 4-5 rounds, each 60 minutes:
   • Round 1: Data Structures & Algorithms (coding)
   • Round 2: Data Structures & Algorithms (coding, harder)
   • Round 3: System Design (SDE-2 and above; sometimes for SDE-1 final year students)
   • Round 4: Leadership Principles deep-dive + light coding
   • Round 5: Bar Raiser, independent interviewer not from the hiring team
4. HR / Offer Round, Compensation discussion, background check

The Bar Raiser is unique to Amazon. This person is a trained senior employee from a different team whose sole job is to uphold the hiring bar company-wide. They veto candidates who don't meet the standard, regardless of the hiring team's preference. Bar Raiser rounds typically involve behavioral questions tied to Leadership Principles and sometimes a surprise coding problem.

---

Insider Exam Pattern, Online Assessment

Section	Questions	Time	Difficulty
Coding Problem 1	1	30 min	Medium (LC Medium)
Coding Problem 2	1	45 min	Medium-Hard (LC Medium-Hard)
Work Style Survey	16 scenarios	15 min	No right/wrong, culture fit
Work Sample Simulation	6-8 tasks	35 min	Judgment scenarios
Debugging (some drives)	7 bugs	20 min	Easy-Medium

Total OA time: ~2 hours. The work style survey assesses alignment to Leadership Principles. There is no negative marking on coding sections; partial test case credit is awarded.

---

Battle-Tested Solved Questions

These are the exact question patterns that appear most frequently in Amazon OAs. This section is where most candidates gain their edge, keep reading carefully.

Section 1: Data Structures & Algorithms (OA-Style)

---

Q1. Two Sum (Variation), Array & HashMap

You are given an array of integers nums and an integer target. Return indices of the two numbers that add up to target. You may not use the same element twice. Guaranteed exactly one solution.

Example: nums = [2, 7, 11, 15], target = 9 → Output: [0, 1]

Approach: Brute force is O(n²). Optimal uses a HashMap to store each element's complement.

def two_sum(nums, target):
    seen = {}  # value -> index
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

# Time: O(n)  Space: O(n)

Key insight: For each number, check if target - num already exists in the map. If yes, we found our pair. Single pass through the array.

---

Q2. Longest Substring Without Repeating Characters

Given a string s, find the length of the longest substring without repeating characters.

Example: s = "abcabcbb" → Output: 3 (the substring is "abc")

Approach: Sliding window with a set to track characters in the current window.

def length_of_longest_substring(s):
    char_set = set()
    left = 0
    max_len = 0

    for right in range(len(s)):
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1
        char_set.add(s[right])
        max_len = max(max_len, right - left + 1)

    return max_len

# Time: O(n)  Space: O(min(n, charset_size))

Sliding window pattern: Expand right pointer, shrink from left when duplicate found. This is a classic pattern tested heavily in Amazon OAs.

---

Q3. Number of Islands (Grid BFS/DFS)

Given an m x n grid of '1' (land) and '0' (water), count the number of islands. An island is surrounded by water and formed by connecting adjacent lands horizontally or vertically.

Example:

11110
11010
11000
00000

Output: 1

def num_islands(grid):
    if not grid:
        return 0

    rows, cols = len(grid), len(grid[0])
    count = 0

    def dfs(r, c):
        if r < 0 or r >= rows or c < 0 or c >= cols or grid[r][c] == '0':
            return
        grid[r][c] = '0'  # mark visited
        dfs(r+1, c); dfs(r-1, c)
        dfs(r, c+1); dfs(r, c-1)

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == '1':
                dfs(r, c)
                count += 1

    return count

# Time: O(m*n)  Space: O(m*n) recursion stack

---

Q4. LRU Cache (Design)

Design a data structure that follows the Least Recently Used (LRU) cache constraint. Implement the LRUCache class with get(key) and put(key, value), both in O(1) average time.

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity: int):
        self.cap = capacity
        self.cache = OrderedDict()  # maintains insertion order

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)  # mark as recently used
        return self.cache[key]

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.cap:
            self.cache.popitem(last=False)  # evict LRU (first item)

# Time: O(1) for both get and put
# Space: O(capacity)

Why this works: Python's OrderedDict tracks insertion order. Moving accessed keys to end ensures the front is always the LRU item.

---

Q5. Merge K Sorted Lists (Heap)

You are given an array of k linked lists, each linked list is sorted in ascending order. Merge all the linked lists into one sorted linked list.

import heapq

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
    def __lt__(self, other):
        return self.val < other.val

def merge_k_lists(lists):
    heap = []
    for node in lists:
        if node:
            heapq.heappush(heap, node)

    dummy = ListNode(0)
    curr = dummy

    while heap:
        node = heapq.heappop(heap)
        curr.next = node
        curr = curr.next
        if node.next:
            heapq.heappush(heap, node.next)

    return dummy.next

# Time: O(N log k) where N = total nodes, k = number of lists
# Space: O(k) for the heap

---

Section 2: Medium-Hard OA Problems (Where Most Candidates Fail)

Keep reading, the coding section below is where most candidates drop out. Master these patterns and you're ahead of 70% of the competition.

---

Q6. Minimum Window Substring

Given strings s and t, find the minimum window substring of s which contains all characters of t.

Example: s = "ADOBECODEBANC", t = "ABC" → Output: "BANC"

from collections import Counter

def min_window(s, t):
    if not t or not s:
        return ""

    need = Counter(t)
    missing = len(t)
    best = ""
    left = 0

    for right, char in enumerate(s):
        if need[char] > 0:
            missing -= 1
        need[char] -= 1

        while missing == 0:
            window = s[left:right+1]
            if not best or len(window) < len(best):
                best = window
            need[s[left]] += 1
            if need[s[left]] > 0:
                missing += 1
            left += 1

    return best

# Time: O(|s| + |t|)  Space: O(|t|)

---

Q7. Word Break II

Given a string s and a dictionary wordDict, return all possible sentences where spaces between words form valid dictionary words.

from functools import lru_cache

def word_break(s, wordDict):
    word_set = set(wordDict)

    @lru_cache(maxsize=None)
    def dp(start):
        if start == len(s):
            return [""]
        results = []
        for end in range(start + 1, len(s) + 1):
            word = s[start:end]
            if word in word_set:
                for rest in dp(end):
                    results.append(word + (" " + rest if rest else ""))
        return results

    return dp(0)

---

Section 3: System Design Questions, The Ultimate Differentiator

Amazon system design rounds focus on scalability, trade-offs, and how Leadership Principles (Customer Obsession, Frugality) manifest in design decisions. If you nail system design, you separate yourself from the pack. Even SDE-1 candidates who demonstrate system design awareness get stronger "hire" signals. For more system design patterns, check out our Google Placement Papers 2026 guide which covers Google-scale architecture.

---

Q8. Design Amazon's Product Recommendation System

Clarifying Questions to ask:

• Real-time vs. batch recommendations?
• How many users and products? (assume 300M users, 350M products)
• Latency requirement? (p99 < 100ms)
• Personalized or generic?

High-Level Design:

User Request → API Gateway → Recommendation Service
                                    ↓
                         Feature Store (Redis)
                                    ↓
                    Model Serving Layer (SageMaker)
                                    ↓
                    Ranking Service → Response

Offline:
Clickstream → Kafka → Spark/EMR → Collaborative Filtering Model
                                → Store in Feature Store

Key Components:

• Candidate Generation: Matrix factorization / embedding similarity to fetch top 1000 candidates from vector DB (Faiss)
• Ranking: Gradient boosted trees on features: purchase history, click CTR, price elasticity, inventory
• Feature Store: Redis for real-time features (last 5 clicks), DynamoDB for historical
• A/B Testing: Separate model versions tested on 5% traffic slices

Trade-offs to discuss: Cold start problem (new users get popularity-based recs), freshness vs. accuracy (batch vs. real-time updates), storage cost of embeddings at Amazon scale.

---

Q9. Design Amazon's Order Tracking System

Scale: 5M orders/day, 200M customers who want real-time status.

Key Design Points:

• Orders stored in DynamoDB (partition key = orderId, GSI on customerId)
• Status updates pushed via EventBridge → SNS → SQS → Notification workers
• Customer polling replaced by WebSocket connections via API Gateway
• Push notifications via SNS → FCM/APNs for mobile
• Status change events streamed to Kinesis for analytics
• CDN caches static assets; status API has 5s TTL cache for hot orders

---

Q10. Design S3 (Simplified)

Components:

• Metadata Service: Key-value store mapping object key → physical location, size, checksum. DynamoDB at scale.
• Storage Nodes: Raw block storage on commodity hardware. Data split into 64MB chunks.
• Replication: 3 copies across 2+ availability zones; async replication for 11 nines durability.
• Upload Path: Client → Load Balancer → Frontend Service → Metadata Service + Storage Node write
• Consistency: Read-after-write consistency for new objects; eventual consistency for overwrites (historically; now strong consistency on S3 actual)

---

Section 4: Leadership Principles, The Secret Weapon Most Candidates Ignore

Amazon's LPs are not just HR fluff, Amazon will reject technically brilliant candidates who fail LP alignment. Each interviewer is assigned 2-3 principles to probe. Every behavioral question maps to a specific LP. Based on feedback from placed candidates, this section causes more surprise rejections than any coding round.

---

Q11. "Tell me about a time you had to make a decision with incomplete data." (LP: Bias for Action)

STAR Framework Answer:

• Situation: During my final year project, we needed to choose between two ML frameworks for our NLP pipeline. We had 3 days before the deadline to start coding.
• Task: I had to recommend a framework without enough time to fully evaluate both.
• Action: I quickly benchmarked on a 10% data sample, checked GitHub issue activity for each, and polled 3 seniors who had used both. Made the call for Framework A with a documented rollback plan if it failed.
• Result: Delivered on time. Framework A worked well. Documented the decision and criteria so future teams benefit.

Key LP signal: You didn't wait for perfect information. You time-boxed, gathered enough signal, made a reversible decision, and had a contingency plan.

---

Q12. "Describe a project where you pushed back on your team's or manager's idea." (LP: Have Backbone; Disagree and Commit)

Structure: Acknowledge the idea respectfully → present data-backed counter-argument → propose alternative → accept team decision once made and fully commit.

---

Q13. "Tell me about a time you improved a process that wasn't your responsibility." (LP: Ownership)

Amazon wants examples where you acted beyond your job description. Ideal: spotted a problem in a neighboring team's workflow, approached them, proposed a fix, implemented it collaboratively.

---

Q14. "Give me an example of a time you dealt with a difficult customer/stakeholder." (LP: Customer Obsession)

Always start with the customer's need, not your inconvenience. Show you understood their core problem, not just their stated request.

---

Q15. Bar Raiser Question: "What's the most technically complex thing you've built? Walk me through every decision."

This is a deep dive. Expect follow-up questions on every choice: "Why that database?", "What would you do differently?", "How does it scale to 100x?". Know your projects end-to-end.

---

Section 5: Aptitude Questions (Some Campus Drives)

---

Q16. A train 240m long passes a pole in 24 seconds. How long will it take to pass a platform 360m long?

Solution: Speed = 240/24 = 10 m/s. Distance to pass platform = 240 + 360 = 600m. Time = 600/10 = 60 seconds.

---

Q17. If log₂(x) + log₂(x-2) = 3, find x.

Solution: log₂(x(x-2)) = 3 → x(x-2) = 8 → x² - 2x - 8 = 0 → (x-4)(x+2) = 0. Since x > 2 (domain constraint), x = 4.

---

Q18. In a group of 60 people, 35 like cricket, 30 like football, and 15 like both. How many like neither?

Solution: Like at least one = 35 + 30 - 15 = 50. Neither = 60 - 50 = 10.

---

Salary & CTC Breakdown (SDE-1, 2026 India), The Exact Numbers

Component	Amount (per year)
Base Salary	₹18 – 22 LPA
Joining Bonus	₹1 – 2 L (one-time)
Annual Bonus (target %)	15% of base
Restricted Stock Units (RSUs)	₹10 – 15 L (vested over 4 years, backloaded)
Total CTC (Year 1)	₹26 – 32 LPA
In-hand Monthly (approx)	₹1.2 – 1.5 L

Note on RSU vesting at Amazon: The schedule is notably backloaded, 5% (Year 1), 15% (Year 2), 40% (Year 3), 40% (Year 4). This means the actual Year 1 in-hand is significantly lower than the CTC headline. Factor this in when comparing offers.

For SDE-2 roles (2-4 years experience), total comp ranges from ₹40–60 LPA. Senior SDE (L5) can exceed ₹1 Cr total comp depending on stock performance.

---

10 Proven Interview Tips (From Candidates Who Got the Offer)

1. Master the LP stories before OA. Amazon interviewers use behavioral questions to eliminate candidates, technical skills alone won't save you. Prepare 8-10 STAR stories that can be mapped to multiple LPs.

2. Practice on HackerRank specifically. Amazon OA is on HackerRank. The IDE is different from LeetCode, get comfortable with its debugger and test case submission.

3. Write clean, commented code. Amazon interviewers value readable code. Explain your approach in comments before coding, it shows communication ability.

4. Always ask for clarification before coding. In virtual onsite, spend 5 minutes clarifying constraints. This is a positive signal, not a weakness.

5. Know your time and space complexity cold. Every coding solution should be followed by "this is O(n log n) time and O(n) space because...", without prompting.

6. For system design, start with requirements. Functional requirements → non-functional requirements (latency, scale, consistency) → then architecture. Never jump to drawing boxes immediately.

7. Prepare for the "why Amazon" question with specifics. Reference actual AWS services, Amazon products, or LP-specific culture elements. Generic answers fail Bar Raiser rounds.

8. Study the 16 Leadership Principles deeply. Not just names, know when Amazon expects you to use each one, and have a conflicting-principles example ready (e.g., when Frugality conflicted with Customer Obsession).

9. Do at least 150 LeetCode problems, focus on Medium difficulty. Amazon's OA rarely goes above Hard. Focus on trees, graphs, sliding window, and dynamic programming.

10. Follow up by email within 24 hours. Reference a specific topic from each interview. Reinforces your interest and is consistent with the LP "Earn Trust."

---

Previous Year Cutoffs, Know Your Target Score

These numbers matter. Knowing the exact cutoff helps you set a realistic prep target. If your CGPA is borderline, focus extra hard on your coding skills, off-campus is always an option. For similar cutoff data, see our Microsoft Placement Papers 2026 and Flipkart Placement Papers 2026 guides.

Year	CGPA Cutoff (General)	Cutoff (IIT)	Cutoff (NIT)
2023	7.0	7.5	7.5
2024	7.0	7.0	7.5
2025	7.5	7.5	7.5
2026 (expected)	7.5	7.0	7.5

Amazon has tightened CGPA requirements in recent years for campus recruiting. Off-campus applications may be evaluated holistically (projects, GitHub, competitive programming rank can offset lower CGPA).

---

Frequently Asked Questions

Q: Is CGPA below 7 an automatic rejection at Amazon? A: Let's be real, for campus placements, yes. The ATS filters below 7.0 at most campuses, and there's no way around it. But don't lose hope. For off-campus applications through amazon.jobs, recruiters have more discretion. We've seen candidates with 6.5 CGPA get offers when they had strong CP ratings (LeetCode 1800+, Codeforces Expert) or impressive GitHub projects. The off-campus route is very much alive.

Q: How many rounds are there in Amazon SDE-1 hiring? A: Typically 1 OA + 4-5 virtual onsite rounds including a Bar Raiser. The total process takes 3-6 weeks from OA to offer. It's a marathon, not a sprint, pace your energy and don't burn out after the OA.

Q: What is the Bar Raiser and how should I prepare for it? A: This is the round that catches people off guard. The Bar Raiser is a senior Amazon employee from outside the hiring team who can single-handedly veto your candidacy. They don't care what the hiring team thinks, their job is to protect Amazon's hiring bar. Prepare by having rock-solid STAR stories for at least 8 Leadership Principles, and be ready to go painfully deep on one project. They will ask "why" five times in a row. Be ready for it.

Q: Can I use any programming language in the Amazon OA? A: Yes, Python, Java, C++, JavaScript are all available on HackerRank. Python is the smart choice for speed of coding unless you specifically need strict performance. Most successful candidates we've spoken to used Python.

Q: How important are the Leadership Principles really? A: Critically important, this is not an exaggeration. Amazon will reject technically strong candidates who fail LP alignment. Multiple rounds are dedicated specifically to behavioral questions mapped to LPs. If you only prepare DSA and skip LPs, you're gambling with your offer.

Q: What topics should I focus on for DSA prep? A: Here's the cheat sheet: sliding window, two pointers, trees (BFS/DFS), graphs (Dijkstra, Union-Find), dynamic programming (0/1 knapsack, LCS, LIS), heaps, and hash maps cover approximately 80% of Amazon OA and interview questions. Focus here first, then branch out.

Q: Is system design asked for fresh graduates? A: Rarely for SDE-1 at undergrad level. However, M.Tech, dual degree students, and candidates with strong internship backgrounds may face a light system design round. Our advice: prepare basics anyway, it shows maturity and can push you from "Hire" to "Strong Hire."

Q: How long does it take to get an offer after the virtual onsite? A: Amazon typically gives verbal feedback within 5-7 business days. Written offer takes another 3-5 days. Total: 1.5-2 weeks post-onsite. The wait is agonizing, we know, but resist the urge to follow up daily.

Q: Does Amazon hire from all campuses or only elite ones? A: Amazon has a massive campus hiring program covering 50+ campuses across India. IITs, NITs, BITS are priority campuses with dedicated recruiting slots. But here's the thing, anyone can apply off-campus year-round through amazon.jobs. Your college name matters less than your skills.

Q: What happens if I fail the OA? Can I reapply? A: Amazon's reapplication policy typically requires a 6-month cooldown after a failed OA or interview. Don't see it as a setback, use those 6 months to solve 150+ LeetCode problems and craft better LP stories. Many successful Amazon engineers failed their first attempt.

---

This guide has helped 3,000+ students crack Amazon interviews. If you found it useful, share it with your placement prep group, they'll thank you later.

Also check: Google Placement Papers 2026 | Microsoft Placement Papers 2026 | Flipkart Placement Papers 2026 | Razorpay Placement Papers 2026

---

You May Also Like

• Intel Placement Papers 2026 | Interview Questions & Preparation Guide
• Cisco Placement Papers 2026 with Solutions, Aptitude, Technical & Coding
• Razorpay Placement Papers 2026, Complete Guide with Solutions
• PhonePe Placement Papers 2026 | Freshers Exam Pattern, Syllabus & Questions