Amazon Interview Questions

Structure with STAR: Describe a specific customer issue, your initiative to resolve it beyond normal expectations, and the positive impact. Emphasize understanding the customer's need, not just the request. Amazon wants leaders who start with the customer and work backward.

Share an example where you identified a problem no one was addressing and took initiative. Show you think long-term, don't sacrifice for short-term results, and never say "that's not my job." Owners don't blame others.

Describe an innovation or simplification you introduced. Show you seek new ideas from everywhere, aren't limited by "not invented here," and accept being misunderstood while innovating. Balance creativity with practicality.

Explain your decision-making process: how you gathered available data, weighed options, made a judgment call, and course-corrected if needed. Show good judgment and willingness to challenge your own beliefs with new data.

Share a genuine learning example: new technology, domain knowledge, or skill. Describe your learning process and how you applied it. Show you're never done learning and continuously seek self-improvement.

Describe specific mentoring: identifying their potential, creating growth opportunities, providing feedback. Show you raise the performance bar and recognize talent. Leaders develop leaders.

Share when you pushed back on cutting corners. Show you have relentlessly high standards others might think unreasonable. Explain how you ensured quality while meeting deadlines.

Share a vision or initiative that was ambitious. Show you think differently and look around corners. Big thinking inspires results and attracts talent. Bold direction creates breakthroughs.

Describe a situation where you acted quickly despite uncertainty. Show you value speed and calculated risk-taking. Many decisions are reversible - they don't need extensive study.

Share an example of resourcefulness: optimizing costs, reusing solutions, or achieving goals with constraints. Show you accomplish more with fewer resources. Constraints breed resourcefulness.

Describe building trust through listening, speaking candidly, treating others respectfully. Show you are vocally self-critical and acknowledge mistakes. Trust is earned through actions.

Share an example where surface-level analysis wasn't enough. Show you operate at all levels, stay connected to details, and question when metrics differ from anecdotes. No task is beneath you.

Explain a principled disagreement: how you advocated your position, respected the final decision even if different, and fully committed. Show you challenge decisions respectfully but don't compromise for social cohesion.

Share a result with measurable impact. Focus on key business inputs, delivering with quality and timeliness. Show you rise to challenges and never settle. Quantify impact wherever possible.

ArrayList uses dynamic array (O(1) random access, O(n) insertion). LinkedList uses doubly-linked nodes (O(n) access, O(1) insertion if position known). ArrayList is better for read-heavy operations; LinkedList for frequent insertions/deletions. ArrayList has better cache locality.

Interface: contract defining methods (all public), supports multiple inheritance, no state (pre-Java 8). Abstract class: partial implementation, single inheritance, can have state and constructors. Use interfaces for capabilities (Comparable), abstract classes for shared behavior in hierarchy.

Index is a data structure (B-tree, hash) that speeds up lookups at cost of write performance and storage. Use for: frequently queried columns, WHERE clauses, JOIN conditions, ORDER BY. Avoid for: small tables, frequently updated columns, low-cardinality columns.

Pessimistic: locks data preemptively (SELECT FOR UPDATE), prevents conflicts but reduces concurrency. Optimistic: assumes no conflict, checks version at commit (CAS), retries if conflict. Use pessimistic for high-contention, optimistic for read-heavy with rare conflicts.

DNS lookup → TCP handshake → TLS handshake (HTTPS) → HTTP request → Server processing → HTTP response → Browser parsing (HTML → DOM, CSS → CSSOM) → Render tree → Layout → Paint → JavaScript execution. Each step has optimization opportunities.

Horizontal scaling, load balancing, caching (CDN, Redis), database sharding/replication, async processing (SQS), microservices with circuit breakers, connection pooling, rate limiting. Monitor and auto-scale based on metrics. Amazon uses all of these.

function twoSum(nums, target) {
  const map = new Map();
  
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    
    if (map.has(complement)) {
      return [map.get(complement), i];
    }
    
    map.set(nums[i], i);
  }
  
  return [];
}

// Example: twoSum([2, 7, 11, 15], 9) → [0, 1]
// Time: O(n), Space: O(n)

function isValid(s) {
  const stack = [];
  const pairs = {
    ')': '(',
    '}': '{',
    ']': '['
  };
  
  for (const char of s) {
    if (char in pairs) {
      if (stack.pop() !== pairs[char]) {
        return false;
      }
    } else {
      stack.push(char);
    }
  }
  
  return stack.length === 0;
}

// Example: isValid("([]){}") → true
// Time: O(n), Space: O(n)

function numIslands(grid) {
  if (!grid.length) return 0;
  
  const rows = grid.length;
  const cols = grid[0].length;
  let count = 0;
  
  function dfs(r, c) {
    if (r < 0 || r >= rows || c < 0 || c >= cols || 
        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 (let r = 0; r < rows; r++) {
    for (let c = 0; c < cols; c++) {
      if (grid[r][c] === '1') {
        count++;
        dfs(r, c);
      }
    }
  }
  
  return count;
}

// Time: O(rows × cols), Space: O(rows × cols) for recursion

class LRUCache {
  constructor(capacity) {
    this.capacity = capacity;
    this.cache = new Map();
  }
  
  get(key) {
    if (!this.cache.has(key)) return -1;
    
    const value = this.cache.get(key);
    this.cache.delete(key);
    this.cache.set(key, value);
    return value;
  }
  
  put(key, value) {
    if (this.cache.has(key)) {
      this.cache.delete(key);
    }
    
    this.cache.set(key, value);
    
    if (this.cache.size > this.capacity) {
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }
  }
}

// Map maintains insertion order in JavaScript
// Time: O(1), Space: O(capacity)

function minMeetingRooms(intervals) {
  if (!intervals.length) return 0;
  
  const starts = intervals.map(i => i[0]).sort((a, b) => a - b);
  const ends = intervals.map(i => i[1]).sort((a, b) => a - b);
  
  let rooms = 0;
  let maxRooms = 0;
  let s = 0, e = 0;
  
  while (s < intervals.length) {
    if (starts[s] < ends[e]) {
      rooms++;
      s++;
    } else {
      rooms--;
      e++;
    }
    maxRooms = Math.max(maxRooms, rooms);
  }
  
  return maxRooms;
}

// Example: [[0,30],[5,10],[15,20]] → 2
// Time: O(n log n), Space: O(n)

function exist(board, word) {
  const rows = board.length;
  const cols = board[0].length;
  
  function dfs(r, c, index) {
    if (index === word.length) return true;
    
    if (r < 0 || r >= rows || c < 0 || c >= cols || 
        board[r][c] !== word[index]) return false;
    
    const temp = board[r][c];
    board[r][c] = '#'; // Mark visited
    
    const found = dfs(r + 1, c, index + 1) ||
                  dfs(r - 1, c, index + 1) ||
                  dfs(r, c + 1, index + 1) ||
                  dfs(r, c - 1, index + 1);
    
    board[r][c] = temp; // Backtrack
    return found;
  }
  
  for (let r = 0; r < rows; r++) {
    for (let c = 0; c < cols; c++) {
      if (dfs(r, c, 0)) return true;
    }
  }
  
  return false;
}

// Time: O(rows × cols × 4^word.length)