Interview Preparation
interview-prep
Question Banks
Heap and Priority Queue Quiz
Multi-step prompts on binary heaps: sift-up vs sift-down, heapify cost, top-K extraction, and the array layout that makes parent/child arithmetic O(1).
Deque and Sliding Window Max
Five prompts on the monotonic deque pattern: implementing sliding window maximum, the invariant that makes it O(n), and adjacent online-statistics applications.
Trie Essentials
Prompts on the prefix-tree shape, insert and lookup costs, and the autocomplete pattern. Builds the model before tackling KMP-like or word-search problems.
Sliding Window Essentials
Five mid-level prompts on fixed and variable sliding windows: max sum, longest substring without repeats, and a window-shrink invariant. Mixes implementation and trace.
Prefix Sum and Difference Array
Four prompts on prefix sums for range queries and difference arrays for range updates. Includes one trace and one bug hunt.
String Anagram and Palindrome
Five prompts on anagram detection by frequency and palindrome checks via two pointers, with one bug hunt and one canonical implementation.
Intervals and Merge Problems
Six harder prompts on sorting intervals, sweep-line counts, overlap detection, and meeting-room scheduling. Code-anchored interview prep.
Recursion and Backtracking
Four prompts on the recurse-mutate-undo pattern: subsets, permutations, and combinations. Includes one trace and one bug hunt.
Recursion Trace Challenge
Five Python tracing prompts on recursive call counts, return values, stack-frame depth, and a base-case bug hunt.
Linked List Trace and Pointers
Four mid-level prompts on in-place reversal, node swapping, and the trickiest pointer bug. Mixes implementation and step-by-step trace.
Monotonic Stack Patterns
Five prompts on monotonic stacks for next-greater-element, daily temperatures, and largest rectangle. Mostly implementation with one trace and one bug hunt.
Linked List Interview Prep
Five harder prompts on cycle detection, in-place reversal of a sublist, and merging two sorted lists. Code-anchored with one bug hunt.
Tree Traversal Challenge
Five mid-level prompts on in-order, pre-order, post-order, and level-order traversal. Code-anchored with one trace and one bug hunt.
Lowest Common Ancestor Patterns
Five harder prompts on LCA in BSTs and general binary trees, with the parent-pointer variant. Code-anchored interview prep.
Graph Theory Essentials
Interview-grade prompts on BFS/DFS, shortest paths, connectivity, and cycle detection across directed and undirected graphs.
Binary Search on the Answer
Cast feasibility problems as binary search over a monotone predicate. Drills cover min capacity, max chunk, and the standard template.
External Sorting and Merge Pass
Disk-aware sorting when data exceeds memory. Drills cover run generation, k-way merge with a heap, and pass-count math.
Bitmask DP Essentials
Subset-state DP for TSP-style problems and assignment. Drills cover state encoding, transitions, and the precondition on `n`.
Bit Manipulation Tricks
Mid-tier drills on XOR cancellation, mask construction, low-bit isolation, and bit counting. The patterns show up across hash-table tricks, DP states, and graph encodings.
Prime and Sieve Quiz
Code-first drills on primality testing, the Sieve of Eratosthenes, and smallest-prime-factor tables. Includes complexity reasoning and one prime-factorization walk.
Floating Point and Precision
Hard drills on IEEE-754 representation, equality pitfalls, accumulation drift, and safe comparison patterns. Includes one Kahan-summation walk and a 0.1 + 0.2 trace.
Event Loop Trace Challenge
Mid-tier traces of the JavaScript event loop covering microtasks, macrotasks, and the interleaving of `setTimeout`, `Promise.then`, and `queueMicrotask`. Predict every line.
Producer / Consumer and Locks
Mid-tier drills on bounded buffers, mutexes, semaphores, and deadlock detection. Code stems in Python and JavaScript; one trace involves the four conditions for deadlock.
Concurrency Edge Cases
Hard drills on race conditions, the ABA problem, lost notifications, and fairness. Mixed JS / Python / Java code stems with subtle bugs to spot and fix.
Python Language Trivia
Mid-tier Python gotchas: mutable default arguments, the GIL, method resolution order, and `is` vs `==`. Predict each snippet's output.
Java OOP Fundamentals
Mid-tier Java drills on interfaces vs abstract classes, the equals / hashCode contract, generics type erasure, and Comparable / Comparator. Concrete code stems you can compile.
Design Patterns Walk-Through
Hard drills on Singleton, Strategy, Observer, and Decorator. Concrete Java implementations to read, critique, and extend, plus one thread-safety twist.
JavaScript Coercion and Equality Code Traces
Six output traces drilling on `==` vs `===`, unary `+`, falsy values, and chained relational coercion. Sharpens the rules JS applies before comparing.
JavaScript Hoisting and TDZ Code Traces
Six traces covering `var` declaration hoisting, function-declaration hoisting, TDZ access of `let`/`const`, and IIFE shadowing. Sharpens the mental model of when a binding exists vs. when it has a value.
JavaScript `this` and Arrow Function Code Traces
Six traces covering lost-`this` on extracted methods, arrow inherits-from-enclosing, function-as-constructor return, IIFE `this`, and static vs prototype methods.
JavaScript Scope and Closure Code Traces
Six traces covering the `var` loop-closure pitfall, parameter shadowing, IIFE captures, block scope leaks, and `delete` on locals.
JavaScript Array Method Output Traces
Six traces drilling on in-place vs returning array methods: `reverse`, sparse arrays, `indexOf`, `filter(Boolean)`, default lexicographic `sort`, and `copyWithin`.
JavaScript Closures and Private State Quiz
Build the classic closure patterns: encapsulated counters, lexical-scope inheritance through nested functions, and constructor-level private fields.
JavaScript Immutability and References Quiz
Lock down objects with `Object.freeze`, build read-only properties with `Object.defineProperty`, and reason about why React leans on immutable updates.
Debounce, Throttle, and Rate Limiting Quiz
Implement the rate-limiting primitives that ship in every UI codebase: debounce, throttle, leading-edge debounce, and `requestAnimationFrame`-paced throttling.
JavaScript Decorators and Metaprogramming Quiz
Wrap methods with cross-cutting concerns: a read-only decorator, a method-timing decorator, and the stage-3 decorator proposal that landed in TC39.
JavaScript String Manipulation Challenges
Six small-but-tricky string problems: longest-word slicing, list extraction, manual reversal, palindrome checks, anagram detection, and capitalizing every word.
Numeric Puzzles and FizzBuzz Challenges
Six numeric warm-ups: recursive exponent, random sampling, prime check, recursive 1..n, completing missing numbers, and iterative Fibonacci.
Object Transformation Challenges
Six object-shape problems: building a tree from a flat array, valid-key extraction, chainable methods, stats reshaping, recursive leaf walking, and deep equality.
JavaScript Tooling and Build Trivia
Three quick-fire build-pipeline questions: transpiler vs polyfill, Babel vs SWC, and what source maps actually do.
React Hooks Fundamentals Quiz
Six drills on the core React hooks: useState, useEffect, useReducer, useCallback, useMemo, and writing custom hooks. Good for tightening mid-level interview answers.
Lifting State and Context API Quiz
Six drills on lifting state to a common ancestor, when to switch to Context, and the useReducer + useContext pattern for a small, self-contained store.
React Rendering and Reconciliation Quiz
Four drills on React's virtual DOM, the reconciliation diffing algorithm, and why stable list keys matter so much.
React Lifecycle and Class Component Quiz
Four drills on legacy class lifecycle methods that still show up in interviews and codebases: mount/update/unmount, getSnapshotBeforeUpdate, setState batching, and getDerivedStateFromProps.
React Portals, Fragments, and StrictMode Quiz
Three drills on three small but tested React features: portals (with their event bubbling quirk), fragments, and what StrictMode does in development.
React SSR and Hydration Quiz
Three drills on the difference between SSR and CSR, what hydration actually does, and how React 18 streaming SSR plus selective hydration change the picture.
JavaScript Vowel Counting: Three Approaches Quiz
Count vowels in a string three different ways (loop + Set lookup, split + forEach, regex match) plus two companion drills on case sensitivity and big-O analysis.
JavaScript Longest and Shortest Unique Substring: Two Approaches Quiz
Two seeded approaches to find the longest and shortest unique substrings (restart-on-conflict and instrumented restart), plus two companions on a real sliding window and complexity analysis.
JavaScript Largest Difference Without Sort: Two Approaches Quiz
Two seeded approaches to compute the largest pairwise difference in an array without sorting (single-pass min/max and the brute-force nested loop), plus two companions on prefix tracking and a negative-numbers twist.
JavaScript var Loop Closure: Two Explanations Quiz
The classic var-in-a-for-loop closure trap, explained two ways (shared `i` binding and the IIFE capture fix), plus two companions on the `let` per-iteration binding and a queueMicrotask version of the trap.
JavaScript Deep Object Comparison: Two Approaches Quiz
Diff the keys of two plain objects two ways (JSON.stringify shortcut and a recursive walker), plus two companions on circular references and a Map-based structural diff.
JavaScript Character Occurrence Count: Three Approaches Quiz
Count how often each unique character from a needle string appears in a haystack, three ways (Set + per-char count, dict tally, regex match per char), plus two companions on case folding and a single-pass tally.
JavaScript String Duplicate Finder: Two Approaches Quiz
Tally character frequencies in a string two ways (explicit loop + counter dict and reduce one-liner), plus two companions on Unicode-aware iteration and duplicates-only filtering.
JavaScript Immutable Key Masking: Two Approaches Quiz
Mask the values of specified keys deeply, leaving the last three characters, two ways (recursive clone + mask and structuredClone + mask), plus two companions on path-based targeting and a JSON.stringify replacer variant.
JavaScript Binary Array Plant Pots: Two Approaches Quiz
Decide whether N new plants can be potted into a binary array of pots with no two plants adjacent. Two approaches (greedy single pass, lookahead with neighbour check), plus capacity counting and input validation.
JavaScript Lost-this and Four Fixes Quiz
Repair a method whose inner regular function loses `this`, four ways (arrow function, `bind`, save-this-in-self pattern, explicit `.call`), plus an explainer on lexical-vs-dynamic this binding.
JavaScript Inherit x From Function b: Two Approaches Quiz
Make constructor `b` inherit `x` from constructor `a`: parent-constructor call via `Function.prototype.call`, ES6 `extends` + `super`, `Object.create` chaining, and an arrow-vs-constructor explainer.
JavaScript Array Pair Extraction: Two Approaches Quiz
Split an array into consecutive pairs (with a trailing single when the length is odd), two ways (reduce with odd-index push and a stepped slice loop), plus companions on a generic chunk size and a lazy generator variant.
JavaScript Pair-Sum Finder: Two Approaches Quiz
Two seeded ways to test whether two numbers in an array add up to a target (nested loop and Set complement), plus two companions on time complexity and on returning the actual pair instead of a boolean.
JavaScript Recipe Batches: Two Approaches Quiz
Two seeded ways to compute how many full batches can be produced from available materials (imperative loop with Math.min and a reduce-based variant), plus two companions on missing-key handling and zero-quantity edge cases.
JavaScript Factorial: Three Implementations Quiz
Three seeded ways to compute n! (iterative loop, classic recursion, reduce), plus two companions on memoization and on guarding against negative inputs.
JavaScript Set and Map Values Output: Two Explanations Quiz
Two seeded explanations of how `Set` and `Map` expose their values via iterators and what `console.log` prints when you call `.values()` on each, plus two companions on insertion-order guarantees and on de-duplication semantics.
JavaScript Merge Two Objects: Three Approaches Quiz
Three seeded ways to merge two plain objects (spread, `Object.assign`, and a manual `for...in` copy), plus two companions on shallow-vs-deep semantics and on which approaches mutate the target.
React ReactDOMServer: Two Explanations Quiz
Two explanations of `react-dom/server` rendering APIs (string vs streaming) plus companions on streaming SSR with `renderToPipeableStream` and on hydration mismatches.
React Stateful vs Stateless Components: Two Explanations Quiz
Two explanations of the stateful/stateless (smart vs presentational) split, plus companions on hooks-era state in function components and on testability trade-offs.
React Hooks API Tour Quiz
Six drills covering core hooks: a what-is-a-hook intro plus targeted exercises on useState, useRef, useLayoutEffect, useMemo, and useReducer with runnable examples.
React Portals: Two Explanations Quiz
Two explanations of React portals (mechanics and use cases, plus event bubbling through the virtual tree) with companions on a Modal implementation and a portal-aware focus trap.
Behavioral Interviews
What Are Behavioral Interviews & Why They Matter
Behavioral interviews ask you to describe specific past situations to predict how you will behave in the future. They sit alongside coding and system design rounds at every major tech company, and they are usually the round that decides between two technically similar candidates. This lesson explains what behavioral interviews actually are, why companies invest so much time in them, which competencies they probe, and how they differ from the technical rounds you have probably been preparing for. By the end you will know what interviewers are listening for and be ready to learn the STAR framework that structures every good answer.
The STAR Method: Structure Your Answers
STAR (Situation, Task, Action, Result) is the universal structure interviewers expect for every behavioral answer. It is not a script, it is a contract: each letter answers a specific question the interviewer is silently asking. This lesson defines all four components rigorously, walks through one fully worked good answer with annotations, contrasts it with a weak non-STAR answer that loses the same story, and gives you a delivery checklist you can use under pressure. After this lesson you will be able to take any past event from your career and shape it into an answer that scores well on every standard rubric.
Story Banking: Build Your Arsenal of 8-10 Key Stories
Strong candidates do not invent stories on the fly, they retrieve them. Story banking is the discipline of mining your past 2-5 years of work to extract 8 to 10 versatile stories, mapping each to multiple competencies, and rehearsing them until they are interview-ready. This lesson walks through the three-step mining process, shows a worked example story bank as a table, explains how one story can answer four different questions with light reframing, and gives you a template to build your own bank by the end of the day. After this you will never again hear a behavioral question and think 'I have nothing for that'.
Reading the Question: What They're Really Asking
Every behavioral question carries a hidden specification: which competency to demonstrate, what timeframe to draw from, what scope is acceptable, and which traps to avoid (especially the hypothetical trap). This lesson teaches you to decode that specification in seconds, so you retrieve the right story from your bank instead of the most-recent one. We walk through six real questions, decode each, and show how a small misread can collapse an otherwise-strong answer. After this lesson you will hear behavioral questions the way an interviewer wrote them, not the way they sound on the surface.
Common Mistakes & How to Avoid Them
Strong technical candidates lose offers on behavioral rounds for a small set of repeating mistakes. This lesson catalogs the seven most common failure modes, shows a representative bad answer for each, and gives you the concrete fix. We close Section A by tying the lessons together: STAR gives you the structure, the story bank gives you material, decoding gives you the right retrieval, and avoiding these mistakes gives you the delivery. After this lesson you will recognize each mistake the moment you hear yourself making it and know how to course-correct mid-answer.
Crafting Compelling Stories: Hook, Conflict, Resolution
STAR gives you the structure of an answer, but structure alone is not enough. A perfectly STAR-shaped story can still be forgettable if it has no hook, no real tension, and no payoff. This lesson teaches the narrative layer on top of STAR: the three-beat shape (Hook, Conflict, Resolution) that turns a competent answer into a memorable one. We define each beat, show how to find genuine conflict in even mundane projects, contrast sensory and concrete language with vague abstractions, and walk through one lifeless STAR answer transformed into a compelling story. After this lesson you will know how to make any banked story land in the room without inventing drama.
Quantifying Your Impact: Metrics That Matter
The Result row of every behavioral rubric is graded on numbers. Candidates who say 'we made it faster' lose to candidates who say 'p99 dropped from 240ms to 110ms', even when the underlying work is identical. This lesson is the deep dive on the Result row: what counts as a metric, how to find one when you 'do not have one', how to frame deltas honestly with denominators and baselines, when fake precision actually hurts you, and how to anchor qualitative outcomes when no number exists. We work through six weak-vs-strong Result rewrites for the same underlying events. After this lesson you will never end a story with 'and the team was happy' again.
Tailoring Stories to the Role & Level
The same banked story should be told differently for an L4 IC role at a startup than for an L7 staff role at a big-tech company, and differently again for a frontend lead than a backend platform engineer. The numbers stay; the framing changes. This lesson teaches the two-axis tailoring framework (level and surface area), shows how to read a job description for the signals that matter most, and walks through one anchor story (the canonical payments DB migration) reframed for three different roles and levels. After this lesson you will be able to take the same eight to ten banked stories and deliver them in language that lands precisely on whichever role and level you are interviewing for.
Advanced Storytelling: Layered Answers for Senior Roles
At the staff and principal level, the behavioral round becomes a conversation, not a recital. The strongest senior candidates do not dump every detail upfront. They deliver a tight 90-second 'system 1' answer that lands the headline at the right level, then seed two or three deliberate hooks the interviewer can pull on, so the conversation goes where the candidate's strongest evidence lives. This lesson teaches the layered-answer architecture: how to compress a six-month project into 90 seconds without losing texture, how to plant follow-up hooks that demonstrate principal-level judgement (taste, second-order thinking, system-wide thinking), and how to deliver the deeper layer when the interviewer follows up. After this lesson you will be able to walk into a staff or principal loop and hold a 30-minute conversation around two or three banked stories without flattening any of them.
"Tell Me About Yourself": The 90-Second Pitch
It is the single most asked behavioral question in tech interviews and most candidates waste it. Either they recite their resume top-down, or they free-associate for three minutes about why they got into engineering. Both miss the actual job of this opener: deliver a 60 to 90 second pitch that gives the interviewer a clean handle on who you are now, how you got here, and why this role is the next step. This lesson teaches the Now-Past-Future arc, what to omit, how to seed two or three hooks the interviewer can pull on, and how to end with an explicit handoff. We work through one strong worked answer, one weak resume-recital, and a delivery checklist you can rehearse in 30 minutes today.
"Why This Company?": Authentic Motivation Answers
'Why this company?' is the question candidates underprepare for and overestimate. They think it is small talk; it is actually the question that decides whether the interviewer believes you are choosing them or interviewing everywhere. This lesson teaches the three-beat structure (this company, this role, this time in your career), the difference between surface and deep research signals, and how to translate company-specific facts into your reasons rather than reciting their marketing back at them. Two strong worked examples (a fintech and a developer-tools company) and one weak generic answer with side-by-side comparison. After this lesson you will produce an answer that is hard to fake and harder to dismiss.
Strengths, Weaknesses & Self-Awareness Questions
'What is your biggest weakness?' is the question candidates fear most and prepare worst. The classic move (a strategic-strength dressed up as a weakness) fools nobody, and the over-honest move (a real flaw with no growth story) sinks the answer. This lesson teaches calibration: how to pick a real but non-disqualifying weakness, how to anchor it with concrete evidence of growth, how to handle the strengths question without false modesty or three abstract claims, and how to read the underlying self-awareness signal the interviewer is actually grading. Worked good and bad examples for both questions, with explicit calibration for junior, mid, and senior candidates. After this lesson, the self-awareness questions become one of the highest-scoring rounds in your loop instead of the trap they currently are.
Career Transitions, Gaps & Non-Linear Paths
Most behavioral lesson advice assumes a clean linear path: CS degree, internships, four-year ladder climb. Many strong engineers do not have that path. They are bootcamp graduates, PhD-to-industry switchers, military veterans, parents who stepped out for caregiving, candidates who lost a job in a layoff, or engineers who bounced between roles before finding their fit. The interview question 'walk me through your background' lands hardest on these candidates, because the wrong framing reads as 'lack of focus' even when the underlying engineer is excellent. This lesson teaches one principle: do not apologise, narrate the through-line. We work through how to construct a coherent through-line in retrospect, even when the path was not planned, and walk through two worked transitions in detail. After this lesson, your non-linear path becomes a distinguishing asset rather than a liability you manage around.
Researching Company Values Before the Interview
The 'why this company' answer is only as good as the research underneath it, and most candidates do shallow research. They read the homepage, skim the careers page, and walk in repeating the marketing copy back at the interviewer. This lesson teaches the deep-research moves: which artefacts the company produces by being good at engineering, where to find honest signal about what the company actually cares about, how to translate those values into your stories rather than the other way around, and how to identify what each company cares about more than the average company. The deliverable is a 60-minute prep template you can run before any onsite. After this lesson, your company-specific answers will sound like someone who has thought hard about whether this is the right fit, because that is what you will have done.
Handling Curveball & Hypothetical Questions
Most behavioral prep teaches you to deliver clean answers to questions you anticipated. The harder craft is keeping your composure when the interviewer asks something you did not see coming: a novel hypothetical, a values probe, an ethics dilemma, or a 'tell me about the strangest thing you have done at work' that none of your STAR templates fit. This lesson teaches the categories of curveball you should expect, the 5-second pause as your default move, the redirect-to-real-event pivot when it is honest, and explicit guidance on when redirecting is dishonest because the question genuinely is asking for hypothetical thinking. We work through four worked curveballs of different kinds. After this lesson, an unexpected question becomes a place to score, not a place to spiral.
Behavioral Interviews for Senior / Staff / Principal Roles
At L6 and above, the same 'tell me about a project' question is graded on different signals than at L4 or L5. The interviewer is no longer asking 'did you ship it'; they are asking 'did you see further, ship a principle, repair the org, raise the bar'. Most candidates moving up the ladder fail at this level because they tell strong L5 stories at the L6 or L7 bar. This lesson unpacks the seniority-specific signals graders look for at L6, L7, and L8, walks through one anchor story (the canonical payments DB migration) reframed for each level, and gives you a self-test for whether your stories are calibrated. After this lesson, you will be able to position yourself accurately for staff or principal interviews without inflating your work or under-claiming the level you have actually reached.
Behavioral Interviews for Engineering Management
Engineering management behavioral rounds grade on a substantially different signal set than IC rounds. The same surface words ('tell me about a time you led a team') probe entirely different competencies: people development, hiring decisions, performance management, building or disbanding teams, cross-functional partnership, dealing with toxic situations, and the willingness to make someone leave. Candidates moving from IC to EM consistently fail because they tell their best IC stories at the EM bar and miss the management-grade signals. This lesson covers what changes in EM interviews, the seven signal areas EM loops probe, the specific story types you need in your bank, and how IC-to-EM transition candidates should explicitly address the move. After this lesson you will know what an EM hiring committee is actually grading and how to position yourself for it.
Post-Interview Reflection & Continuous Improvement
What you do in the 15 minutes after each interview round determines how much you improve before the next one. Most candidates do nothing structured: they replay the rough moments in their head, decide they bombed (often inaccurately), and walk into the next round either over-confident or demoralised. This lesson teaches a 15-minute structured reflection template you run after every round, regardless of how you think it went. It covers what was asked, where you felt strong, where you floundered, what story you should have told instead, and what story-bank gap this round revealed. It also covers how to avoid the demoralisation spiral after a tough round, how to update your story bank between rounds in the same loop, and how to debrief the full loop once it is over. As the closing lesson of the Foundations track, it loops back to the four sections (Interview Basics, Storytelling, Self-Presentation, Strategy) and forward-points to Track 2.
Leading Without Authority
Leading without authority is the most common probe in senior and staff-level behavioral rounds. It tests whether you can move a group toward a decision when nobody reports to you and no RACI document names you the owner. This lesson defines the competency rigorously, separates it from the easier 'led a team' framing, walks through the four mechanisms candidates use to influence (data, relationships, framing, and escalation as leverage), and gives you fully worked model STAR answers for the six prompts you are most likely to hear. After this lesson you will be able to take any cross-team or peer-influence story you already have and shape it into an answer that scores on judgement, ownership, and communication at the same time.
Taking Initiative & Ownership
Initiative and ownership questions test whether you act on problems nobody handed you. They are the most common 'ownership' probe at every level and they distinguish candidates who treat their job description as a floor from candidates who treat it as a ceiling. This lesson defines real initiative versus 'doing my job', gives you a four-quadrant taxonomy for finding initiative stories you may have undersold, walks through a discovered-proposed-shipped arc that is the spine of every strong answer, and provides fully worked model STAR answers for the six prompts you will hear. After this lesson you will be able to surface initiative stories without sounding self-aggrandising, and recognise the line where initiative tips into overreach.
Making Hard Decisions Under Uncertainty
Hard-decision questions are the judgement probe at staff and above. They test whether you can act when the information is incomplete, the choice is irreversible, the timeline is short, the answer is unpopular, or all four at once. This lesson defines what makes a decision genuinely hard, walks through a four-step decision framework (frame, generate options, weigh, decide) you can lean on under interview pressure, contrasts calibrated confidence with overconfidence, and provides fully worked model STAR answers for the seven prompts you are most likely to hear including the rare and high-signal 'tell me about a decision you got wrong'. After this lesson you will be able to take any consequential decision in your career and shape it into an answer that scores on judgement, ownership, and self-awareness simultaneously.
Driving Results & Delivering Impact
Driving-results questions are the execution probe. They test whether you can take a project from kickoff to a measured outcome, owning the result rather than the activity. This lesson defines the difference between delivering work and driving results, walks through how to demonstrate end-to-end ownership when the credit is shared, breaks down the four sub-skills interviewers grade (anticipating blockers, removing them proactively, working through cross-team stalls, and not confusing effort with impact), and provides fully worked model STAR answers for the six prompts you will hear most. After this lesson you will be able to take any shipped project and tell the story so the rubric reads ownership of outcome, not just hours worked.
Cross-Team Collaboration
Cross-team collaboration questions test how you operate at the seams between teams: where roadmaps misalign, definitions of done diverge, and RACI ownership is ambiguous. This lesson defines the failure modes specific to cross-team work, walks through how to read another team's incentives before pitching anything, breaks down the three coordination mechanisms (shared problem framing, shared cadence, shared accountability) that strong candidates use, and provides fully worked model STAR answers for the six prompts you will hear most. After this lesson you will be able to take any cross-functional project from your career and tell the story so the rubric reads collaboration mechanics, not just teamwork-as-vibe.
Conflict Resolution
Conflict-resolution questions test whether you can disagree well: stay engaged with the substance, take responsibility for your own contribution to the friction, and end up in a healthier place than you started. This lesson is not about winning arguments. It defines the three kinds of conflict (substance, style, values), walks through the disagree-and-commit pattern that mature engineers use, breaks down the four-step resolution arc (de-escalate, separate the problem from the person, find the shared interest, decide and commit), and provides fully worked model STAR answers for the six prompts you will hear most. After this lesson you will be able to take real disagreements from your career and tell them in a way that scores on judgement, self-awareness, and trust simultaneously, without ever framing the other person as the villain.
Working with Difficult People
'Difficult people' questions are the resilience probe inside collaboration. They test whether you can stay productive and humane when the other person's working style is hard for you, without resorting to labels or framing the other person as the problem. This lesson teaches the framing rule that protects every answer in this competency (describe behaviours, not labels), walks through the patterns that show up most often (slow responder, status-game player, scope-creeper, dismissive senior, chronic cynic) without stereotyping, breaks down the four-step approach mature engineers use (notice the pattern, name your own role in it, try a deliberate change, evolve or escalate), and provides fully worked model STAR answers for the six prompts you will hear most. After this lesson you will be able to take any working relationship that was hard for you and tell the story without making the other person sound toxic.
Building Consensus & Alignment
Consensus-building questions are the senior-staff alignment probe. They test whether you can move a group of stakeholders to a shared decision when reasonable people disagree, without steamrolling, watering down, or faking the alignment. This lesson disentangles consensus from unanimity, draws the line between when consensus is the right goal and when 'disagree and commit' is, walks through the four moves mature engineers use (shared problem framing, shared evaluation criteria, surfacing hidden objections, iterating the proposal), and provides fully worked model STAR answers for the seven prompts you will hear most. After this lesson you will be able to take any contentious technical or organisational decision from your career and tell the story so the rubric reads judgement, communication, and trust simultaneously.
Solving Complex Technical Problems
Complex-problem questions are the technical-depth probe at the heart of every senior engineering interview. They test whether you can decompose a hard, novel problem under uncertainty, validate hypotheses cheaply, and demonstrate technical depth without over-explaining. This lesson defines what actually counts as 'complex' (scale, novelty, blast radius, time-pressure, multi-component coupling), walks through the four-phase arc (decompose, hypothesise, validate, iterate) you can apply to any technical-depth answer, covers when to mention specific technologies (yes when relevant, no when flexing), and provides fully worked model STAR answers for the prompts you will hear most. After this lesson you will be able to take any genuinely hard problem from your career and tell the story so the rubric reads depth, structure, and judgement simultaneously.
Debugging & Production Incident Stories
Production-incident questions are the operational-judgement probe. They test whether you can act calmly under live pressure, separate mitigation from root-cause work, and tell a blameless story that distinguishes systems-level lessons from individual blame. This lesson defines incident-grade storytelling (timeline craft with explicit T+0 / T+5 / T+30 markers), draws the line between fix, remediation, and prevention, walks through blameless-postmortem language you can use in the room without sounding rehearsed, and provides fully worked model STAR answers for the prompts you will hear most. Every model answer in this lesson focuses blame on systems and processes, never on people or teams. After this lesson you will be able to take any real incident from your career and shape it into an answer that scores on calm, judgement, and operational maturity simultaneously.
Navigating Technical Trade-offs
Trade-off questions are the senior-engineering judgement probe. They test whether you can weigh competing technical priorities, articulate the criteria that drove your choice, own the path you took including its costs, and distinguish real trade-offs from false choices that better engineering would dissolve. This lesson defines trade-off literacy across the canonical axes (consistency vs availability, build vs buy, simplicity vs flexibility, speed vs safety, cost vs latency), walks through the explicit-criteria framework strong candidates use to make trade-offs visible, covers the technical-debt framing that scores best in interviews, and provides fully worked model STAR answers for the prompts you will hear most. After this lesson you will be able to take any consequential technical choice from your career and tell the story so the rubric reads judgement, calibration, and ownership simultaneously.
System Design Decision Stories
System design decision questions are the staff-and-above architecture probe. They test whether you can shape a design that compounds correctly over years, demonstrate second-order thinking about how decisions interact, balance forward-looking design with iterative delivery, and tell a story that operates at the right altitude for staff scale. This lesson defines what counts as a scale-shaping decision (architectural choices whose costs and benefits compound), walks through how to present design decisions in narrative form rather than whiteboard form, covers the second-order-thinking moves that distinguish staff stories from senior stories, addresses when to over-engineer versus when to ship-and-iterate, and provides fully worked model STAR answers for the prompts you will hear most. After this lesson you will be able to take any consequential architectural decision from your career and tell the story so the rubric reads design judgement, second-order thinking, and operating at staff altitude.
Handling Failure & Learning from Mistakes
Failure questions are the single most-graded self-awareness probe in the behavioural loop. They test whether you can pick a real failure (not a humble-brag), own your specific role in it without self-flagellation, and surface durable behavioural change with evidence the change has held since. This lesson defines what counts as a substantive failure (not 'I worked too hard'), walks through the four-part failure-answer pattern (situation plus your role plus what you tried plus what you changed), addresses out-of-bounds failures (signals of trust deficit, ethics violation, or role-disqualifying weakness), and provides fully worked model STAR answers for the prompts you will hear most. After this lesson you will be able to take a real failure from your career and tell the story so the rubric reads accountability, growth, and self-awareness simultaneously, without crossing into self-flagellation.
Adapting to Change
Adaptability questions ask whether you can stay productive and shape outcomes when the ground moves underneath you. They probe a specific signal: did you act with agency inside the change, or did you absorb it as something that happened to you? This lesson covers the five common change types you will face in interviews (priority shifts, organisational reshuffles, technical pivots, requirement changes, leadership changes), the difference between adapting and capitulating, the language that signals agency without bitterness, and the trap of describing change as bad without nuance. After this lesson you will be able to take a real change story from your career and tell it so the rubric reads agency, professional maturity, and durable adaptability without crossing into either victim framing or fake enthusiasm.
Working Under Pressure & Tight Deadlines
Pressure questions probe whether your judgement holds when stakes are high and time is short. The interviewer is grading a specific set of moves: calm decomposition under stress, deliberate scope cuts, parallel-track thinking, and clear communication upward. They are not grading whether you worked weekends. This lesson distinguishes pressure (real time-bound stakes) from rush (artificial urgency or poor planning), names the four behaviour signals graders look for, and walks through worked answers for the prompts you will hear most. After this lesson you will be able to take a high-pressure story from your career and tell it so the rubric reads judgement under stress, deliberate trade-offs, and proactive escalation, without crossing into hero framing or learned-helplessness about workload.
Dealing with Ambiguity
Ambiguity is the senior and staff judgement signal. Interviewers ask 'tell me about a time you operated with significant ambiguity' to probe whether you can act decisively when requirements are unclear, when there is no precedent, when ownership is undefined, or when success criteria are vague. The trap is the false-clarity reflex: the candidate retroactively pretends they had clear direction the whole time. The strong move is to show judgement under uncertainty without falsely claiming clarity. This lesson covers the four kinds of ambiguity, the four-step ambiguity workflow (frame, hypothesise, validate cheaply, expand), the difference between escalating for direction and moving forward with cheap probes, and what staff-scale ambiguity stories look like in practice. After this lesson you will be able to take a real ambiguity story from your career and tell it so the rubric reads judgement, calibrated confidence, and the courage to commit to a direction without complete information.
Receiving & Acting on Feedback
Receiving feedback is one of the highest-graded growth signals in behavioral interviews. Interviewers ask 'tell me about a time you received tough feedback' to probe whether you can listen without defensiveness, separate signal from noise, and translate the feedback into observable behavioural change. The trap is the performative-acceptance reflex: the candidate says all the right words about being open to feedback but never demonstrates that anything actually changed. The strong move is to show evidence of behavioural change, calibrated agreement and disagreement (you are allowed to disagree with feedback after honest consideration), and a habit of soliciting feedback proactively. After this lesson you will be able to take a real feedback story from your career and tell it so the rubric reads self-awareness, low defensiveness, and a durable shift in how you operate.
Mentoring & Developing Others
Mentoring questions probe whether you can develop other engineers, not just whether you have helped them once. Interviewers ask 'tell me about a time you mentored someone' to evaluate the gap between effort on your part and growth in your mentee. The trap is the credit-claiming reflex: candidates describe what they did and skip what their mentee did, which inverts the rubric. The strong move is to demonstrate sustained growth in your mentee through their work, frame your contribution as creating conditions rather than producing the wins, and show the four mentoring moves (assess where they are, set development goals, provide deliberate practice, give specific feedback). After this lesson you will be able to take a real mentoring story and tell it so the rubric reads sustained development of another engineer, with you as the architect of the conditions and them as the source of the achievement.
Continuous Learning & Growth Mindset
Continuous-learning questions probe whether the candidate has a real practice of growth, not just an enthusiasm for learning. Interviewers ask 'tell me about something you learned in the past year' to evaluate whether learning produces visible output, whether the candidate can name what was hard about the learning honestly, and whether the practice is sustainable rather than performative. The trap is the learning-as-performance reflex: the candidate lists impressive-sounding topics they have read about without showing the work or the output. The strong move is to demonstrate learning-and-shipping (the learning produced something observable), to show calibrated discomfort with stretch work, and to name the practice that makes the learning sustainable. After this lesson you will be able to take a real learning experience and tell it so the rubric reads curiosity that ships, not curiosity that performs.
Communicating Technical Concepts to Non-Technical Audiences
Communicating-to-non-technical questions probe whether the candidate can shape technical work so that it lands with people who do not share the candidate's context. Interviewers ask 'tell me about a time you explained a technical concept to a non-technical stakeholder' to evaluate audience-first framing, the discipline of leading with the listener's question rather than the candidate's interesting detail, and the calibrated trade-off between clarity and accuracy. The trap is the deep-dive reflex: the candidate explains the technology rather than the decision the listener has to make. The strong move is audience-first framing, the abstraction ladder (concrete examples, then abstractions, then diagrams or analogies), and the explicit choice to surface the trade-off rather than the implementation. After this lesson you will be able to take a technical situation and tell it so the rubric reads clarity-for-the-audience, not technical-depth-for-its-own-sake.
Persuading & Negotiating
Persuasion and negotiation questions probe whether the candidate can move a decision in a direction they think is right without burning the relationship that makes future decisions possible. Interviewers ask 'tell me about convincing your manager' or 'walk me through pushing back with data on a senior leader' to evaluate whether persuasion was framed in the listener's interest, whether the candidate surfaced the listener's criteria before proposing, and whether the candidate held the line between persuasion and manipulation. The trap is the win-the-argument reflex: the candidate retells the case they made for their own position. The strong move is persuasion-as-service: framing from the listener's perspective, surfacing their criteria, proposing with their criteria, and pre-empting their objections. After this lesson you will be able to take a persuasion or negotiation situation and tell it so the rubric reads listener-first influence, not advocacy.
Managing Stakeholders & Expectations
Stakeholder management questions probe whether the candidate can hold consistency, trust, and forward motion across a network of people whose interests do not all align. Interviewers ask 'tell me about managing competing stakeholder needs' or 'walk me through saying no to a stakeholder request' to evaluate whether the candidate maps stakeholders deliberately, manages expectations proactively rather than reactively, communicates on the right cadence for each kind of message, and says no with options rather than with friction. The trap is the keep-everyone-happy reflex, which produces over-commitment and surprises that erode trust. The strong move is calibrated stakeholder discipline: a deliberate map, proactive expectation-setting before surprises, three communication cadences (incident / proactive / scheduled), no-with-options rather than no-with-friction, and the upward-management discipline of giving senior stakeholders the information they need to back you. After this lesson you will be able to take a multi-stakeholder situation and tell it so the rubric reads calibrated coordination, not heroics.
Amazon: Leadership Principles Deep Dive
Amazon's behavioral loop is the most legible behavioral process in big tech. Every question maps to one of the 16 Leadership Principles, every interviewer is trained to score against a specific subset, and every loop includes a Bar Raiser whose job is to veto candidates who do not meet the published bar. This lesson walks through the principles that actually carry the most weight in practice, the loop format including the Bar Raiser, the value-to-question mapping interviewers use, and two fully worked LP-tailored model answers. After this lesson you will know which 6 to 8 stories to pre-bank, how to frame them in Amazon's own language, and what specific signals make an Amazon interviewer write 'inclined' versus 'not inclined' on the debrief form.
Behavioral for Frontend Engineers
Frontend behavioral rounds grade for a specific cluster of signals that the rest of engineering does not weight as heavily: substantive collaboration with designers and PMs, performance-and-accessibility judgement under real numbers, browser-and-device variation experience, and the discipline of treating the user-facing surface as the artefact. The behavioral signal is often woven into the system-design and UX-deep-dive rounds rather than concentrated in a dedicated People round. This lesson defines the cross-cutting frontend signals interviewers grade, walks through how the loop folds the behavioral signal into the technical rounds, maps the signals to the questions interviewers actually ask, and shows two model answers tailored to the design-collaboration and performance-investigation story shapes.
Stripe: Rigor and User Focus
Stripe is unusual among high-growth tech companies for the seriousness of its writing culture, the rigor of its decision-making, and the explicit weight given to a 'values' round in the loop. Candidates who walk in expecting a typical Silicon Valley behavioral interview misread it. This lesson defines the cultural posture Stripe actually grades for (users first, rigor, craftsmanship, urgency tempered by careful reasoning, asymmetric upside thinking, optimism), walks through the loop format including the dedicated values interview, maps Stripe's signals to the questions interviewers ask, and shows two model answers tailored to the rigor and user-focus signals Stripe privileges.
Airbnb: Belonging and Core Values
Airbnb is famous for its dedicated Core Values interview, judged separately from the technical loop and historically run by interviewers from outside the hiring team. The cultural framing is built around the four published values (Champion the Mission, Be a Host, Embrace the Adventure, Be a Cereal Entrepreneur) with belonging as the underlying anchor. This lesson defines what each value actually means in interview context, walks through how the Core Values round runs and why it can end an otherwise-strong loop, maps the values to the questions interviewers ask, and shows two model answers tailored to the host-mindset and mission-championing signals Airbnb privileges.
Behavioral for Backend / Infra Engineers
Backend and infrastructure engineering loops grade for a cluster of behavioral signals that frontend and product engineering loops weight less heavily: reliability and oncall judgement, capacity and scale thinking, data-integrity decisions under pressure, and the empathy-for-the-pager dimension that distinguishes engineers who can be trusted with production. The behavioral signal is most often woven into the system-design round and the oncall-and-incident round, with explicit story shapes (the 3am page, the SLO trade-off) that interviewers reach for. This lesson defines the cross-cutting backend signals interviewers grade, walks through how the loop folds the behavioral signal into the technical rounds, maps the signals to the questions interviewers ask, and shows two model answers tailored to the incident-response and capacity-planning story shapes.
Google: Googleyness & Cultural Fit
Google grades behavioural answers against four explicit attributes: General Cognitive Ability, Role-Related Knowledge, Leadership, and Googleyness. Of the four, Googleyness is the least defined and the most determinative. It covers comfort with ambiguity, bias to action, intellectual humility, collaborative posture, and a willingness to question assumptions without ego. Google's loop is also distinctive in that the hiring committee, not the interviewers, makes the final call, which means your answers are written down in detail and read by people who never met you. This lesson defines Googleyness in concrete terms, walks through the loop including the hiring-committee handoff, and shows two model answers tailored to the attributes Google actually scores.
Behavioral for Full-Stack Engineers
Full-stack behavioral rounds grade for a contested signal: the credibility of a single engineer who can ship a feature from data model to pixel without dropping any of the layers. The skeptical interviewer's silent question is whether the candidate is a real full-stack engineer with depth on multiple layers or a generalist who is shallow on every layer. This lesson defines the cross-cutting full-stack signals interviewers grade, walks through how the loop probes for breadth-with-depth rather than breadth-instead-of-depth, maps the signals to the questions interviewers ask, and shows two model answers tailored to the vertical-slice ownership and breadth-versus-depth navigation story shapes.
Meta: Move Fast and Core Values
Meta's behavioural loop is built around six core values published internally and externally: Move Fast, Focus on Long-Term Impact, Build Awesome Things, Live in the Future, Be Direct and Respect Your Colleagues, and Meta, Metamates, Meta. Their interview process uses an internal shorthand (Jedi for craftsmanship, Pirate for bias to ship, Ninja for cross-team scope) that interviewers reach for when calibrating fit. Meta also runs a behavioural round explicitly called the 'People' round and grades direct disagreement as a positive signal. This lesson maps the values to the questions, walks through the loop format, and shows two model answers tailored to Meta's preferred posture: high-velocity, direct, and willing to disagree productively in public.
Uber: Cultural Norms
Uber's culture has been through a deliberate reset under Dara Khosrowshahi's leadership, with a new articulation of eight cultural norms that are now the published rubric for behavioral interviews. The current cultural posture is meaningfully different from the pre-2017 framing the company has explicitly moved away from. This lesson defines the eight cultural norms and what each grades for in interview context, walks through the loop format including the bar-raiser-style hiring committee, maps the norms to the questions interviewers ask, and shows two model answers tailored to the act-like-owners and ideas-over-hierarchy signals Uber privileges most strongly.
Apple: Craftsmanship and Collaboration
Apple does not publish a list of values the way Amazon publishes the Leadership Principles, but Apple's behavioural loop has one of the most consistent cultural signals in big tech: craftsmanship over volume, ownership of the user experience end-to-end, simplicity as a posture, and tight cross-functional collaboration with design and hardware. Apple's interview process is also distinctive in its secrecy: candidates are often interviewed without being told the team or the product they would join. This lesson defines what Apple actually grades for, walks through the loop format and the secrecy constraints, and shows two model answers tailored to the craftsmanship and collaboration signals Apple privileges.
Behavioral for ML / Data Engineers
ML and data engineering loops grade for a cluster of behavioral signals that other engineering loops weight less heavily: experimentation rigor, the craft of being wrong with data and catching it yourself, data ethics judgement under tradeoff, ambiguity tolerance on problems where the right answer is not knowable in advance, and substantive collaboration with research and platform teams. The behavioral signal is woven heavily into the technical rounds (the ML system design round, the applied ML deep dive) as well as a dedicated behavioral round. This lesson defines the cross-cutting ML and data signals interviewers grade, walks through how the loop probes for experimentation discipline rather than story-telling about results, maps the signals to the questions interviewers ask, and shows two model answers tailored to the experiment-was-wrong and data-ethics judgement story shapes.
OpenAI: Mission Alignment and Safety
OpenAI's behavioral loop sits at the intersection of three signals that no other major engineering employer asks for in the same combination: substantive engagement with the AGI mission, serious consideration of safety as a daily constraint, and the intensity of frontier-lab work paired with collaborative care. Candidates who walk in with strong engineering credentials but no view on the mission, or who recite mission language without engaging with the safety-versus-capabilities tension, do not score well. This lesson defines what mission alignment actually means in interview context, walks through how the loop probes safety thinking specifically, maps the cultural signals to the questions interviewers ask, and shows two model answers tailored to the mission-articulation and intensity-with-care signals OpenAI privileges.
Netflix: Culture Memo and Freedom and Responsibility
Netflix is unique among big tech companies in publishing a long, opinionated Culture Memo that is genuinely the operating document of the company. The memo names ten values (Judgment, Communication, Curiosity, Courage, Passion, Selflessness, Innovation, Inclusion, Integrity, Impact) and three operating concepts (freedom and responsibility, stunning colleagues, context not control) that pervade every interview. The most distinctive feature of the loop is the keeper-test framing: the question every Netflix manager is trained to ask, 'would I fight to keep this person if they tried to leave', is the implicit grading rubric for every behavioural answer. This lesson maps the values to questions, walks through the loop, and shows two model answers tailored to Netflix's high-judgement, high-impact, high-honesty posture.
Startup Behavioral Interviews: What's Different
Behavioral interviews at 10-to-50-person startups operate by different rules than the FAANG and high-growth-unicorn loops covered earlier in this track. There is rarely a published values rubric, the interviewer is often a founder or an early engineer rather than a trained interviewer, and the signal the company is grading for is whether the candidate can build with the people in the room and the constraints they have. This lesson defines what is actually different about startup behavioral rounds, walks through the typical loop format and its quirks, identifies the cross-cutting signals startups grade for, and shows two model answers tailored to the ownership and ambiguity-tolerance signals that startups privilege most strongly.
Microsoft: Growth Mindset and Inclusivity
Microsoft's behavioural loop is shaped by Satya Nadella's deliberate cultural reset in the mid-2010s, which replaced a previous know-it-all stack-rank culture with a learn-it-all, growth-mindset, inclusivity-first posture explicitly anchored on Carol Dweck's research. The company publishes five values (Customer obsession, One Microsoft, Growth mindset, Diverse and inclusive, Make a difference) that are genuinely operationalised in interviews, performance reviews, and product decisions. Microsoft's loop also includes the 'as-appropriate round' (often called the AA round), a behavioural round whose explicit purpose is values-fit. This lesson maps the values to questions, walks through the loop, and shows two model answers tailored to Microsoft's growth-mindset and One-Microsoft posture.
Community
Sliding Window Technique
What sliding window actually optimises (state reuse, not just same-direction pointers), the fixed vs variable templates, four canonical problems, and when the technique is the wrong tool.
Rejected at the Offer Stage After Team Match Failed
I cleared a senior generalist loop with a verbal commitment from the recruiter. Eight weeks later team-matching closed without an offer. A postmortem on the failure mode.
Behavioral Paired With Design: The Bar-Raiser Pattern
A 4-question reconstruction of a bar-raiser loop where every behavioral prompt opened the door for a design follow-up. Each question pairs the story I told with the sketch I had to draw 20 seconds later.
The Mid-Level Coding Questions Most Loops Share
Five Python questions I have now seen at four different mid-level loops in 2024 and 2025. None are tricky; all five are testing whether you can write clean code and reason about edge cases out loud.
Python Decorators Explained with Five Real Examples
Decorators stop being magic the moment you see five real ones in a row: timing, caching, auth, retry, and rate limiting. Here is the pattern, the gotchas, and the line where I stop reaching for them.
Failed My Meta Interview: Lessons Learned
I cleared the phone screen for an E5 backend role at Meta and bombed the second onsite coding round on a problem I had solved twice in mocks. A postmortem on the failure shape.
Pure vs Tail Recursion and Why JavaScript Doesn't Care
What pure recursion vs tail recursion actually means, why tail-call optimisation matters, why mainstream JS engines refuse to ship it, and the iterative rewrite I default to when stack depth scales with input.
The Honest Guide to Amortized Analysis
Why amortized O(1) is not the same as worst-case O(1), the three accounting methods, and the real situations where the average bound stops being good enough.
Kubernetes Pod Scheduling Mental Model Drill
A 4-question reference set on how Kubernetes places pods: filter-then-score, requests vs limits, affinity and anti-affinity, and the taint/toleration machinery the kubelet uses to signal node health.
Series A Engineering Loop: The Founder Round
I interviewed at a Series A startup (12 engineers, devtools, NYC). The founder round was 45 minutes and decided everything. Here is what it was actually grading.
Datadog Onsite: Five Hours of System Design
A Datadog senior backend onsite where four of the five rounds were system design, anchored on real telemetry-shaped problems.
Data Engineer Loop: The SQL Test That Wasn't Just SQL
A data engineering loop at a Series C analytics company. The SQL round looked like a standard SQL test. It was grading something else entirely.
DevOps / SRE Interview: The Production Postmortem Round
An SRE loop at a Series D infra company, anchored on the round where they handed me a real-feeling postmortem and asked me to find what was missing.
The React Bugs I Keep Finding in Pull Requests
I review React PRs all week. These 5 bugs keep showing up: a memo that does nothing, a useCallback hiding the real fix, a SyntheticEvent that vanishes, a stale closure interval, and a batching surprise. Each one is the actual diff I left.
Recovering From a Bad Round, Mid-Loop
I bombed round 2 of a 5 round onsite and got the offer. Three loops later I bombed another round 2 and didn't. Here is what was different.
Startup vs. FAANG Interview Differences
I ran a Series B startup loop and a Meta loop in the same month. The shape, the calibration, and what each one was actually grading were nothing alike.
Rejected at Onsite After Three "Strong Hire" Rounds
I cleared three of four onsite rounds at strong-hire and bombed the fourth (behavioral) hard enough that the packet came back as no-hire. A postmortem on the round that broke me.
London Engineering Loop: What Differs From the US
I ran a London senior engineer loop after eight years in the Bay Area. Comp bands, right-to-work, IR35, and the cultural pieces I had to learn live.
PostgreSQL MVCC and Isolation Level Deep Dive
A 5-question reference set on PostgreSQL's MVCC implementation: tuple versioning, READ COMMITTED vs REPEATABLE READ vs SERIALIZABLE, row-level locks, and the autovacuum machinery that keeps txid wraparound at bay.
Spring Boot Bean Lifecycle Trivia
Four questions on Spring's bean lifecycle: scopes, init / destroy callbacks, circular dependencies, and conditional beans. Aimed at Java backend candidates who keep getting tripped up by the container.
Type Hints, mypy, and the Runtime Truth
Python type hints are documentation that a static checker reads. The runtime ignores them. Here is what hints do, what mypy adds, and the libraries that validate at runtime on purpose.
The Three Questions That Tanked My Onsite
Three problems from a senior backend onsite I failed in 2024. A median-of-stream I overcomplicated, a string compression where I missed a case, and a queue-with-min I never finished. Plus what I should have written.
Django ORM N+1 and prefetch_related Drill
Four questions on Django ORM patterns I keep flagging in code review: spotting N+1 in templates, choosing select_related vs prefetch_related, slicing prefetches, and avoiding the .count() trap.
Hash Tables: The Most Useful Data Structure
Why hash tables earn their reputation, where collisions and load factor actually bite, and the language-specific quirks (JS Map vs Object, Python dict, Java HashMap) that change the game.
Tradeoff Stories and the Design They Led To
A 5-question set where each behavioral tradeoff story is paired with the design choice it forced. Drawn from a senior backend loop where the interviewer kept pushing past the story into the code that proved it.
Interview Patterns Deep Dive
Monotonic stacks, binary tree serialization, and LRU cache design — three medium-difficulty patterns commonly asked at FAANG-tier interviews.
Context Managers Beyond with open(...)
The `with` statement is a setup-teardown primitive, not a file-handling shortcut. Five context managers I write or use weekly, plus the gotcha that turns a class-based manager into a leak.
The React Form Validation Traps I Keep Stepping On
Hand-rolled forms in React look easy until they meet real users. These 5 traps are the ones I keep regressing on: the empty-input case, controlled vs uncontrolled, when to stop hand-rolling, async race conditions, and the accessibility bit nobody catches in review.
TLS Handshake and Certificate Chain Quiz
A 4-question reference set on TLS 1.3: the handshake flights, certificate chain validation, SNI privacy, and mTLS rotation. Covers the practical knobs that show up at staff-level networking interviews.
FastAPI Dependency Injection Drill
A four-question drill on FastAPI's Depends system: caching, sub-dependencies, override patterns, and yield-based teardown. Aimed at developers preparing for a Python web backend interview.
Next.js App Router Quirks I Keep Mixing Up
Five App Router gotchas I keep tripping over six months into Next.js 15. Each one is paired with the exact mental model that finally made it click, in TypeScript.
P, NP, and Why You Rarely Care at Work
P, NP, NP-hard, NP-complete in working-engineer language: what each one means, why the open question matters less than the recognition signal it gives you, and what I do tell juniors about NP.
SRE Incident Drill Questions From Our On-Call
Four incident-shaped questions our on-call rotation uses to interview SREs. Each one starts with a symptom, asks you to write the smallest diagnostic snippet, and the discussion is more important than the code.
ML Engineer Onsite: The Whiteboard Math Round
An ML onsite at a Series D recommendation-systems company, anchored on the math round where I had to derive a logistic regression gradient on a whiteboard.
Amazon Bar Raiser Round: What Actually Tipped the Vote
A zoomed-in account of the bar raiser round in an Amazon SDE-2 loop, including the failure story I think turned a leaning-no vote into a hire.
Top K Frequent Elements
Return the k most frequent elements in O(n) time using bucket sort by frequency. A staple of mid-level interview rotations.
Backend Loop Questions That Actually Test System Design
Five backend coding questions where the surface is a function but the real signal is your system-design instincts. None of them want the cleverest algorithm; all of them want the right data model and the right failure mode.
My Google L4 Interview Experience
A round-by-round account of my Google L4 software engineer loop, from recruiter screen to team match, ending in an offer.
Heaps and Priority Queues: When the Order Matters
Why a binary heap is the right shape for top-K, Dijkstra, k-way merge, and scheduling, plus the one trap I have hit twice with mutable heap entries.
Tokyo Mid-Level SWE Loop: Cultural Nuances
I ran a Tokyo loop at a global tech company's Japan engineering office. The technical bar matched the global standard. The cultural register was its own thing.
asyncio Explained Without the Jargon
asyncio is a cooperative scheduler for I/O-bound code. async def marks a pause-able function, await is the pause point, and the event loop runs whichever coroutine is ready.
LLM Glue Questions From an AI Platform Loop
Four questions a senior engineer at an AI platform team asked me in 2024. Streaming token forwarding, retry-and-fallback across providers, tool-call validation, and a small token budgeter.
Sorting Algorithms Compared
The complete comparison table, why your standard library is almost always faster than what you would write, and the two questions that decide which sort you actually want.
The Three-Month Coding Interview Prep Plan
The week-by-week plan I have used twice and watched four others use, with the three traps that kill most prep schedules.
The Sysdesign Round Where I Talked Myself Out of an Offer
I drew a clean diagram, then over-explained every tradeoff until the interviewer no longer trusted any of them. A postmortem on a defensible answer that still got rejected.
The this Keyword: Six Rules and the Edge Cases
The six rules that fully decide the value of this in JavaScript: lexical for arrows, new, explicit binding, implicit binding, and the strict/sloppy default. Plus the four-step diagnostic I use on every this bug.
Stacks and Queues Cheat Sheet
LIFO vs FIFO, the operations that matter, and the language-specific footguns (JS shift, Python list.pop(0), Java Stack vs Deque) that turn O(1) into O(n).
Resume Tips From a Tech Lead Who Screens 100 a Month
What I actually look for in the 90 seconds I spend on each resume, the patterns that move me from "skim" to "phone screen", and what I have stopped caring about.
Discriminated Unions: The Best TypeScript Pattern
The strong-stance defence of discriminated unions: why distinct states should be a literal-tagged union of object types, the exhaustive-switch with never check, and shapes I reach for every week.
Amazon SDE-2 Loop: What to Expect
What the Amazon SDE-2 loop actually feels like, round by round, and how the leadership principles thread through every conversation.
The Frontend-Only Loop I Coach People Through
Five rounds I rehearse with frontend candidates: a DOM puzzle, a CSS layout, a state management drill, an accessibility audit, and a rendering performance question. JavaScript throughout, framework-agnostic where possible.
Conditional Types and infer Explained
The single ternary shape, the one inference rule that infer encodes, and the distribution behaviour over union types. Plus the standard utility types read as decomposed conditionals.
Generics in TypeScript: From Confused to Confident
What a type variable actually is, when constraints earn their place, the keyof T pattern that makes pluck type-safe, and the three-question test I run before introducing a generic.
Understanding Event Propagation: Capturing, Bubbling, and More
The three-phase event model in the DOM, why bubbling is the default for historical reasons, when capturing pays off, and how event delegation falls out of the same mechanic.
Series C Hyper-Growth Loop: Speed Over Polish
A Series C hyper-growth loop where the rubric was 'can you ship next week, not in three months'. The shape, the pushback, and the offer that came in 36 hours.
WeakMap and WeakSet: When They Actually Help
The narrow but exact problems weak collections solve: associating metadata with objects you do not own, memoizing on object identity, and seen-tracking without rooting. Plus the misuses that turn them into ineffective leak-papering.
Behavioral Interview Tips from 30+ Interviews
I have done 34 behavioral rounds across 4 job searches. Six things that actually moved the signal, five that did not, and the story bank shape I now keep.
The Mock Interview Rotation That Got Me Three Offers
The four-week schedule of mock interviews I ran before my last job hunt: who I interviewed with, what I asked them to do, and the feedback that mattered.
Remote-First Series B Loop: Five Async Rounds
A remote-first Series B ran their entire senior loop async. Three rounds were Loom videos and written replies. Here is how the rhythm and signals worked.
Hoisting: The Mental Model That Finally Stuck
The two-phase entry into every scope: creation phase creates every declaration's binding, execution phase runs the code. Once that order is fixed in your head, var/let/const/TDZ behaviour is mechanical.
React Server Components Mental Model Quiz
A 5-question quiz that builds the right mental model for React Server Components: where code runs, what can cross the network, when client boundaries cost you, and where async lives.
Frontend Engineer Loop at a Design-Centric Company
A 5 round frontend loop at a design-centric Series C SaaS. The CSS round, the rendering round, the design-system round, and what each one was actually grading.
Recursion Demystified
How to read recursion as a contract instead of a stack trace, the four parts of every recursive function, and where iteration beats it in practice.
System Design Interview at Stripe
A senior backend system design round at Stripe centered on idempotent webhooks, the failure mode I missed, and how the interviewer pushed me from a clean diagram to a defensible one.
The Stripe Loop Questions I Actually Got
A 5-question reconstruction of a senior backend loop at a payments company in 2024. Each one is paired with what the interviewer pushed back on and what I should have answered.
My Take-Home Assignment at a Fintech Company
An 8-hour take-home for a Series B fintech, the design call after, and the one question that decided whether the offer came.
dataclasses, attrs, and pydantic: Pick One
Three libraries solve the data-container problem and they answer different questions. dataclasses for internal objects, attrs for power-user customisation, pydantic for validating external input.
ML Engineer Pipeline Questions I Prep For
Five pipeline questions I bring with me to ML engineer loops. Training-serving skew, label leakage, batch vs streaming features, retraining cadence, and a small idempotent upsert into the feature store.
Bootcamp Grad to Mid-Level at a Series B Startup
I graduated from a 14-week bootcamp and spent 18 months interviewing for a mid-level role. The Series B loop that converted graded depth, not credentials, and the round that swung it was not the coding round.
The Airbnb System-Fit Questions I Prepped
Free set: four coding questions I rehearsed for a marketplace company's frontend loop. Every prompt is grounded in a real booking-domain object, because the interviewers grade modeling choices as much as code.
I Bombed a Behavioral Round on My Strongest Story
I had a story I had told fifteen times and it landed every single time. The sixteenth time it bombed. A postmortem on over-rehearsal, the tells that gave me away, and the rewrite that fixed it.
Python Packaging in 2026: pyproject, uv, and pipx
Python packaging finally converged. pyproject.toml is the source of truth, uv replaced pip plus venv plus pip-tools, and pipx owns global CLIs. The modern toolchain and the migration order that does not blow up CI.
Dynamic Programming Patterns
A 5-step framework that turns DP from magic into a checklist, the six recurring patterns, and the memoization-vs-tabulation decision that hides every space optimization.
Python Gotchas That Trip Up Experienced Devs
A 4-question reference set on Python pitfalls that look obvious in retrospect: mutable default arguments, is-vs-equals identity, the GIL's actual behavior, and closure late-binding in comprehensions.
Go Concurrency Questions From Real Loops
A 4-question reference set on Go concurrency patterns that appear in nearly every backend Go interview: worker pools, select with context, non-reentrant mutexes, and the errgroup fan-out pattern.
Monotonic Stack: The Pattern Everyone Skips
The next-greater-element trick that turns O(n^2) scans into O(n). Daily temperatures, largest rectangle in histogram, and trapping rain water, all from the same shape.
JS Questions I Ask Senior Frontend Candidates
A 5-question screen I run on every senior frontend candidate. Each one has a junior answer that passes, a mid-level answer that almost passes, and a senior answer I am actually looking for.
The Google L4 Coding Round I Bombed
Four questions from the L4 coding round I failed in 2023, with the exact follow-ups my interviewer pushed me on. Each entry shows the answer I wish I had given, plus the simpler one I missed.
Story Banking: Build Eight Stories, Not Eighty
Most candidates I mock with prep one story per behavioral question. That is the wrong axis. Eight well-built stories, mapped to themes, will cover thirty interviewers' questions.
How I Prepared for Coding Interviews in 3 Months
A 12 week prep plan I used while working full-time. Hours, problem mix, mocks, and the things I would skip if I were doing it again.
Linked Lists Explained
What linked lists actually buy you in modern code, the operations that make them shine, and why the answer is usually "use an array" anyway.
The JavaScript Debugging Stories From Real PRs
Four solutions to the same closure-and-var trap, plus one bug that took me an afternoon. 5 questions, all from real PRs where the test passed and the user-visible behavior was still wrong.
Express vs NestJS Middleware Quiz
Four questions comparing Express middleware to NestJS guards, interceptors, and pipes. Aimed at devs who came up on Express and keep reaching for `app.use()` when Nest already gives them a better seam.
Disagree-and-Commit Stories With a Design Twist
A 4-question set where each behavioral disagree-and-commit story gets a design follow-up that proves the commit was reversible. The pattern I lean on when an interviewer wants to see both sides of the same call.
Mobile Lifecycle and State Restoration Quiz
Four Android-flavored questions on activity lifecycle, configuration changes, and saved-state restoration. Aimed at native Android candidates and at backend devs interviewing onto a mobile-leaning team.
Senior Engineer Design Questions I Actually Use
Four open-ended design prompts I ask in senior engineer loops. There is no clean LeetCode answer; I am listening for how the candidate frames the tradeoff, when they push back, and whether they can ship a v1 before optimizing.
The Amazon Leadership Principles + Coding Mix
Five Java questions from an SDE2 loop where every coding prompt was framed by a leadership principle. The interviewer wanted my decision trail, not just the algorithm. Each entry shows the LP they were probing.
Coinbase System Design Round: What "Crypto-Native" Meant
A senior backend system design round at Coinbase where the generic exchange-order-book prompt was actually grading deposit confirmations, double-spend windows, and the cold-wallet boundary.
Staff+ Tradeoff Questions With No Right Answer
Four staff-plus prompts where the interviewer is testing whether you can hold two answers in your head and pick the right one for a specific context. The Python is intentionally thin: this is about judgment, not syntax.
List Comprehensions and When to Stop Using Them
Comprehensions are the fastest way to express a simple transform-and-filter, but they decay into write-only code the moment you nest them or sneak side effects in. Here is the line I draw.
The System Design Interview Framework I Use in Every Loop
The 45-minute structure I have used as a candidate and the rubric I now use as an interviewer. Sequencing, sample whiteboard, and the 6 common failure modes.
Incident Debrief Questions They Asked Me
A 4-question set drawn from the debrief portion of an SRE-flavored loop. Every behavioral prompt about an on-call story got paired with a design follow-up the interviewer used to stress-test the takeaway.
The CSS-in-JS Tradeoffs I Keep Explaining to Juniors
Five conversations I keep having: the styling-approach overview, build-time vs runtime CSS-in-JS, CSS Modules vs Tailwind, the styled-components performance trap I keep flagging, and when to walk back to plain CSS.
The Meta Frontend Loop Questions (2024)
Four utility-belt questions from a frontend loop at a large social platform in early 2024. They look like trivia but each one is graded on a specific edge case. Mine got me to round three.
Shopify Senior Engineer Loop: Take-Home Plus Architecture
A Shopify senior backend loop centered on a take-home, an architecture deep dive on what I built, and a Life Story round.
Two Pointers Technique
The three sub-patterns (opposite ends, same direction, fast-slow), the canonical problems each one solves, and why recognizing the shape is the entire skill.
Atlassian Senior SWE Loop: The Roadmap Round
How a roadmap-and-product round at Atlassian sank an otherwise solid senior backend loop, and what I would prep next time.
Module Systems: CJS, ESM, and the Interop Pain
Four sources of CJS/ESM interop pain (file extensions, bundlers, runtime, tooling), the dual-publish problem with module-level state, and what tsx, ts-node, esbuild, and bun do differently.
From QA to SWE: The Internal Transfer Path
I was a QA engineer for three years. The internal transfer to SWE took 11 months and three rejected internal interviews. A walkthrough of the path and the round that finally converted.
Java Streams and Collectors Deep Quiz
A 4-question reference set on Java streams beyond the basics: laziness and short-circuiting, downstream collectors in groupingBy, toMap collision handling, and when parallel streams actually pay off.
The Netflix Senior Bar-Raiser Set
Six Python questions that map to the bar-raiser part of a senior streaming-platform loop. The set rewards depth over speed: each prompt has a follow-up about failure modes, observability, or rollout.
Debounce, Throttle, and the Difference People Miss
Debounce settles, throttle paces. The visual difference, the canonical implementations of both (with leading-edge and trailing-call variants), and the three edge cases that bite hand-rolled wrappers.
Meta E5 Backend, Phone Screen to Offer
A full-loop account of my Meta E5 backend interview, from cold-applying through team match, with the rounds and the calibration I missed.
The React Context Traps I Keep Stepping On
I have lost the same Context fight on three different teams. These are the 5 traps I now check for in every Provider before approving the PR, with the rewrites that actually stop the re-render storm.
The DP Problem That Almost Ended My Interview
The interviewer dropped a DP problem at minute four. By minute thirty I had three broken solutions on screen. A postmortem on the round that ended in a no-hire.
Negotiating the Offer After a Mediocre Onsite
I negotiated the offer up 22% after an onsite I knew had gone sideways. The leverage was not what I had been told it would be.
DP Questions I Saw Coming and Still Missed
Four DP problems I recognized in the interview and still got wrong. Coin change with the wrong order of loops, LIS in O(n^2), edit distance with a missing base case, and a 2D grid DP with overcounted moves.
Prototypes vs Classes: What Is Actually Happening
The contrarian take that classes are no longer just syntactic sugar over prototypes. Walks the prototype chain, what new actually does, and the five things class adds that pure-prototype code cannot replicate without contortion.
Understanding Big-O Notation
What Big-O actually measures, why constants still matter at small N, and the four traps that catch even strong engineers in code review.
What I Ask Juniors Before Extending an Offer
The four questions I lean on when I am the last interviewer for a junior loop. They are not trick questions: each one tells me whether the candidate has actually built something or only studied for the interview.
Binary Search: Divide and Conquer
The template you actually need, three variations that cover most interview problems, and the off-by-one bug that catches every engineer at least once.
The "We'll Decide in 24 Hours" YC Startup Loop
A 4-engineer YC company ran me through their full loop in two days and made a decision in 24 hours. Here is the shape, the founder pressure, and why I declined.
Self-Taught Career Switcher: Three Years to Senior
I left a non-engineering career, taught myself to code, and landed junior, mid-level, then senior roles in 36 months. The arc, the three loops, and the bets that compounded.
Distributed Locks and Leases Deep Dive
A 5-question reference set on distributed mutual exclusion: Redis SETNX with fencing tokens, etcd leases, Raft leader election, optimistic vs pessimistic locking tradeoffs, and cross-region home-region pinning.
TypeScript Utility Types I Use Every Week
The seven utility types that show up in every PR (Partial, Required, Pick, Omit, Record, Readonly, ReturnType), plus the three I keep on standby (Awaited, Parameters, NonNullable/Exclude/Extract). When to derive instead of restate.
Data Engineering Pipeline Questions I Prep
Four pipeline-shaped questions I rehearse before data-engineering loops: incremental ingestion, idempotent upserts, late-arriving data, and a SQL window-function read. Python throughout, light on framework lock-in.
From Big Tech to Early-Stage Startup: The Reverse Path
I left a senior big-tech role to join an eight-person early-stage startup. The interview was four hours over coffee and a code review of my GitHub. The decision was harder than the loop.
The CSS Accessibility Tricks I Keep Using
Five accessibility moves I have committed to muscle memory: the visually-hidden snippet, skip links, focus-visible rings, reduced-motion, and a CSS variable trick that catches contrast bugs at build time.
