PapersAdda

Amazon Placement Papers 2026

31 min read
Company Placement Papers
Advertisement Placement

Amazon Placement Papers 2026 - Complete Preparation Guide

Last Updated: March 2026

šŸ¢ Company Overview

Amazon.com, Inc. is an American multinational technology company focusing on e-commerce, cloud computing (AWS), digital streaming, and artificial intelligence. Founded by Jeff Bezos in 1994 in Bellevue, Washington, Amazon started as an online bookstore and has grown to become one of the world's most valuable companies.

Key Highlights:

  • Founded: July 5, 1994
  • Headquarters: Seattle, Washington, USA (Arlington, Virginia - HQ2)
  • Employees: 1,500,000+ globally
  • Revenue: $600+ billion (2025)
  • India Presence: Major centers in Bangalore, Hyderabad, Chennai, Delhi/NCR, Mumbai, Pune
  • Leadership Principles: 16 principles including Customer Obsession, Ownership, Invent and Simplify

šŸŽÆ Eligibility Criteria (2026 Batch)

CriteriaRequirements
DegreeB.E/B.Tech, M.E/M.Tech, MCA, M.Sc (CS)
Batch2025, 2026
Academic Criteria70% or 7.0 CGPA throughout (10th, 12th, Graduation)
BacklogsNo active backlogs at time of assessment
Gap AllowedMaximum 1 year with justification
BranchCSE, IT, ECE, EEE, EIE (core CS preferred)

šŸ’° CTC Breakdown for Freshers 2026

ComponentSDE-1 (New Grad)
Base Salaryā‚¹12,00,000 - ā‚¹15,00,000
Signing Bonusā‚¹3,00,000 - ā‚¹5,00,000 (Year 1 + Year 2)
Relocationā‚¹1,50,000
RSUs (Stock)ā‚¹6,00,000 - ā‚¹10,00,000 (vested over 4 years)
Total First Yearā‚¹28 - ā‚¹38 LPA

Designation: Software Development Engineer - I (SDE-1)

Note: Packages vary significantly based on college tier, interview performance, and previous internships.

šŸ“‹ Exam Pattern 2026

Amazon has one of the most rigorous recruitment processes, with heavy emphasis on coding and problem-solving.

Online Assessment Structure:

RoundNo. of QuestionsTime (Minutes)Type
OA Round 12 coding + MCQs90Debugging + Coding
OA Round 2 (Work Simulation)24 questions90Behavioral + Work style
Technical Round 12 coding problems60Live coding
Technical Round 22 coding + System Design60DSA + Design
Technical Round 31-2 coding + Projects60Bar Raiser
Hiring ManagerBehavioral + Design45Leadership Principles

Total Duration: 5-6 rounds over 1-2 days

Selection Process:

  1. Online Assessment (2 rounds - Aptitude + Coding)
  2. Technical Phone Screen (for some campuses)
  3. Virtual Onsite (3-4 rounds)
    • Coding (DSA)
    • System Design (LLD for freshers)
    • Behavioral (Leadership Principles)
  4. Hiring Committee Review
  5. Offer

šŸ§® Aptitude Questions with Solutions (15 Questions)

Question 1: Number Series

Find the next number: 1, 1, 2, 3, 5, 8, 13, ?

Solution: This is the Fibonacci series: Each number is the sum of previous two. 8 + 13 = 21

Question 2: Time & Work

A and B together can complete a work in 12 days. A alone can do it in 20 days. How long would B take alone?

Solution: (A+B)'s 1 day work = 1/12 A's 1 day work = 1/20

B's 1 day work = 1/12 - 1/20 = (5-3)/60 = 2/60 = 1/30

B alone = 30 days

Question 3: Probability

A bag contains 5 red, 3 green, and 2 blue balls. Two balls are drawn at random. Find probability that both are of different colors.

Solution: P(different) = 1 - P(same color)

P(both red) = 5C2/10C2 = 10/45 P(both green) = 3C2/10C2 = 3/45 P(both blue) = 2C2/10C2 = 1/45

P(same) = 14/45 P(different) = 1 - 14/45 = 31/45

Question 4: Speed & Distance

A train 360m long runs at 45 km/hr. How long will it take to pass a platform 140m long?

Solution: Total distance = 360 + 140 = 500m Speed = 45 Ɨ (5/18) = 12.5 m/s

Time = 500/12.5 = 40 seconds

Question 5: Profit & Loss

A trader marks his goods 40% above cost price and allows 25% discount. Find gain percentage.

Solution: Let CP = ā‚¹100 Marked Price = ā‚¹140 SP = 140 Ɨ 0.75 = ā‚¹105

Gain% = (105-100)/100 Ɨ 100 = 5%

Question 6: Mixtures

Two vessels contain milk and water in ratios 3:2 and 4:1 respectively. In what ratio should they be mixed to get a mixture with milk and water in ratio 7:3?

Solution: Vessel 1: Milk = 3/5, Water = 2/5 Vessel 2: Milk = 4/5, Water = 1/5 Target: Milk = 7/10, Water = 3/10

Using allegation for milk: (3/5) ā€”ā€”ā€”ā€” (4/5) \ / 7/10 / \ (4/5-7/10) (7/10-3/5) (1/10) (1/10)

Ratio = 1:1

Question 7: Compound Interest

A sum becomes ā‚¹6690 in 3 years and ā‚¹10035 in 6 years at compound interest. Find the principal.

Solution: Amount in 6 years / Amount in 3 years = (10035/6690) = 1.5

This means (1 + r)Ā³ = 1.5

P Ɨ (1.5) = 6690 P = 6690/1.5 = ā‚¹4460

Question 8: Permutations

How many 4-digit numbers can be formed using digits 1,2,3,4,5 without repetition that are divisible by 4?

Solution: A number is divisible by 4 if its last 2 digits form a number divisible by 4.

Possible endings from {1,2,3,4,5}: 12, 24, 32, 52 (divisible by 4)

For each ending:

  • First digit: 3 choices (remaining)
  • Second digit: 2 choices
  • Last 2 digits: fixed

Total = 4 Ɨ 3 Ɨ 2 = 24

Question 9: Clocks

How many times do the hands of a clock coincide in a day?

Solution: The hands coincide every 65 5/11 minutes. In 12 hours, they coincide 11 times (not 12, because the 11th and 12th are the same at 12:00).

In 24 hours: 11 Ɨ 2 = 22 times

Question 10: Pipes & Cisterns

Pipe A fills a tank in 8 hours, Pipe B empties it in 12 hours. If both are opened together, how long to fill the tank?

Solution: A's rate = 1/8 per hour B's rate = -1/12 per hour Net rate = 1/8 - 1/12 = (3-2)/24 = 1/24 per hour

Time = 24 hours

Question 11: Calendar

If March 5, 2024 is Tuesday, what day is March 5, 2025?

Solution: 2024 is a leap year (366 days). From March 5, 2024 to March 5, 2025 = 366 days

366 mod 7 = 2 odd days

Tuesday + 2 days = Thursday

Question 12: Averages

The average of 11 results is 50. If the average of first 6 is 49 and last 6 is 52, find the 6th result.

Solution: Sum of 11 = 11 Ɨ 50 = 550 Sum of first 6 = 6 Ɨ 49 = 294 Sum of last 6 = 6 Ɨ 52 = 312

6th result = (294 + 312) - 550 = 56

Question 13: Partnership

A invests ā‚¹5000 for 12 months, B invests ā‚¹8000 for 8 months, and C invests ā‚¹10000 for 6 months. Find ratio of profits.

Solution: A's investment-months = 5000 Ɨ 12 = 60000 B's investment-months = 8000 Ɨ 8 = 64000 C's investment-months = 10000 Ɨ 6 = 60000

Ratio = 60000 : 64000 : 60000 = 60 : 64 : 60 = 15 : 16 : 15

Question 14: HCF LCM

Three numbers are in ratio 2:3:4 and their HCF is 12. Find the LCM of the numbers.

Solution: Numbers = 2Ɨ12, 3Ɨ12, 4Ɨ12 = 24, 36, 48

LCM of 24, 36, 48: 24 = 2Ā³ Ɨ 3 36 = 2Ā² Ɨ 3Ā² 48 = 2ā“ Ɨ 3

LCM = 2ā“ Ɨ 3Ā² = 16 Ɨ 9 = 144

Question 15: Boats & Streams

A boat covers 30 km downstream in 2 hours and returns in 3 hours. Find the speed of the boat in still water.

Solution: Downstream speed = 30/2 = 15 km/hr Upstream speed = 30/3 = 10 km/hr

Boat speed = (15 + 10)/2 = 12.5 km/hr

šŸ’» Technical/CS Questions with Solutions (10 Questions)

Question 1: Explain Time and Space Complexity.

Common Notations:

  • O(1): Constant
  • O(log n): Logarithmic
  • O(n): Linear
  • O(n log n): Linearithmic
  • O(nĀ²): Quadratic
  • O(2^n): Exponential

Amortized Analysis: Average time over a sequence of operations.

Question 2: Explain Hash Tables and Collision Resolution.

Collision Resolution:

  1. Chaining: Store colliding elements in a linked list at that index
  2. Open Addressing:
    • Linear Probing: Check next slot sequentially
    • Quadratic Probing: Check slots at quadratic intervals
    • Double Hashing: Use second hash function

Load Factor (Ī±) = n/m (n=elements, m=slots)

Question 3: What is the difference between BFS and DFS?

BFSDFS
Uses QueueUses Stack
Explores level by levelExplores depth first
Finds shortest path in unweighted graphMay not find shortest path
More memory for wide graphsLess memory for deep graphs
Iterative implementationRecursive implementation

Applications:

  • BFS: Shortest path, level-order traversal
  • DFS: Cycle detection, topological sort, path finding

Question 4: Explain Dijkstra's Algorithm.

Algorithm:

  1. Initialize distances: source=0, others=āˆž
  2. Use priority queue (min-heap)
  3. Extract minimum, relax edges
  4. Repeat until all nodes processed

Time Complexity: O((V+E) log V) with binary heap Space Complexity: O(V)

Question 5: What is Load Balancing?

Types:

  1. Hardware Load Balancers: Physical devices
  2. Software Load Balancers: NGINX, HAProxy
  3. Cloud Load Balancers: AWS ELB, Azure Load Balancer

Algorithms:

  • Round Robin
  • Least Connections
  • IP Hash
  • Weighted Round Robin

Question 6: Explain Database Indexing.

Types:

  • Primary Index: On primary key, clustered
  • Secondary Index: On non-primary columns
  • Composite Index: On multiple columns
  • Covering Index: Contains all queried columns

Trade-offs:

  • Faster SELECT, slower INSERT/UPDATE/DELETE
  • Additional storage space

Question 7: What is CAP Theorem?

  • Consistency: All nodes see the same data at the same time
  • Availability: Every request receives a response
  • Partition Tolerance: System continues despite network partitions

Systems:

  • CP: MongoDB, HBase
  • AP: Cassandra, DynamoDB
  • CA: Traditional RDBMS (not distributed)

Question 8: Explain Amazon's Leadership Principles.

  1. Customer Obsession: Start with customer and work backwards
  2. Ownership: Think long-term, act on behalf of company
  3. Invent and Simplify: Innovation and simplification
  4. Are Right, A Lot: Strong judgment, seek diverse perspectives
  5. Learn and Be Curious: Always learning
  6. Hire and Develop the Best: Raise performance bar
  7. Insist on Highest Standards: Continuously raise the bar
  8. Think Big: Create bold direction
  9. Bias for Action: Speed matters in business
  10. Frugality: Accomplish more with less
  11. Earn Trust: Listen, be vocally self-critical
  12. Dive Deep: Operate at all levels, stay connected
  13. Have Backbone; Disagree and Commit: Challenge decisions
  14. Deliver Results: Focus on key inputs
  15. Strive to be Earth's Best Employer: Create safe environment
  16. Success and Scale Bring Broad Responsibility: Be humble

Question 9: What is the difference between Monolithic and Microservices?

MonolithicMicroservices
Single unified codebaseMultiple independent services
Simple to develop initiallyComplex to set up initially
Scaled as one unitIndependently scalable
One technology stackMultiple technology stacks
Difficult to update partiallyEasy to update individual services
Single point of failureBetter fault isolation

Question 10: Explain LRU Cache.

Implementation:

  • Use HashMap for O(1) lookup
  • Use Doubly Linked List for O(1) removal/insertion

Operations:

  • get(key): O(1)
  • put(key, value): O(1)

Amazon frequently asks LRU Cache in interviews.

šŸ“– Verbal/English Questions with Solutions (10 Questions)

Question 1: Synonyms

Choose the word closest to "EPITOME": a) Beginning b) Summary c) Perfect example d) Conclusion

Question 2: Antonyms

Choose the opposite of "BENIGN": a) Gentle b) Harmless c) Malignant d) Friendly

Question 3: Error Detection

"The number of employees are increasing rapidly."

Question 4: Fill in the Blanks

The new feature was _______ by early adopters. a) embraced b) denied c) refused d) rejected

Question 5: Sentence Improvement

"Neither the manager nor the employees was present."

Question 6: Para Jumble

Arrange: A) Customer obsession drives B) All innovation at Amazon C) Every decision we make D) From product development to delivery

Question 7: Reading Comprehension

Passage about AWS cloud services and scalability...

Question: What is the main advantage described? Answer: Ability to scale resources dynamically based on demand without upfront infrastructure investment.

Question 8: One Word Substitution

A person who is extremely skilled in a particular field: a) Amateur b) Novice c) Virtuoso d) Beginner

Question 9: Idioms

"To move the needle" means: a) To repair something b) To make a significant difference c) To measure precisely d) To relocate equipment

Question 10: Active to Passive

Convert: "Amazon delivered the package within 24 hours."

šŸ’” Coding Questions with Python Solutions (5 Questions)

Question 1: Merge Intervals

Merge all overlapping intervals in a collection of intervals.

def merge_intervals(intervals):
    if not intervals:
        return []
    
    # Sort by start time
    intervals.sort(key=lambda x: x[0])
    
    merged = [intervals[0]]
    
    for current in intervals[1:]:
        last = merged[-1]
        if current[0] <= last[1]:  # Overlapping
            last[1] = max(last[1], current[1])
        else:
            merged.append(current)
    
    return merged

# Test
intervals = [[1, 3], [2, 6], [8, 10], [15, 18]]
print(f"Merged: {merge_intervals(intervals)}")
# Output: [[1, 6], [8, 10], [15, 18]]

Time Complexity: O(n log n) | Space Complexity: O(n)

Question 2: Top K Frequent Elements

Given an array, return the k most frequent elements.

from collections import Counter
import heapq

def top_k_frequent(nums, k):
    # Count frequencies
    count = Counter(nums)
    
    # Use heap (min heap, so negate for max effect)
    return heapq.nlargest(k, count.keys(), key=count.get)

# Alternative using bucket sort
def top_k_frequent_bucket(nums, k):
    count = Counter(nums)
    
    # Bucket by frequency
    freq = [[] for _ in range(len(nums) + 1)]
    for num, cnt in count.items():
        freq[cnt].append(num)
    
    result = []
    for i in range(len(freq) - 1, 0, -1):
        for num in freq[i]:
            result.append(num)
            if len(result) == k:
                return result
    return result

# Test
nums = [1, 1, 1, 2, 2, 3]
k = 2
print(f"Top {k} frequent: {top_k_frequent(nums, k)}")

Time Complexity: O(n log k) | Space Complexity: O(n)

Question 3: Number of Islands

Given a 2D grid of '1's (land) and '0's (water), count the number of islands.

def num_islands(grid):
    if not grid or not grid[0]:
        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] != '1':
            return
        grid[r][c] = '0'  # Mark as 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':
                count += 1
                dfs(r, c)
    
    return count

# Test
grid = [
    ['1', '1', '0', '0', '0'],
    ['1', '1', '0', '0', '0'],
    ['0', '0', '1', '0', '0'],
    ['0', '0', '0', '1', '1']
]
print(f"Number of islands: {num_islands(grid)}")  # Output: 3

Time Complexity: O(m Ɨ n) | Space Complexity: O(m Ɨ n) recursion stack

Question 4: Course Schedule (Topological Sort)

Determine if all courses can be finished given prerequisites.

from collections import defaultdict, deque

def can_finish(num_courses, prerequisites):
    # Build graph
    graph = defaultdict(list)
    in_degree = [0] * num_courses
    
    for course, prereq in prerequisites:
        graph[prereq].append(course)
        in_degree[course] += 1
    
    # Start with courses having no prerequisites
    queue = deque([i for i in range(num_courses) if in_degree[i] == 0])
    count = 0
    
    while queue:
        course = queue.popleft()
        count += 1
        for next_course in graph[course]:
            in_degree[next_course] -= 1
            if in_degree[next_course] == 0:
                queue.append(next_course)
    
    return count == num_courses

# Alternative: DFS with cycle detection
def can_finish_dfs(num_courses, prerequisites):
    graph = defaultdict(list)
    for course, prereq in prerequisites:
        graph[course].append(prereq)
    
    visited = [0] * num_courses  # 0=unvisited, 1=visiting, 2=visited
    
    def has_cycle(course):
        if visited[course] == 1:  # Currently visiting - cycle
            return True
        if visited[course] == 2:  # Already processed
            return False
        
        visited[course] = 1
        for prereq in graph[course]:
            if has_cycle(prereq):
                return True
        visited[course] = 2
        return False
    
    for course in range(num_courses):
        if has_cycle(course):
            return False
    return True

# Test
prerequisites = [[1, 0], [0, 1]]  # Cycle
print(f"Can finish: {can_finish(2, prerequisites)}")  # Output: False

Time Complexity: O(V + E) | Space Complexity: O(V + E)

Question 5: LRU Cache Implementation

Design and implement an LRU (Least Recently Used) cache.

class DLinkedNode:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = {}
        self.capacity = capacity
        self.size = 0
        
        # Dummy head and tail
        self.head = DLinkedNode()
        self.tail = DLinkedNode()
        self.head.next = self.tail
        self.tail.prev = self.head
    
    def _remove_node(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev
    
    def _add_to_head(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node
    
    def _move_to_head(self, node):
        self._remove_node(node)
        self._add_to_head(node)
    
    def _pop_tail(self):
        node = self.tail.prev
        self._remove_node(node)
        return node
    
    def get(self, key: int) -> int:
        node = self.cache.get(key)
        if not node:
            return -1
        self._move_to_head(node)
        return node.value
    
    def put(self, key: int, value: int) -> None:
        node = self.cache.get(key)
        if node:
            node.value = value
            self._move_to_head(node)
        else:
            new_node = DLinkedNode(key, value)
            self.cache[key] = new_node
            self._add_to_head(new_node)
            self.size += 1
            
            if self.size > self.capacity:
                tail = self._pop_tail()
                del self.cache[tail.key]
                self.size -= 1

# Test
cache = LRUCache(2)
cache.put(1, 1)
cache.put(2, 2)
print(cache.get(1))       # returns 1
cache.put(3, 3)           # evicts key 2
print(cache.get(2))       # returns -1

Time Complexity: O(1) for get and put | Space Complexity: O(capacity)

šŸŽ¤ Interview Tips for Amazon

1. Master Data Structures & Algorithms

Amazon interviews are heavily DSA-focused. Be comfortable with arrays, strings, hash maps, trees, graphs, and dynamic programming. Practice at least 200+ LeetCode problems.

2. Know the Leadership Principles by Heart

Prepare 2-3 STAR-format stories for each of the 16 Leadership Principles. Amazonians are trained to evaluate every answer against these principles.

3. Practice the Bar Raiser Round

The Bar Raiser is the toughest round. They assess if you're better than 50% of current Amazon employees at that level. Show deep technical knowledge and strong ownership mindset.

4. Focus on Edge Cases

Always discuss edge cases before coding: empty input, single element, duplicates, integer overflow, etc. This shows thoroughness.

5. Optimize Your Solutions

Start with brute force, then optimize. Discuss time/space complexity trade-offs. Amazon expects optimal or near-optimal solutions.

6. System Design for SDE Roles

Freshers should know basic LLD (Low Level Design). Be ready to design classes for problems like Parking Lot, Chess Game, or Library Management System.

7. Own Your Projects

Be prepared to discuss your projects in depth: architecture decisions, challenges faced, what you'd do differently, and metrics/impact achieved.

ā“ Frequently Asked Questions (FAQs)

Q1: How difficult is the Amazon coding interview?

A: Amazon interviews are among the toughest in the industry. Expect medium to hard LeetCode-style problems. The key is not just solving the problem but explaining your thought process clearly, handling edge cases, and optimizing your solution.

Q2: What is the Bar Raiser round?

A: The Bar Raiser is a specially trained interviewer whose job is to maintain hiring standards. They evaluate if you're better than 50% of current employees at that level. This round can be technical or behavioral and is the final gate before an offer.

Q3: How important are Amazon's Leadership Principles?

A: Extremely important. Every interviewer is trained to evaluate candidates against these principles. You should prepare STAR-format stories demonstrating each principle. Even technical answers should reflect principles like "Customer Obsession" and "Dive Deep."

Q4: What should I prepare for System Design as a fresher?

A: Freshers are typically evaluated on Low-Level Design (LLD) rather than distributed systems. Practice designing classes, interfaces, and relationships for problems like Parking Lot, Elevator System, or Online Bookstore.

Q5: What is the re-interview policy at Amazon?

A: Amazon typically has a 6-12 month cooling period before you can reapply. However, this can vary based on feedback from your previous interviews. Use this time to strengthen your weak areas.

šŸ“š Additional Resources

Best of luck with your Amazon placement! šŸš€

This guide is prepared based on recent placement experiences and official Amazon recruitment patterns. Always verify with the latest official notifications.

Advertisement Placement

Share this article: