Company Question Bank — Who Asks What

Prep for the exam you're actually taking

Imagine studying for an SAT by grinding calculus problems. You'd be working hard in completely the wrong direction. Every company's interview has a distinct style — Amazon tests leadership principles alongside DSA, Google goes deep on algorithmic analysis, Stripe cares about API design and correctness. Knowing who asks what lets you allocate your limited prep time with precision.

🎯 The meta-strategy: The patterns below are durable signals — each company's style and recurring question shapes. Specific questions rotate quickly, but style stays stable across years. Drill the pattern, not the trophy question.

The interview funnel — three rounds, increasing seniority

Every loop runs the same funnel:

1. DSA round — clear it with the patterns and the Blind 75.
2. LLD round (SDE-2+) — OOP/SOLID, patterns, and the classics (LRU, vending machine, tic-tac-toe).
3. HLD round (SDE-2/3) — the approach plus case studies (URL shortener, feed, and friends).

Company-specific complexity expectations

The canonical DSA patterns by company

The same code template showing how a company-favorite problem looks in Python, Java, and C++:

# Amazon favorite: BFS on a graph/grid (classic medium)
from collections import deque

def num_islands(grid):
    if not grid: return 0
    rows, cols = len(grid), len(grid[0])
    count = 0
    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == '1':
                count += 1
                queue = deque([(r, c)])
                grid[r][c] = '0'
                while queue:
                    row, col = queue.popleft()
                    for dr, dc in [(0,1),(1,0),(0,-1),(-1,0)]:
                        nr, nc = row + dr, col + dc
                        if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == '1':
                            grid[nr][nc] = '0'
                            queue.append((nr, nc))
    return count

# Google favorite: DP with optimization (LIS — O(n log n) patience sort)
import bisect

def length_of_lis(nums):
    tails = []
    for n in nums:
        pos = bisect.bisect_left(tails, n)
        if pos == len(tails):
            tails.append(n)
        else:
            tails[pos] = n
    return len(tails)

// Meta favorite: interval merge (speed-focused, must be fast and clean)
import java.util.*;

public int[][] merge(int[][] intervals) {
    Arrays.sort(intervals, (a, b) -> a[0] - b[0]);  // sort by start
    List<int[]> merged = new ArrayList<>();
    for (int[] iv : intervals) {
        if (merged.isEmpty() || merged.get(merged.size()-1)[1] < iv[0]) {
            merged.add(iv);  // no overlap, add as new interval
        } else {
            merged.get(merged.size()-1)[1] =  // extend end
                Math.max(merged.get(merged.size()-1)[1], iv[1]);
        }
    }
    return merged.toArray(new int[0][]);
}

// Microsoft favorite: validate BST (fundamentals + bounds trick)
#include <climits>

bool isValidBST(TreeNode* root, long low = LLONG_MIN, long high = LLONG_MAX) {
    if (!root) return true;
    if (root->val <= low || root->val >= high) return false;
    return isValidBST(root->left, low, root->val)
        && isValidBST(root->right, root->val, high);
}

Big Tech

Amazon

• Style: medium DSA + a strong LP/behavioral bar; OOD is common at SDE-2.
• DSA: graphs/BFS-DFS, heaps & intervals, two pointers, DP.
• LLD/HLD: parking lot, LRU; design a URL shortener, a distributed cache.

Google

• Style: algorithmic depth + clean analysis; expect "now optimize / now prove it."
• DSA: graphs, DP patterns, backtracking, tries, math.
• HLD: typeahead, web crawler, YouTube. Sometimes a concurrency round.

Meta

• Style: fast medium DSA (speed matters), product-flavored HLD, "ownership" behavioral.
• DSA: arrays/strings, graphs, intervals, binary search.
• HLD: news feed / Twitter, Instagram, ad click aggregation.

Microsoft

• Style: balanced, fundamentals-first; OOD and some bit work.
• DSA: linked lists, trees, strings, DP.
• LLD/HLD: tic-tac-toe, file system; distributed ID.

Apple / Netflix

• Apple: fundamentals + domain depth; LLD and memory-aware code.
• Netflix: senior bar — HLD at scale, streaming/CDN, strong system ownership over puzzle DSA.

Product / scale-ups

Uber

• Real-time + geo + maps. Design Uber, advanced graphs (routing), message queue.

Stripe

• Correctness + API design + practical coding (often realistic, less trick-puzzle). API design, idempotency/payments, REST/GraphQL.

Airbnb / LinkedIn

• Full-stack + product HLD; LinkedIn leans graph/feed (feed, typeahead).

Atlassian

• Values-based behavioral + practical LLD and balanced HLD.

Data / infra / AI

Databricks / Snowflake

• Distributed-systems and data depth. Databases at scale, OLAP vs OLTP, message queue, consistency.

Nvidia

• Systems + parallelism + concurrency; C++ and memory matter.

OpenAI / AI labs

• Strong general SWE + AI/ML depth; pragmatic coding and LLM systems. Research-eng roles add ML breadth.

Bloomberg / HFT

• Bit tricks, math, low-latency concurrency, and tight C++.

Startups & mid-size product companies

Fewer rounds, more "can you ship": one practical DSA screen, often a take-home or a realistic LLD, and a pragmatic HLD about their product. Breadth (backend, databases, caching) beats exotic algorithms.

Think it through

Practice — climb the ladder

Check yourself — company prep strategy

Visualize the interview funnel by level