Interview Prep
Everything pointed at the interview loop — AI and system-design handbooks, language Q&A, the DSA roadmap and runnable coding challenges in one place.
Handbooks 62
The Agentic AI Interview Handbook
Twenty topics every senior AI engineer should be able to reason about live — from eval pipelines to reliability patterns for generative systems.
The Senior AI Engineer Interview Handbook
60 questions across architecture, production incidents, agentic systems, RAG, evals, cost, safety, and leadership — what staff-level AI interviewers actually probe for.
50 Angular Interview Questions
A visual handbook covering components, change detection, RxJS, signals, routing, forms, performance, and testing — what interviewers actually probe for in senior Angular roles.
50 Python Interview Questions
Fundamentals to advanced: data structures, OOP, iterators & generators, the GIL, asyncio, memory, testing, and the standard library — a visual walk through everything a Python interview touches.
51 LLM Evals Interview Questions
Golden sets, LLM-as-judge, regression testing, offline vs online evals, RAG evals, agent evals, red-teaming, and observability — demystified for interviews and production.
The Agent Evaluations Handbook
A self-contained handbook on evaluating AI agents — theory, interactive widgets, and practical guidance. Trajectory evals, tool-use scoring, LLM-as-judge, observability, and reliability for PMs, engineers, and founders.
The React Interview Handbook
What senior React interviews actually probe — components and JSX, props vs state, the render cycle with the virtual DOM and reconciliation, hooks and the rules of hooks, why components re-render and when memoization helps (and hurts), keys and lists, controlled inputs, and context vs prop drilling.
The Behavioral Interview Handbook
The round that decides your level — why behavioral interviews matter and what they signal, the STAR method with a worked example, building a flexible story bank, leadership and ownership, conflict, failure, ambiguity and prioritization, thoughtful questions to ask, and the red flags that sink good candidates.
50 System Design Interview Questions
The questions that actually come up in senior and staff loops, each with a concise, defensible answer you can say out loud: scaling and estimation, load balancing, caching, databases and sharding, CAP and consistency, message queues, reliability, and the classic design scenarios like URL shorteners and news feeds. Mark what you master as you go.
The Browser Internals Handbook
How a browser turns a tree of tags and a pile of CSS into a scrolling, animating picture at 60fps. The render pipeline — parse → style → layout → paint → composite — is ordered and dependent, so the cost of a visual change is how far back it reaches. Layout (reflow) is the expensive stage because boxes are interdependent (cost grows with node count); geometric changes (width, top, adding a node) force it, paint-only changes (color) skip it, and transform/opacity stay on the composite-only fast path. Plus layout thrashing (interleaved read/write forces a sync reflow each time — batch them), and virtualizing giant DOM trees. With worked math and a runnable reflow calculator.
The TypeScript Handbook
Why TypeScript surprises people from Java/C#: its type system is structural, not nominal — it matches by an object's shape, not a declared name. A value is assignable to a type if it has every property the type requires with a matching type ("if it walks like a duck…"), so a wider object (extra props) fits a narrower target but a missing property never does. Object literals get one extra rule — the excess-property check — that flags undeclared props to catch typos (which is why extracting to a variable can make a type error vanish). Plus structural vs nominal trade-offs, branded types, and the traps (any disables checking; types are erased so validate external data at the boundary). With worked math and a runnable assignability checker.
The React Handbook
React lets you write UI declaratively — return a description of what it should look like — and makes it fast with reconciliation: it builds a lightweight virtual DOM, diffs it against the previous tree, and applies only the minimal real-DOM changes. For lists it matches items by key: a key in both old and new means reuse the element in place (keep its DOM node + state), a new key mounts, a gone key unmounts — so a pure reorder with stable keys costs zero. The famous bug: using the array index as a key breaks on reorder/insert, because an index is a position not an identity, so React reuses the wrong element and state leaks to the wrong row. Plus unnecessary re-renders, memo/useMemo/useCallback, and why the virtual DOM isn't automatically fast. With worked math and a runnable reconciler.
The Salary Negotiation Handbook
The expected-value case for always countering an offer. A polite counter is accepted with some probability p and otherwise the employer just holds the original (they essentially never rescind over a reasonable ask), so EV = p·counter + (1−p)·original beats accepting for any p>0 — heads you win, tails you break even. Your BATNA (best alternative) is your real leverage and your accept-floor; improve it before the conversation with competing offers. And a base bump compounds — its lifetime value is a geometric series, ≈$55k for a $10k raise over 5 years at 5%, not $50k. Plus how to actually do it (research, let them anchor, counter in writing, negotiate the whole package and level) and the traps. With worked math and a runnable EV calculator.
The Code Review Culture Handbook
The quantitative case for code review plus the human norms that make it pay off. A defect costs ~1× to fix in review, ~10× in test, ~100× in production — so review, the earliest human checkpoint, catches bugs at the cheapest stage and returns many times the reviewer's time (net = bugs-caught × the prod-vs-review gap − review cost). But the ROI is only realized when the culture is right: small PRs (a giant diff gets a rubber-stamp = negative value), automated style so humans never nit it, prompt reviews, blocking-vs-nit clarity, and the golden rule — critique the code, not the coder. Plus how to give/receive feedback and the traps. With worked math (defect-cost curve + review ROI) and a runnable calculator.
The Resume & Portfolio Handbook
Your resume has two readers and the first isn't human. Most applications hit an ATS (applicant tracking system) that scores keyword coverage against the job — coverage = |resume ∩ required| / |required| — and auto-filters anything below a threshold, so a qualified engineer gets rejected on missing keywords. Step one: clear the machine by tailoring keywords in the posting's own words (for skills you have) in a clean single-column format that parses. Step two: win the human with quantified-impact bullets — a bullet with a number ("reduced latency 40%") beats a vague responsibility ("worked on the backend"). Plus what an engineer's portfolio needs (a few working, well-documented projects, curated not exhaustive) and the traps. With worked math (ATS coverage + gate, bullet impact) and a runnable resume scorer.
The Staff Engineer Behaviors Handbook
The hardest promotion in engineering — senior to staff — trips people up because they aim at the wrong target: writing more/better code, when the level is a change in the unit of impact. Senior is measured by own output; staff+ by leverage — the output you create in others (an architecture that unblocks three teams, a standard that speeds everyone, a mentee who levels up). Total impact = own_output + Σ multipliers, a team-wide boost is worth team_size × per_person_boost, and staff-level is the threshold where leverage dominates personal output. Covers Larson's four archetypes (tech lead / architect / solver / right hand), glue work and why it's under-credited, how to operate (work on what matters, write relentlessly, influence without authority, multiply others, stay technically credible), and the traps (hero IC, architecture astronaut, invisible glue). With a worked leverage model and runnable code.
The Forward Deployed Engineer: Role & Mindset
The fastest-growing engineering title in AI, demystified: what an FDE actually does (owns the customer outcome, not the ticket), how it differs from a software engineer, solutions engineer, and consultant, the mindset shifts it demands, a week in the life, and how to break in.
AI-Assisted Interviews
The 2026 technical-interview FORMAT (distinct from the content handbooks): AI is now allowed in the room, so the exam shifts from writing algorithms from memory to working WITH AI — code-comprehension rounds, AI-fluency rubrics, and frontier-lab eval-design rounds. The one equation behind the shift: when the AI is correct with probability p, a reviewing human's value is pure review skill — final = p·(1−p_falsepos) + (1−p)·p_catch — so a skilled reviewer lifts output above the AI alone while a careless one (breaks correct code, catches little) drags it BELOW raw AI (an unskilled AI user is net-negative). The new round types and how to prepare (read/audit/test, not just write). Worked math plus a runnable reviewer-value model.
Vibe Coding vs Spec-Driven Development
Vibe coding vs spec-driven development, two ways to build with AI: vibe coding is conversational and exploratory — prompt, run, keep what works; spec-driven development writes a precise spec first and has the agent implement against it with tests as the contract. The spec→plan→tasks→implement loop, where each breaks, and how to combine them.
The AI-Era Backend Engineer
How the backend-engineer job changes in the AI era — and how to be the one who gets more valuable, not less. Boilerplate, CRUD and first-draft tests get cheap; system design, debugging, security judgment and production ownership become the moat. The new stack (reviewing AI code, spec-driven development, evals + cost/latency for LLM features), five AI-augmented workflows, a judgment exercise, and a 90-day plan.
The AI-Era Frontend Engineer
How the frontend-engineer job changes in the AI era — and how to be the one who gets more valuable. Component scaffolding, CSS and markup get cheap; interaction and UX judgment, accessibility, performance and perceived latency, state architecture, and building AI-native interfaces (streaming, chat, copilot) become the moat. The new stack, five AI-augmented workflows, a judgment exercise, and a 90-day plan.
The AI-Era Product Manager
How the product-manager job changes in the AI era — and how to be the PM who gets more valuable. PRDs, research synthesis and comms get cheap; judgment, taste, user truth and accountability become the moat, plus a new stack: evals literacy, the unit economics of AI features, and agent/AI UX. Five AI-augmented workflows, a judgment exercise, and a 90-day plan. The career companion to AI for Product Managers (tool literacy).
The AI-Era DevOps Engineer
How the DevOps / platform-engineer job changes in the AI era. Pipeline YAML, Dockerfiles, boilerplate IaC and scripts get cheap; reliability, incident response, security, cost/FinOps and platform-as-product become the moat — plus a new stack: reviewing AI-generated infrastructure for blast radius, AIOps signal-vs-noise, and golden paths. Five AI-augmented workflows, a judgment exercise, and a 90-day plan.
The AI-Era Data Engineer
How the data-engineer job changes in the AI era. SQL, pipeline glue and connector code get cheap; data modeling, quality and contracts, cost, lineage and the semantic layer become the moat — plus a new high-demand specialty: building the data pipelines that feed AI (RAG ingestion, embeddings, eval datasets). Five AI-augmented workflows, a judgment exercise, and a 90-day plan.
The AI-Era QA Engineer
How the QA / test-engineer job changes in the AI era. Writing test scripts, selectors and boilerplate cases gets cheap; test strategy, exploratory testing, risk-based judgment, and the new discipline of testing AI and nondeterministic systems (evals, not assertEquals) become the moat. Five AI-augmented workflows, a judgment exercise, and a 90-day plan.
The AI-Era Engineering Manager
How the engineering-manager job changes in the AI era. Status reports, summaries and first-draft reviews get cheap; people leadership, technical judgment, hiring and setting direction become the moat — plus a new mandate: leading AI-augmented teams and measuring output, not activity. Five AI-augmented workflows, a judgment exercise, and a 90-day plan.
The New Grad in the AI Era
A straight answer to “AI is killing junior roles — what do I even learn?” The junior grind (boilerplate, glue, first-draft tests) is being automated, so the bar shifts to fundamentals, judgment, and working WITH AI earlier — and you need fundamentals more, not less. What to learn now, five moves for your first months, a judgment exercise, and a 90-day plan.
AI for Support Engineers
Support automation is the #1 deployed AI use case, so this role is changing fast. What AI automates (tier-1 tickets, FAQs, routing) versus what becomes valuable (hard troubleshooting, escalation judgment, empathy, and improving the AI itself), the new support stack, and the high-value pivots — agent-ops, AI-support engineering, and forward-deployed engineering. Five moves, a judgment exercise, and a plan.
AI for Data Analysts
Text-to-SQL and auto-dashboards are automating the mechanical half of analysis. What AI automates (writing SQL, basic dashboards, pulling numbers) versus what becomes valuable (asking the right question, judging whether data can be trusted, interpreting results in business context, and defining what the metrics mean), plus the analytics-engineering escape hatch. Five moves, a judgment exercise, and a plan.
AI for Technical Writers
AI drafts docs, generates API reference from code, and answers user questions directly — so fewer people read the docs at all. But the twist most miss: your documentation is now the context layer AI assistants, agents, and RAG systems read from, and an AI that reads wrong or unstructured docs gives confident wrong answers at scale. What AI automates (first drafts, boilerplate, formatting) versus what becomes valuable (information architecture, docs-as-context, docs-as-evals, owning the source of truth), plus the pivots — docs/DX engineering, developer relations, and AI knowledge engineering. Five moves, a judgment exercise, and a plan.
AI for Business Analysts
AI drafts requirements docs, turns meeting notes into user stories, summarizes stakeholder calls, and writes the SQL for your reports. But the hard part of business analysis was never the writing — it was asking the right questions, resolving conflicting requirements, and deciding what is actually worth building. What AI automates (documentation, first-draft stories, process diagrams, basic queries) versus what becomes valuable (problem definition, stakeholder judgment, process redesign, validating that requirements match reality), plus the pivots — analytics engineer, AI product manager, and product owner. Five moves, a judgment exercise, and a plan.
AI for Technical Program Managers
AI writes your status reports, summarizes the meeting, updates the tracker, and drafts the project plan — the reporting layer of program management is being automated. But the job was never the reports; it was driving cross-team execution, killing the risks that matter, and forcing decisions when senior people disagree. What AI automates (status, notes, trackers, first-draft plans) versus what becomes valuable (cross-org coordination, risk judgment, technical depth to challenge estimates, unblocking), how the TPM role differs from product management, and the pivots — engineering manager, product manager, and AI-program leadership. Five moves, a judgment exercise, and a plan.
AI for Scrum Masters
An honest handbook, because this role is under more pressure than most: standups, sprint analytics, backlog grooming, burndown reports, and retro summaries are exactly what AI automates — and much of the pure ceremony-facilitation scrum-master job goes with them. But coaching a team, removing organizational impediments, resolving conflict, and driving actual delivery do not automate. What AI takes over, what stays valuable, and the honest pivots — delivery lead, technical program manager, engineering manager, and org-level agile coaching. Five moves, a judgment exercise, and a plan.
AI for Developer Relations
AI drafts your blog posts, scaffolds tutorials, writes the sample code, and answers routine developer questions — and, bigger, developers increasingly ask an AI instead of reading your content at all. But that same shift creates two new high-value jobs only DevRel can do: making your product the answer the AI gives (GEO, llms.txt, docs-as-agent-context) and building the authentic community and trust no model can fake. What AI automates versus what becomes valuable, and the pivots — product marketing, product management, docs/DX engineering, and AI-visibility (GEO) specialist. Five moves, a judgment exercise, and a plan.
AI for Founders
AI collapses the cost of building — one person or a tiny team can now ship what used to take a whole engineering org. That is real leverage, but it cuts both ways: when everyone can build, building stops being the moat. What AI makes cheap (code, MVPs, first-draft everything, research) versus what becomes scarce and decisive (taste on what to build, distribution, a real wedge, customer truth, and judgment on what NOT to build), how to use AI leverage without fooling yourself, and where to place your bet. Five moves, a judgment exercise, and a plan.
AI for Game Developers
AI generates concept art, textures, 3D assets, boilerplate gameplay code, dialogue drafts, and procedural content — and it is reshaping game production faster than almost any creative field, asset pipelines first. What AI automates (asset production, boilerplate, first-draft narrative, playtest analysis) versus what becomes valuable (game design and game feel, original creative vision, knowing what is actually fun, and building AI into the game itself), plus the pivots — technical game designer, AI-gameplay engineer, and AI-leveraged indie. Five moves, a judgment exercise, and a plan.
Career Switch to Tech
Switching into tech got harder and easier at the same time, and pretending otherwise helps no one. Harder: AI now does a lot of the junior work, so the old learn-to-code-and-get-hired path is tighter and credentials count for less. Easier: AI lets a career-switcher build real, working things fast — and a portfolio of real things now beats a certificate. What changed, why your prior-career domain knowledge is an edge, how to aim above the fully-automatable entry rung, and a concrete plan. Five moves, a judgment exercise, and a realistic path.
The AI Consultant
Every company wants to adopt AI and most don't know how — the opening for AI consultants and freelancers. But building a demo is cheap; the value is positioning yourself in a specific niche, scoping projects that actually deliver, pricing on value instead of hours, and shipping real outcomes rather than prototypes that die in production. What is cheap versus valuable in AI consulting, the rules of positioning and scoping, and how to price and deliver. Five moves, a judgment exercise, and a plan.
AI for Network Engineers
AI and automation are eating the manual half of network engineering — per-device CLI config, routine changes, first-pass log analysis, and memorized command syntax. What gets automated versus what becomes valuable (network architecture and design, the hard cross-layer troubleshooting, security posture, and owning network-as-code), how AIOps changes operations, and the strong pivot into network automation and NetDevOps. Five moves, a judgment exercise, and a plan.
Blockchain to AI
A skills-transfer map for blockchain and crypto engineers moving into AI. Far more transfers than you'd guess: distributed systems, rigorous correctness, cryptography, working at scale, and incentive design are exactly what AI infrastructure needs — and skills most ML-first engineers lack. What carries over and where it applies, what you genuinely need to learn (ML fundamentals, the LLM/RAG/agent stack), how to target the systems-and-infra overlap, and a concrete plan. Five moves, a judgment exercise, and a transition path.
What Is a Forward Deployed Engineer?
The pillar definition, with sources: an FDE owns the full arc of a deployment inside the customer’s environment. The three species of the role (builder / pre-sales-shaped / internal), why postings grew 729% in a year, who hires, what the bar really is, and whether the title survives its own hype.
FDE vs Every Adjacent Role
One master table placing the Forward Deployed Engineer against eleven adjacent roles — software engineer, AI engineer, solutions engineer, architect, consultant, PM, DevOps, data engineer, SRE, TAM, customer success — on environment, ownership and comp shape, then the four deep comparisons and a four-check test for reading any job ad.
FDE vs Software Engineer
Same code, different physics. The ownership asymmetry that rewrites everything, two calendars side by side, why FDE comp is higher but far wider, what transfers from product engineering and what has to be built new, and honest checklists for switching in either direction.
FDE vs AI Engineer
Identical toolbox — RAG, agents, tool schemas, evals — but the AI engineer’s hard problem is the model and the FDE’s is the organisation around it. Where Applied AI Engineer and Agent Engineer land, negotiated evals as the skill that separates them, and how comp, ceiling and exits differ.
FDE vs Solutions Engineer & Architect
One question separates all three: after signature, who is accountable for what runs in production? Includes the 30-second test that reveals a relabelled pre-sales posting, one enterprise deal followed phase by phase, and the production-engineering gap to close if you are moving over from pre-sales.
FDE vs Consultant
Is forward deployed engineering just consulting with better branding? Three things genuinely separate them — running software, a product feedback loop, and equity — and each can quietly disappear. The services trap, four interview questions that detect it, and what FDEs should steal from consultants anyway.
Forward Deployed Engineer Salary, Explained
Why the public numbers differ by seven times, reconciled: base versus total comp, six employer tiers from frontier labs to defense integrators, the level ladder and what earns each rung, six questions for reading an offer, and the equity structure that makes most of the package an estimate about the future.
How to Become a Forward Deployed Engineer
The concrete route in: the real bar (staff-level judgement, not SWE-lite), six skills in dependency order, the one portfolio artefact that beats everything else, a 12-week plan, what to do coming from support / consulting / no degree, and an honest verdict on paid FDE courses and certifications.
Is Forward Deployed Engineering Worth It?
The honest version. Five named costs — coding atrophy, travel, accountability without control, the services trap, and a specific kind of burnout — each with the version of the job where it does not happen. Then the exits ranked by how naturally they follow, and eight questions that buy you out of the costs.
A Day in the Life of an FDE
Hour by hour, built from the published first-hand accounts: a customer-site day, a remote build day, and a launch-week day — plus how the 40/30/30 split actually swings across discovery, prototype, hardening and handoff phases of a single deployment.
FDE Interview Prep: The 9 Rounds
The complete Forward Deployed Engineer interview guide — decomposition, learning round, incremental coding, debugging/re-engineering, take-home + defence, client roleplay, values, customer-flavoured system design and behavioural ownership. What each scores, the five signals every company screens for, a four-week plan, and an interactive drill for every round.
The Palantir FDSE Interview
The loop that every other company copied: the online assessment, the panel drawn from a pool of five round types, and the decomposition round minute by minute — what strong candidates do in the first five minutes versus what fails. Plus the FDSE / Deployment Strategist split and a two-week prep plan.
The OpenAI FDE Interview
How the reported OpenAI forward deployed engineer loop works: the multi-hour API take-home, the required video walkthrough where it is actually graded, and the case/empathy rounds that carry roughly half the evaluation — with six habits that win the take-home.
The Anthropic Applied AI / FDE Interview
The most agent-shaped FDE role at a frontier lab: the escalating-constraint coding assessment, the deployment case where negotiated evals win it, and the values round that candidate reports call the highest-failure stage — plus exactly how to prepare for it.
The Sierra Agent Engineer Interview
Live incremental coding, a support agent you must build without an agent framework, and a debugging onsite with planted bugs. Why the no-framework constraint is the cleanest signal-extraction device in any published FDE loop — and the six decisions frameworks hide from you.
The Distyl AI Interview (AI Allowed)
One of the few companies that publishes its interview philosophy: use AI in the take-home, then defend everything it produced. The three anti-patterns they reject — Autopilot, Default and Demo — and a phase-by-phase split of what stays human when AI is permitted.
The FDE Take-Home Playbook
Take-homes are the centre of gravity in modern FDE loops and they are graded on judgement, not volume. The five-phase method with time budgets, what graders actually weight, a deliberately ambiguous five-hour practice spec, a 30-point self-scoring rubric, and how to prepare the video defence.
The Commercial Layer for FDEs
The part nobody teaches: reading a SOW before you are bound by it, the six clauses that cause all the pain, four pricing models and what each does to your week, telling a customer need from a rep’s quota, the services-trap arithmetic, and the renewal that starts nine months early.
Applied AI Engineer, Explained
“Applied” does not mean applied research — it means the model meets a real customer’s systems and you are standing where that happens. The published 40/30/30 split, how the title differs from AI engineer and ML engineer, the five badge variants in the family, and the two questions that identify any of them.
FDE vs FDSE vs Deployment Strategist
Palantir split forward-deployed work into an engineering ladder and a strategy ladder; most companies copied the title and not the split, which is why one word now means two jobs. What each role owns, how the loops diverge, and the career mistake this comparison exists to prevent.
AI Solutions Engineer
The engineer on the other side of the signature. Roughly a third of FDE-family postings are pre-sales-shaped: what that means across the deal cycle, how OTE changes which customers you spend time on, why “how accurate is it?” must not be answered with a number, and the four questions to ask before accepting.
The FDE Canon
Ten sources that actually explain the role — first-hand accounts, job descriptions read as documents, the commercial argument, and the market data — each with what to take from it and what it is silent about. Read in this order, and note honestly what is missing: almost nothing good exists on identity, security review, the commercial layer or evals.
Roadmaps 5
Data Structures & Algorithms Roadmap
A visual transit-map roadmap from Big-O and arrays through hashing, sorting, and trees to graphs, Dijkstra, A*, and dynamic programming. 18 stations across 3 tracks — seven of them fully playable. Interactive, free, your own pace.
Frontend Engineer Roadmap
A visual transit-map roadmap to become a frontend engineer in 2026. From HTML, CSS, layout, and JavaScript through TypeScript, React, state, and data fetching to bundlers, rendering, Core Web Vitals, and deployment. 18 stations across 3 tracks — Foundations, Core Frontend, Production.
Engineering Manager Roadmap
A visual transit-map roadmap to become an engineering manager in 2026. From the IC-to-manager shift, 1:1s, feedback and delegation through performance management, growth, difficult conversations and culture to strategy, stakeholders, org design and managing managers. 18 stations across 3 tracks — The Transition, Leading People, Leading the Org.
Mobile Engineer Roadmap
A visual transit-map roadmap to become a mobile engineer in 2026. From native vs cross-platform, a language, UI, state and navigation through storage, concurrency, platform APIs, testing and offline-first sync to architecture, mobile CI/CD, app-store release, crash reporting and the mobile career. 18 stations across 3 tracks — Foundations, Building Apps, Shipping.
Embedded Engineer Roadmap
A visual transit-map roadmap to become an embedded engineer in 2026 — with a full edge-AI track. From embedded constraints, C and microcontrollers through memory, peripherals, RTOS, interrupts, low-power and OTA to on-device model optimization, TinyML inference on microcontrollers, NPUs and the on-device AI product and career. 18 stations across 3 tracks — Embedded Foundations, Systems & Real-Time, Edge AI & the Frontier.
Paper Breakdowns 3
The 95% Number, Examined
The most-quoted statistic in enterprise AI, read carefully: roughly 95% of pilots reportedly produced no MEASURABLE profit-and-loss impact. Two words carry the sentence. "Measurable" means attributable financial effect — not accuracy, not satisfaction — and "pilot" means a bounded trial, which selects for projects that end before an accounting period closes. Three separate failures hide inside the one number: MEASUREMENT failure (it worked and no baseline exists, because nobody captured the before-picture in week one and it is unrecoverable afterwards), ATTRIBUTION failure (something improved and three other things changed the same quarter, so finance will not credit yours), and ACTUAL failure (the workflow was wrong or nobody adopted it). The first two are why the forward deployed role exists — both are solved by work before and after the model. Sourced, confidence-labelled (reported via press coverage, not a public methodology), and paired with the a16z argument it mirrors.
Trading Margin for Moat
Why a software company would deliberately hire expensive engineers to do customer work. The services-led-growth thesis: spend gross margin on deployment depth because the resulting integration is hard to displace and the outcome is provable — the margin hit is an acquisition cost for defensibility, not an inefficiency. The arithmetic that decides whether it holds, as a worked napkin example: an FDE at ~$300K loaded doing 3 deployments a year costs ~$100K per deployment, which is 67% of a $150K ACV and 17% of a $600K one — and REUSE is the only term that improves over time (0.6x, then 0.4x). The failure mode built into the thesis is paying the margin and not receiving the moat, which arrives one reasonable exception at a time. Diagnostic: does deployment N take measurably less time than N−1? Plus what the trade means for your career and the two questions to ask an employer.
1,000 FDE Jobs, Analysed
Reading a thousand job postings beats reading a thousand opinions. One title covers at least THREE distinct jobs — builder (few customers, deep, milestone-driven), pre-sales (many customers, shallow, quarter-driven, often with quota), and internal/platform — and roughly a third of postings using the FDE title are the pre-sales shape, which the posting rarely makes explicit. A separate census counted 1,206 strict-definition postings across 669 companies at a ~$185K median posted base. What every posting asks for: strong general engineering, LLM app patterns, integration reality, deployment where you do not own the cloud, and increasingly MCP servers as deliverables — with EVALUATION the most-cited hard skill and the least taught anywhere. How to read a posting properly, the two questions that settle which species it is, and the honest caveat that posting counts measure demand signals rather than filled roles.
Coding Challenges 14
Two Sum
The classic warm-up: find the two numbers that add up to a target. Brute force is O(n²) — a hash map gets you to one pass, O(n). Solve it in Python or TypeScript, right in your browser, with hidden tests and a reveal-solution button.
Valid Parentheses
The canonical stack problem: decide whether every bracket is closed by the right type, in the right order. A stack turns nested matching into a single pass. Solve it in Python or TypeScript with hidden tests.
Fizz Buzz
The famous screening question. Print 1…n, but multiples of 3 become "Fizz", of 5 become "Buzz", and of both become "FizzBuzz". Easy — the catch is testing divisibility in the right order. Solve it in Python or TypeScript.
Softmax
The function at the end of every classifier and language model: turn raw scores (logits) into a probability distribution. Implement the numerically stable version so big logits do not overflow. Solve it in Python or TypeScript.
Cosine Similarity
The measure behind every embedding search and RAG system: how aligned are two vectors, ignoring their length? Dot product over the product of magnitudes — 1 identical, 0 orthogonal, -1 opposite. Solve it in Python or TypeScript.
Top-K Retrieval
The core of the "R" in RAG: given a query embedding and a set of document embeddings, return the indices of the k most similar docs by cosine similarity, with a stable tie-break. Solve it in Python or TypeScript.
Token-Level F1
The metric behind QA evaluation (SQuAD and friends): how well does a predicted answer overlap a reference as a bag of words? Compute token precision and recall, then their harmonic-mean F1. Solve it in Python or TypeScript.
Spot the Bug in AI Code
An assistant wrote a chat-history trimmer that looks right, passes the obvious case, and silently drops the system prompt the moment the conversation gets long. Reviewing AI code means catching exactly this: confident, plausible, wrong on the case that matters. Find the bug and fix it. Solve it in Python or TypeScript, with hidden tests.
Read the Codebase, Fix the Bug
The skill an AI can’t fake for you: drop into unfamiliar code, trace how the pieces call each other, and fix the one that’s wrong without breaking the rest. A reverse-Polish calculator spread across three functions gets subtraction and division backwards — read the operand flow, then fix it at the source. Solve it in Python or TypeScript, with hidden tests.
Re-Engineer a Legacy ETL
You inherit an aggregation nobody can explain and the totals are wrong. Three planted defects — an exclude-list where the spec wants an include-list, a dedupe key missing a field, and pre-seeded customers that should never appear. The FDE re-engineering round. Solve it in Python or TypeScript, with hidden tests.
Repair the Spread Traversal
Inherited code computes how far something spreads through a contact graph, and the answers are wrong in a way that is invisible on small inputs. A one-way adjacency map, a frontier with no dedupe, and a seen-set updated one step too late. Solve it in Python or TypeScript, with hidden tests.
LRU Cache, Constraint by Constraint
The incremental-coding round, packaged: a cache that becomes bounded, then least-recently-used, then instrumented — each stage invalidating the shape of the last. Tests whether your first version can absorb the next requirement. Solve it in Python or TypeScript, with hidden tests.
Deep Clone, Constraint by Constraint
The incremental round on a problem where stage three genuinely breaks the obvious design: copy an object, then nested structures, then one containing a cycle, then one where two keys must still share the same clone. A visited set stops the crash and fails the last stage. Solve it in Python or TypeScript, with hidden tests.
Rate Limiter, Constraint by Constraint
A third incremental round, where stage two invalidates stage one outright: a fixed-window counter becomes a sliding window, then per-key, then gains a burst allowance. Tests whether you can say “that counter has to go” calmly and refactor. Solve it in Python or TypeScript, with hidden tests.
Labs 5
The Decomposition Round, Simulated
Don't read about the FDE decomposition round — sit it. Pick a case (taxi fleet, emergency response, fraud unification, marketplace) and get scored on the five clarifying questions you ask <em>before</em> the propose button unlocks, then on which sub-problems you attack and in what order, then on the two things you explicitly refuse to build. Premature solutioning scores negative, exactly like the real round. Ends with an interviewer verdict and a band. The signature Palantir-style round, interactive nowhere else.
Client Roleplay Simulator
The four conversations that actually decide deployments, as branching dialogue: your demo breaks in front of their CTO, a stakeholder insists on the wrong feature, security will not release the data, and a manager whose team gets smaller keeps raising objections. Every reply moves a live trust meter and changes what they say next. Ends with a scored verdict against the four signals FDE interviewers screen for — the round every guide tells you to rehearse with a friend.
The Learning Round, Simulated
Learn a library that does not exist. You get the internal docs for <code>flowpkg</code> — a package installer with dependency stages, a barrier between them, ordered post-install hooks and idempotent installs — in three unlocking sections with comprehension gates. Two rules are deliberately buried, and the last question can only be answered by combining rules from different sections. Tests reading strategy, not recall, exactly like the real round.
Stakeholder Politics Lab
Deployments die on org charts, not architecture. Six people at one customer, each identified by a single sentence — classify them as economic buyer, champion, end user, blocker or data gatekeeper, and expect the titles to mislead you at least twice. Then handle the three situations that actually end projects: the gatekeeper who never says no but never grants access, the team lead whose people you are automating, and the champion who resigns in month five — while a coalition meter tracks who is still with you.
Domain Ramp Sprint
The FDE meta-skill, drilled on three real verticals — insurance claims, hospital revenue cycle, or legal discovery. Learn the vocabulary that turns out to be codes (<code>status 7</code>, <code>CO-45</code>, TAR), reconstruct the workflow people actually follow rather than the one on the diagram, then pass expert gates including the one that asks which rule lives only in a practitioner's head. Scored on whether you could hold a conversation with them on Monday.
Interactive Tools 4
Interactive Capacity Estimator
Slide DAU, requests per user, payload size and read/write ratio and watch QPS, storage per year, bandwidth, shard count and cache memory recompute live — every number with the formula behind it. The napkin math interviewers expect, made interactive.
AI Salary Explorer
A quick, transparent estimate of total-compensation ranges for AI and software roles in 2026. Pick a role, level and company tier and it shows an indicative band, built from a public base rate and clearly-labelled tier and level multipliers rather than a black box. Calibrated so the anchors match reported figures — a senior big-tech AI engineer around the low-$200Ks, a frontier-lab senior in the high-six-figures. These are self-reported market ranges for orientation and negotiation prep, not an offer or advice — always verify live on a source like Levels.fyi.
FDE Comp Explorer
Forward Deployed Engineer compensation, decomposed. Pick an employer tier (frontier lab, Palantir, AI infra, vertical startup, big tech, defence), a level and a market, and see the base/equity/bonus split rather than one headline number — plus the reported band, the confidence label on the underlying source, and the six questions that change what any offer actually means. A transparent multiplier model with its anchors and sources stated, not a scraped table.
Scoping Question Log
A drill for the skill every discovery call actually tests. Two underspecified customer asks, twelve candidate questions each, and a budget of six — spend them, see what the customer really says, and get each question scored on whether the answer changes what you build. Ends with a copyable scoping doc, a coverage map across the six axes, and the thing that was really going on that you either found or missed.
About interview prep
Technical interviews sample a few skills under pressure: can you talk through a system's trade-offs, implement a core algorithm cleanly, and explain how you'd know your solution works? This topic points every relevant piece of the site at that loop — the AI and system-design handbooks, language Q&A, the DSA roadmap and runnable coding challenges.
The most reliable prep isn't cramming; it's building genuine understanding of a handful of recurring patterns and then practising them until they're fast. Explain a design out loud, implement a metric or algorithm by hand, and you'll walk into the room with substance rather than memorised answers.