Notes on coding interviews — from Fin and Coco.
A practical guide to the greedy pattern -- when to use it, why it works, and the problems that prove it. No formal proofs required.
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 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.
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 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.
A curator pass through the public writing that actually shapes how senior engineers think about behavioral rounds — Gergely Orosz, Lara Hogan, Will Larson, Charity Majors, Alison Green — plus the forum threads where real candidates compare notes. Use this as the map; the linked sources are the territory.
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.
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.
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 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 behavioral is its own round. Release cadence is weekly at best, crash rate is a product KPI tied to store visibility, and your designer is opening the simulator next to you. The interviewer is not grading your STAR structure. They are listening for whether your stories have the shape of someone who has actually shipped to real devices.
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 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.
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.
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.
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.
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.
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 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 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.
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.
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.
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.
Most posts explain what each one is. This one explains the one question that tells you which to use — and why senior engineers still get it wrong under pressure.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
A practical behavioral mock interview guide built from the public deliberate-practice canon — Anders Ericsson on feedback loops, Aline Lerner on interviewing.io interview data, Gayle Laakmann McDowell on behavioral prep, Julia Evans on reading your own interview transcript, and Yangshun Tay on the question families that repeat.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
A first-person report from Leo Kwan's 2024-2025 mobile interview loop: where I got humbled, what larger-company mobile interviews now reward, and why StrongYes exists.
Demystify bitwise operations -- XOR tricks, bit counting, and the handful of patterns that cover 90% of interview bit problems.
Master the interval pattern -- sorting, merging, overlapping detection, and the scheduling variants that come up in every interview loop.
The interview math you actually need — modular arithmetic, GCD, number theory tricks, and geometry patterns that show up at top companies.
When the problem says 'simulate the process' — matrix spirals, game of life, robot paths, and the discipline of clean state management.
Master the string patterns that actually show up in interviews — frequency counting, palindromes, parsing, and the tricks that turn O(n²) into O(n).
Two Sum is the fixed playground problem for that — not a generic demo loop.
