Fin

Binary Tree Interview Questions — return values where candidates drown

Most tree-round failures are not recursion bugs. They are helper-contract bugs. Here are the engineers, textbooks, and open-source trees that teach the return-value discipline tree rounds actually grade on.

DP stops being scary when you name the state

DP is a compression problem, not a recursion trick. Ask one question — what does the future need to know from the past? — and state, recurrence, and iteration order fall out. Here are the engineers and open textbooks that teach it.

Five graph shapes and I've seen them all

BFS and DFS are the same algorithm with a different container. That reframe, plus five shape-names, covers most graph coding rounds. Here are the engineers and open textbooks that taught it.

Sliding Window Algorithm — the pattern I learned the hard way

Sliding window is not a LeetCode trick. It is the pattern that has moved every TCP packet since 1981 and the pattern that powers every major API rate limiter in production today. Here are the engineers, RFCs, and open-source implementations that teach it.

Swift interviewers listen for compiler literacy

Five engineers spent 2024–2026 writing about the same Swift features — value types, opaque types, actors, [weak self], region-based isolation. None of them wrote to prep you for an interview. Read them side by side and the interview version shows up on its own. Here is the reading list.

Technical Phone Screen — 45 minutes to earn a loop

A curator pass through the public writing that still defines the phone-screen round — Steve Yegge (2008), Joel Spolsky (2006), Jeff Atwood (FizzBuzz, 2007), Gayle Laakmann McDowell (_Cracking the Coding Interview_), Aline Lerner (interviewing.io data), plus modern takes from Gergely Orosz and Julia Evans. Use this as the map; the linked sources are the territory.

2019 Android prep won't clear 2026's bar

Android loops are not generic coding loops with a Kotlin skin. They split into DSA, Android systems, and a UI feature build — and the bar moves every year. Here is what Google, Uber, Meta, and Lyft actually test in 2026, and what you can skip.

Kotlin's compiler hates nulls more than you do

Kotlin interviews do not test whether you can write Kotlin. They test whether you understand why the compiler retires entire classes of Java bugs — null pointers, unchecked async leaks, non-exhaustive when branches. Here is what Google, Meta, Uber, Lyft, and Spotify probe — from platform types to structured concurrency — and how to answer without hand-waving.

Mobile is distributed systems on devices you don't own

Mobile system design is not UI design with a backend diagram stapled on. It is a distributed-systems problem where the distribution happens on user devices — clock drift, flaky networks, OS process kills. Here is the five-layer framework, three canonical deep dives, and the mistakes that fail the round.

React Native Interview Questions — the bridge is dead and the bar moved

React Native interview loops in 2026 grade whether you understand the platform under the abstraction — JSI, Fabric, TurboModules, Hermes. If your mental model is "React that runs on phones," you are interviewing for 2021. Here is what Discord, Shopify, Meta, and Microsoft actually probe, and how to answer without hand-waving.

Most iOS candidates prep the wrong bucket

iOS loops are not generic coding loops with a Swift skin. They split into DSA, iOS systems, and a UI feature build — and most candidates walk in over-prepared on the wrong bucket. Here is what actually separates staff from senior on the loop, what to study, and what to cut.

13 Interviewer Quirks — the weird things candidates don't see coming

Every top tech company has one interview round that breaks generic prep. This piece pulls 13 dossiers side by side to find the single weirdest structural detail at each — the round that catches candidates who only practiced on LeetCode.

AI-assisted coding interviews: the candidate who lets AI talk first lost

A practical guide to AI-assisted coding interviews: what interviewers actually score, when to use AI, when not to, and the workflow that keeps you in control when the model is wrong.

In an AI interview, some companies fail you for opening Copilot

I mapped 13 of the biggest tech companies by their AI interview policy. Two require AI. Seven ban it outright. Four are silent. Here is the full map and what it means for your prep.

Blind 75: The Compact List That Forces the Core Patterns (and What to Change)

Most candidates grind 300 LeetCode problems and learn 40 patterns. Blind 75 is the compact list that forces the patterns to repeat without the noise. Here's how to actually use it.

Backtracking Pattern — the undo-step that trips candidates

Backtracking isn't hard because recursion is hard. It's hard because candidates can't name the decision they're making at each level. Here's the one question that fixes that — and why the 'choose/explore/un-choose' template lies to you.

DoorDash Replaced the Coding Round With an AI Session. The Other Shoe Hasn't Dropped Yet.

DoorDash is the first company we track that officially replaced its traditional coding round with a 60-minute AI-assisted engineering session. Cursor, Claude Code, Copilot — all allowed, all encouraged. Here's what the new round actually tests, why the other FAANGs haven't followed yet, and what to practice this month.

13 Glassdoor picks candidates actually liked interviewing at

We pulled interview satisfaction data from all 13 companies in our dossier store. The results surprised us: the companies building the future of AI have the worst-rated interview experiences. Here is the full ranking, the role-specific splits, and what it all means for you.

Monotonic stacks collapsed my O(n²) into one pass

Every element on a monotonic stack is waiting for something. Once you can name what each one is waiting for, Daily Temperatures, Next Greater Element, and Largest Rectangle stop being three different problems — they're the same problem with different waits.

13 companies graded on whether they want new grads

We read every dossier, tracked every signal, and ranked 13 companies from "actively recruiting new grads" to "you are fighting uphill." Here is the tier list, the comp data, and the one thing that will surprise you about each company.

The 3 Questions I Ask Before Writing Any Interview Code

Duolingo gives you a codebase, not a whiteboard

A practical Duolingo pair programming interview guide for software engineers: how to get oriented in an unfamiliar codebase, make the smallest useful change, and show Duolingo you can collaborate instead of solo-hero coding.

Matrix mutation order is where grids eat candidates

A practical matrices interview prep guide for software engineers: the grid question families that repeat, the boundary and mutation mistakes that waste time, and the short drill plan that makes matrix rounds feel predictable.

The Microsoft AA doesn't grade code. It grades fit.

A practical Microsoft AA interview guide for software engineers: why the last round is not just behavioral, how to prep the project deep dive, and the 45-minute replay that makes your judgment easy to trust.

Palantir wants to hear you decompose out loud

A practical Palantir decomposition interview guide for software engineers: what the round is really testing, why smart candidates still ramble, and how to turn a vague operational problem into objects, actions, and a believable first plan.

Queue interviews test FIFO state, simpler than candidates think

A practical queue interview prep guide for software engineers: the queue question families that repeat, the state mistakes that waste time, and the short drill plan that makes queue-heavy rounds feel predictable.

Recursion Interview Questions — base case first, or it eats you

A practical recursion interview prep guide for software engineers: the question families that repeat, the helper-contract mistakes that waste time, and the short drill plan that makes recursion rounds feel predictable.

Stripe hands you a broken repo and a clock

A practical Stripe debugging interview guide for software engineers: what the repo-based round is really testing, how to stay calm in an unfamiliar codebase, and the 60-minute loop that keeps you from thrashing.

Topological Sort Interview Questions for Software Engineers: In-Degree, Cycles, and Build-Order Judgment

A practical topological sort interview prep guide for software engineers: the dependency-order question families that repeat, the graph-construction mistakes that waste time, and the short drill plan that makes DAG rounds feel predictable.

Amazon's leadership principles need story banks, not 16 scripts

A practical Amazon behavioral interview guide for software engineers: which Leadership Principles show up most, how to build a reusable story bank, and the follow-up traps that sink otherwise good answers.

API Design Interview Questions — every contract is a reef

A practical API design interview prep guide for software engineers: the question families that repeat, how to talk through REST and webhooks without hand-waving, and the mistakes that make good code look shaky.

Big O Interview Guide — explain complexity in one breath

A practical Big O interview guide for software engineers: how to define input size, derive time and space complexity, and answer the follow-up questions that show up in real coding interviews.

TCP, DNS, HTTP — what actually travels the wire

A practical computer networks interview guide for software engineers: the question families that repeat, how to explain request flow and transport trade-offs clearly, and the prep loop that makes networking rounds less fuzzy.

Concurrency is where juniors meet their first ghost

A practical concurrency interview guide for software engineers: the question families that repeat, how to talk about locks and worker pools without hand-waving, and the prep loop that makes multithreading rounds less chaotic.

STL choices are the C++ tell

A practical C++ interview prep guide for software engineers: the STL decisions that repeat, the mistakes that make code feel risky, and the short drill loop that makes C++ rounds calmer.

Data Engineering Interview Questions — pipeline judgment patterns

A practical data engineering interview guide: the question families that repeat, how to answer ETL and pipeline-design prompts, and what to review before a data-heavy interview loop.

Database Interview Questions — schema-first grading criteria

A practical database interview prep guide for software engineers: the question families that repeat, how to explain schema and indexing tradeoffs, and the drill plan that keeps database rounds concrete.

Distributed systems without the buzzword soup

A practical distributed systems interview guide for software engineers: the question families that repeat, how to explain consistency and scaling trade-offs, and the prep loop that keeps senior-system rounds concrete.

Instagram Stories lives and dies on preload timing

A practical Instagram Stories system design guide for software engineers: how to scope the viewer, model playback and seen receipts, and talk through mobile-specific trade-offs without overdesigning the whole app.

LeetCode 75 is a map, not a trophy

A practical LeetCode 75 guide for software engineers: when the plan is worth doing, how to pace it, what it misses, and how to turn 75 problems into interview-ready reps instead of box-checking.

Meta watches how fast you reach for the AI

A practical Meta AI-assisted coding interview guide for software engineers: how the round is shaped, what interviewers are actually testing, and how to use the built-in assistant without giving away ownership.

Authentication isn't authorization, and OAuth proves it

A practical OAuth interview guide for software engineers: how to explain the actors, the authorization-code flow with PKCE, token trade-offs, and where OAuth stops and OpenID Connect starts.

Trie Interview Questions for Software Engineers: Prefix Trees, Word Search, and Autocomplete

A practical trie interview prep guide for software engineers: the trie question families that repeat, the node-modeling mistakes that break good answers, and the shortest drill plan that makes prefix-tree rounds feel predictable.

Arrays and hashing, three hours, no hand-holding

A practical arrays and hashing guide for coding interviews: when to use a set, when to use a hash map, which questions keep repeating, and the mistakes that cost people easy wins.

Low-Level Design Interview Questions — OOD patterns that repeat every week

A practical guide to low-level design and object-oriented design interviews: rate limiters, hit counters, file systems, autocomplete, and the talk-track that makes your design feel deliberate.

Joins and windows decide the SQL round

A practical SQL interview prep guide for software engineers: the query families that repeat, when to use joins vs window functions, and the exact drills that make SQL rounds feel predictable.

Bit Manipulation Pattern — the interview skill nobody practices

Demystify bitwise operations -- XOR tricks, bit counting, and the handful of patterns that cover 90% of interview bit problems.

Greedy works when the next step can't haunt you

A practical guide to the greedy pattern -- when to use it, why it works, and the problems that prove it. No formal proofs required.

Sort the intervals. Everything else is easy.

Master the interval pattern -- sorting, merging, overlapping detection, and the scheduling variants that come up in every interview loop.

Math problems are arithmetic in a costume

The interview math you actually need — modular arithmetic, GCD, number theory tricks, and geometry patterns that show up at top companies.

Simulation problems test whether you can read

When the problem says 'simulate the process' — matrix spirals, game of life, robot paths, and the discipline of clean state management.

Strings are arrays in disguise. Act like it.

Master the string patterns that actually show up in interviews — frequency counting, palindromes, parsing, and the tricks that turn O(n²) into O(n).