2026 changes: an AI-assisted "code comprehension" round is piloting, in which you debug and optimize an existing codebase with Gemini available; interviewers score AI fluency (prompting, output validation, debugging AI output). An in-person round has been reinstated to curb AI-assisted cheating. The Googleyness round is now part-technical. Roughly 19% of reported problems are Hard. Segment tree / BIT problems are a Google-distinctive category.

Custom problems: restaurant waitlist data structure; number of lakes on an island; root an undirected acyclic graph as a binary tree; top-K most talkative users from chat logs; network of teleporters; car rental booking overlap.

2026 changes: The AI-enabled coding round is rolling out to all SWE roles, 60 min in a 3-panel CoderPad (file explorer, editor, AI chat; GPT-5, Claude Sonnet, Gemini, Llama 4 available; AI reads files but cannot edit). Three phases: fix a bug -> build a 120+ line feature -> optimize for larger datasets. Scored on problem solving, code quality, verification, and communication. For E4-E5 it randomly replaces one coding round; for E6+ it is the coding round. Behavioral weight increased, it can single-handedly downlevel E5 to E4. Candidates increasingly get variants of tagged problems.

AI-round problems (~9 in rotation): Maze Solver with Path Printing; Maximize Unique Characters from Word List; Card Game (Three Cards Summing to 15); Friend Recommendation System.

2026 changes: HackerRank OA = 2 coding problems (~70 min) + Work Simulation (~20 min) + Work Style Assessment; the SDE II OA adds a 20-min System Design scenario. ~75-80% of OA problems are Medium, wrapped in Amazon-themed framing (servers, warehouses, parcels). Onsite is ~50/50 coding vs Leadership Principles in every round, plus Bar Raiser. Rising: Dijkstra/weighted-shortest-path problems. No AI-assisted round: Amazon rotates custom OA sets aggressively instead, so pattern prep beats memorization.

Custom OA problems (2026): Server Allocation Cost; Warehouse Distribution; Minimum Array Operations; Bug Sorting by Frequency & Code; Distribute Parcels; Suitable Warehouse Locations; Min Cost To Add New Roads (Hard); Dropped Requests (Hard).

Still radically team-dependent. No unified loop: some teams ask standard LC mediums, embedded/hardware teams ask C/C++ memory questions, services teams ask API design or debug-broken-code. 2026: design-style coding questions are disproportionately common; loops for experienced hires run 8-9 rounds over several weeks. No AI-assisted rounds reported: human-only interviews graded on correctness, memory behavior, and boundary handling.

Custom problems: memory-efficient ProRAW image decoder (<=1GB RAM); lock-free queue for watchOS sensor data; debug a PyTorch U-Net shape mismatch; Bag-of-Words similarity search; Library Management System OOP design.

Biggest 2026 change: formal engineering levels. Netflix moved from a single "Senior Engineer" rung to an explicit multi-band ladder (~E1/L4-E7). The same coding answer is now scored against your target level, so an answer that passes at E4 can fail at E6 for being "too tactical." Loops are decentralized and team-owned; the hiring manager is involved from the first screen. Coding favors practical mediums re-skinned with Netflix domain (shows, playlists, watch history). The culture/Keeper Test round is mandatory in every loop.

Custom problems: TTL Cache with LRU eviction; Weighted Eviction Cache; Versioned Key-Value Store; Streaming Word Counter; group users by overlapping last-K watched movies; playlist add/remove/shuffle; rate limiter with graceful degradation when the limiter itself fails.

2026 changes: Process compressed. OA (2 mediums) then 4 virtual onsite rounds usually on a single day; SDE2 loops = 2-3 DSA + LLD + HLD + hiring manager. The "As Appropriate" (AA) round is formalized and run by Principal EMs; ~85% who reach it get offers, but it retains veto power. Behavioral "growth mindset" scoring is level-banded. AI-assisted rounds are org-specific, not universal: mostly CoreAI/Copilot teams; ask your recruiter.

Custom problems (2026): reconstruct DNA payload strings from tagged fragments; build a CSV query engine; in-memory URL shortener; memory allocation simulation; debug broken queue code; combined rate-limiter + LFU round; traverse an org chart by level; minimum moves on a grid with k-cell jumps.

LLD: Vending Machine, Parking Lot, Snake & Ladder, Elevator Control System (SOLID + State/Strategy probed).

2026 changes: The AI-enabled coding round is now standard: one of two coding rounds, on CoderPad with an AI chat panel (Claude/Opus tiers). The AI cannot edit code: you paste and verify. Graded on a 4-point scale where 3 passes, relative to other candidates. The follow-ups are the real bar: after working code, questioning pivots to concurrency/thread safety, scaling, malformed input, and production readiness.

Custom problems: structured data processing from scratch (parse JSON-like objects, AI-round staple); Merge Intervals reframed as a data-structure-choice design problem; LRU Cache with thread-safety and scaling follow-ups; merge two n-ary trees by key rules; count trips from vehicle logs.

OpenAI interviews focus on practical engineering over LeetCode puzzles. Problems are drawn from a bank of ~8 core challenges with progressive difficulty layers, and the bank churns. Python is strongly recommended.

New in 2026: (1) Agentic coding round (beta): you get an existing codebase and must add features scoped "too large and complex to tackle by hand," so you're expected to drive an AI coding agent. This is the only live round where AI is permitted. Every other interview strictly prohibits it (the take-home is the one other carve-out, and only for Applied AI roles). (2) The 48-hour take-home is now a paid work trial (~$1,000) under NDA, graded like a senior engineer's PR review, "missing test coverage" is the single most-cited rejection reason. (3) Loop = 2 coding + 1 system design + behavioral + hiring manager, plus a 45-min project presentation round.

Core Custom Problems (Most Frequently Reported)

LeetCode-Equivalent Problems

Anthropic uses a CodeSignal OA followed by a 4-6 hour onsite with 4-6 rounds. Python expected. Problems are drawn from a bank of ~6 core custom challenges with progressive difficulty layers, and recruiters tell you which prompt family you'll get days beforehand.

Split AI policy: AI tools are strictly prohibited in all live interviews (candidates have been dropped for using them), but explicitly permitted on the performance take-home. Google/Stack Overflow are allowed in live coding.

The performance take-home has been redesigned three times because Claude kept beating it (Anthropic engineering blog + TechCrunch, Jan 2026): V1 (2024) was a 4-hour simulated-accelerator optimization; V2 (mid-2025) was cut to 2 hours after Claude Opus 4 outperformed most humans; V3 (late 2025) is a Zachtronics-puzzle-style constrained instruction set where you minimize instruction count with no built-in debugging tools, building your own tooling is part of the test. The original is open-sourced at anthropics/original_performance_takehome.

The Values/Culture round (45 min) is the #1 failure point: identical across all roles and levels. It's NOT behavioral/STAR: it evaluates holding complexity, admitting knowledge gaps, second-order reasoning, and intellectual honesty. Scripted STAR stories are the top failure mode, and measured skepticism about the mission scores better than performed enthusiasm.

Core Custom Coding Problems (Most Frequently Reported)

LeetCode Practice Problems (Mapped to Anthropic's Focus Areas)

Key Focus Areas: AI safety/alignment (Constitutional AI, RLHF, red-teaming), systems engineering (distributed training, inference optimization), concurrency/parallel programming, Transformer architecture depth. Prep material for the values round: Core Views on AI Safety + the Responsible Scaling Policy.

Palantir's onsite gives you 3 of 4 round types: Decomposition, System Design, Re-engineering (Debugging), and Coding. Each round includes 20 min of behavioral questions. AI use is strictly prohibited in interviews: a notable divergence from the industry's 2026 drift toward AI-assisted rounds.

The OA is a 3-part practical HackerRank (~90 min): one coding (shape classes OOP) + one SQL (sessions-per-city 3-table join) + one REST API task (paginated restaurant endpoint). Not pure DSA.

Meritocracy Fellowship (launched 2025): an alternative pipeline for high-school grads (SAT >= 1460 / ACT >= 33, $5,400/mo, 4 months). 22 hired from 500+ applicants; successful fellows interview for full-time roles without a degree.

Most Frequently Asked Coding Problems

Unique Interview Rounds

• Decomposition: Break down open-ended real-world problems. Non-coding. AI-flavored prompts (new in 2026): an insurer wants LLM-powered claim summarization; a logistics firm wants an agent to reroute shipments; unify bank fraud detection across legacy systems; retailer demand forecasting; a platform for 500 data sources. Classics: "Design tech to help elderly cook safely"; chess; parking garage; social graph; infection spread; taxi dispatch.
• Re-engineering (Debugging): Debug 500-1000 lines of buggy code with red herrings; sometimes proprietary-library docs are supplied
• System Design: Focus on data integration, ontology design, access control (ABAC); correctness and fault tolerance are first-class constraints
• FDSE vs SWE: Forward-deployed roles emphasize client-facing scenarios; backend roles emphasize scale

Databricks has a unique dedicated concurrency/multithreading round (1 hour), "most companies wave at the topic; Databricks makes it an entire hour." OA is 4 problems in 70 minutes on CodeSignal (2 easy, 2 medium), webcam-proctored, scored on a scale up to 850. The onsite is fully virtual in 2026: 2 algorithm rounds + concurrency + system design + behavioral.

Small question pool, deep follow-up variations: the same core problems (SnapshotSet, Lazy Array, House Robber variants, Tic-Tac-Toe) recycle with escalating twists, including "now distribute this with Spark" follow-ups.

Custom problems: SnapshotSet / versioned iterator (iterator reflects state at creation time, most-reported); Lazy Array (chained map + indexOf); Revenue System with referral chains; in-place delta encoding (+ "distribute with Spark"); replaying shell commands (cp/ls/mv/!<index>); SMS message splitting; lamps on a number line; multi-threaded logger; token-bucket rate limiter with burst probing.

Stripe does NOT use traditional LeetCode-style interviews. Problems model real engineering work -- payment processing, debugging, API integration. Code quality valued over algorithmic cleverness. Unique rounds: Bug Squash (debug a GitHub repo), Integration (build with Stripe API), API Design (REST resource modeling).

2026 changes: The new-grad OA is now a single 60-minute multi-part question on HackerRank: "measuring true coding ability with one question." Integration round rules clarified: web/docs search is allowed, but AI coding assistants are NOT permitted. Bug Squash now focuses sharply on financial-logic bugs: race conditions, missing idempotency checks, non-atomic check-then-act, unvalidated refund logic (~5-7 bugs in ~200 lines).

LeetCode-Mapped Practice Problems

Custom Problems: Accept-Language header parser (parse q-values, sort by quality, the long-standing screen); currency conversion string parsing ("USD:CAD:DHL:5,..." -> multi-hop -> best rate over all paths); card range obfuscation; fraud detection stream (CHARGE/DISPUTE, per-MCC thresholds); subscription notification scheduler; CSV parse + validate with circular dependency detection; invoice reconciliation; request deduplication (idempotency); webhook handler debugging; payment retry with exponential backoff; shipping cost calculator.

NVIDIA interviews emphasize performance awareness (cache hierarchies, memory bandwidth, parallelization). After solving the baseline, expect: "How does this behave under memory pressure? How would you parallelize across 10,000 threads?" C++ essential for systems/GPU roles.

2026 changes: Loops are team-scoped with a "build from scratch" preference: interviewers prefer you avoid built-in library functions. Candidates report bespoke variants over tagged problems. Classic problems now get systems extensions: LRU Cache follow-ups ask you to make it thread-safe with a read-write lock (and justify RW lock vs mutex), or relate it to GPU memory caching. AI-infra system design is the new senior bar: batch inference APIs on GPU clusters, tensor+pipeline parallelism across H100s, TensorRT-LLM/vLLM tradeoffs.

CUDA/GPU-Specific: Matrix multiplication optimization (GEMM), CUDA kernel fusion, memory coalescing analysis, thread synchronization across blocks, multi-GPU communication patterns. 2026 conceptual drills: profile a slow kernel with Nsight Compute; fix uncoalesced access / bank conflicts / thread divergence; make a kernel scale across GPU architectures; occupancy analysis.

Custom problems: polynomial multiplication API in C; temperature spike detection from (timestamp, temp) pairs; minimum sum after K operations; log aggregation by HTTP status code; tree planting constraint satisfaction.

Uber interviews reflect the product domain -- routing, dispatch, surge pricing map to graph traversal, streaming aggregation, and sliding-window patterns. Code readability is explicitly evaluated.

2026 changes: Machine-coding / LLD rounds are the differentiator at senior levels: coding is the primary gate while system-design quality decides leveling (L5a/L5b/Senior/Staff). Original non-LeetCode problems appear in "Hack2Hire" assessments. Questions cluster into four families: graphs/BFS-DFS, sliding window/two pointers, heaps/streaming, and cache/design, with domain-flavored twists (quadtrees for geo points, rate limiters, autocomplete).

Custom Problems: thread-safe token-bucket rate limiter (machine coding); expiry counter (TTL-based driver sessions); geo heatmap builder (aggregate ride pings); driver-rider matching engine; surge pricing calculator; referral revenue tracker; deep equality of nested records; sort a string of clothing sizes ("XS < S < M"); earliest full connectivity timestamp; adaptive bitrate selector.

ByteDance interviews are among the most technically demanding in the industry. Baseline is Medium, Hard is frequent. Candidates solve 2-3 problems per round (vs 1-2 at Google/Meta). Interviewers write their own problems and progressively mutate them mid-round. Compile-ready, bug-free code expected.

2026 changes: The OA was overhauled, switched from HackerRank to CodeSignal, multiple-choice removed entirely, now 4 pure coding problems in 70-90 min (down from ~120 in 2025), with strict proctoring (camera on, screen share, no leaving the window). AI tools are explicitly banned: violations mean immediate disqualification. Questions are increasingly scenario-wrapped (file systems, server infrastructure, data pipelines). The hiring-manager round can include an LC-Hard DP under a strict clock.

Custom Problems: GPU resource management (job queue + scheduler + monitor with fairness and bin-packing); Server Investment and Round Robin Load Balancer (new 2026 OA); Map Async Limit, middleware compose(), and bind polyfill (frontend rounds); video chunk scheduler; hashtag trend detector; comment tree flattening; content moderation priority queue; video deduplication via hashing; live viewer count at billion scale.

Airbnb's most distinctive rule is no pseudocode: your code must actually run and pass test cases in the 45-60 min CoderPad screen. ~33% of reported problems are Hard, with heavy DP and simulation emphasis. Problems arrive dressed as product features (interval merging as overlapping reservation windows). Core values and cross-functional rounds are true gates, not chats.

System Design: Booking/reservation system with time-based availability and strict payment correctness; geo-aware listing search and ranking; notification service; recommendation engine.

DoorDash publicly rebuilt its engineering interviews around AI. The new format is a 60-min AI-assisted working session in your own IDE, where free tiers of the common agent tools suffice and all agent features are allowed. You're graded on pragmatic tradeoffs, turning ambiguity into a plan, minimal-repro validation, and narrating reasoning. The policy is transitional: traditional algorithm rounds still ban AI, while the working session mandates it. Loop: CodeCraft (build a business module, extend as requirements arrive), Debugging (subtle bugs in an unfamiliar codebase), System Design, Behavioral.

Custom problems: Nearest DashMart (multi-source BFS on a city grid); Dasher pay module with rule stacking (CodeCraft); support-ticket workflow automation engine (AI working session); debugging an unfamiliar codebase with planted bugs.

Greedy and string manipulation are heavily tested (Reorganize String is most-asked). OA is ~85-90 min, 3 problems on Codility. New in 2026: take-homes replaced by a ~60-min practical CoderPad screen for many teams, and a shift back toward in-person onsites. Googling and documentation are allowed; LLM use is at interviewer discretion: evaluators watch whether you critically review code rather than paste blindly. Questions are team-tied: Autopilot/firmware/energy loops add sensor parsing, state machines, and scheduling. Difficulty across ~47 tracked problems: 8 Easy / 33 Medium / 6 Hard.

Embedded/firmware: interrupt-safe circular buffers in C, CAN bus protocol design, RTOS task scheduling, mutex vs. semaphore, I2C/UART/SPI selection, bitwise register exercises.

Custom problems: sensor data parsing (noisy streams), state machine implementation (vehicle/charging states), scheduling simulations from an internal question bank.