Forward Deployed Engineering
The trending customer-facing engineering role: discover the problem on site, prototype fast, integrate with the customer’s systems, deploy in their environment, demo, harden, and hand off — everything for becoming a Forward Deployed Engineer.
Handbooks 53
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 Agent Patterns Handbook
The design patterns behind every LLM agent — the ReAct Thought–Action–Observation loop, tool/function calling, plan-and-execute, reflection, memory, multi-agent orchestration, and the failure modes (loops, hallucinated tools, recovery, human-in-the-loop) that break agents in production.
The Kubernetes Handbook
The one idea under all the YAML — declare desired state, and a control loop makes reality match. Covers the orchestration problem, pods, deployments and replicasets, services and networking, the reconciliation loop and self-healing, the scheduler, config/secrets and health probes, autoscaling, and when you actually need Kubernetes.
The Observability Handbook
Seeing inside production — monitoring vs observability, the three pillars (metrics, logs, traces) and what each answers, structured logging, metric types and the cardinality trap, distributed tracing, the golden signals and SLIs/SLOs/error budgets, alerting on symptoms not causes, and correlating all three during an incident.
The AI Security Handbook
Your app now reads the internet and believes it. Why prompt injection is a design problem filters cannot solve, the lethal trifecta (private data + untrusted content + exfiltration), defense in depth from least privilege to output validation, where PII actually leaks (logs, embeddings, weights), MCP/model supply-chain trust, and the red-team eval suite that gates CI.
The Docker Handbook
A container is a lie told by the kernel — namespaces (what a process sees) plus cgroups (what it uses), not a VM. Image layers and the cache-ordering rule that halves build times, multi-stage Dockerfiles that ship small, volumes vs bind mounts, name-based networking, Compose, and the handoff to Kubernetes.
The API Design Handbook
An API is a promise you keep for years. Choosing REST vs gRPC vs GraphQL honestly, resource-modeling REST so consumers can guess it, contract-first gRPC and protobuf evolution, the retry-safe semantics that survive real networks (idempotency keys, cursor pagination, structured errors), versioning without breaking clients, and why agent tool schemas are the newest API surface.
RAG vs Fine-Tuning
The most common wrong turn in AI engineering — reaching for fine-tuning when you needed retrieval, or vice versa. The one distinction that decides it (knowledge vs behavior), a head-to-head table, when to use each, and why the strongest systems combine them: fine-tune for behavior, RAG for knowledge.
MCP vs Function Calling
Pitted against each other, but they live at different layers — like comparing USB-C to sending data. Function calling is the model capability to emit a structured tool request; MCP is the open standard for discovering and connecting to tool servers. How MCP uses function calling, and when each matters.
The LLM Observability Handbook
Tracing an AI request as a tree of spans. Why total latency is the critical path — the max end time, not the sum of durations, because parallel spans overlap — while cost is the sum across every span, how to find the bottleneck span, and what to log for every LLM call (including percentiles over averages). With worked math and runnable code.
The Evals in CI Handbook
Turn LLM quality into a regression gate, like unit tests for code. A golden set scored on every change, and why the gate needs both an aggregate threshold AND per-case no-regression — because a healthy average can hide a broken case (mean stays up while one case collapses). How to wire it into the PR pipeline, handle non-determinism with a tolerance band, and avoid a flaky gate. With worked math and runnable code.
The OAuth & Auth Deep Dive
How "Sign in with Google" lets an app act for you without ever seeing your password. OAuth swaps your credentials for a scoped, revocable token, delivered via a short-lived authorization code that's worthless on its own — turning it into a token needs a back-channel exchange the browser can't make. Two parameters guard the flow: state (a random value echoed back, blocking forged/CSRF responses) and PKCE (challenge = SHA-256(verifier), so a stolen code can't be redeemed without the secret). Plus authentication vs authorization, OIDC/ID tokens, and the traps (implicit flow, unvalidated tokens, wide scopes, token leaks). With worked math 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.
Customer Discovery & Scoping for FDEs
How FDEs find the real problem before building the wrong one: the wrong-problem tax, watching users instead of asking, the questions that surface truth, defining success as one number, scoping the smallest slice that proves value, and the red flags that mean a deployment will stall.
Customer Integration Patterns for FDEs
Integration is where POCs die. The FDE playbook: the five integration families (REST/GraphQL, webhooks, files/SFTP, database/CDC, queues), auth into customer systems (API keys, OAuth, mTLS), reliability at the edge (idempotency, retries with jitter, webhook verification, dead-letter), and mapping messy customer data.
Rapid Prototyping for FDEs
How FDEs build a convincing prototype in days, not months: throwaway-first thinking, the smallest demoable vertical slice, choosing a boring fast stack, faking the non-core parts honestly (hardcode / stub / Wizard-of-Oz), demo-driven development, and knowing when to throw it away versus harden.
Deploying in Customer Environments
Ship where the customer can actually run it: the four deployment targets (your SaaS, the customer’s cloud/VPC, on-prem, and air-gapped), what changes as you move right — data egress, updates, model hosting, secrets, observability, and your own access — plus packaging portably and the air-gapped update path.
The Demo & Storytelling Playbook
A demo is a performance, not a code review. How FDEs prep (their data, rehearse, a fallback recording), structure the story (open with the problem, show-then-explain, land the "so what"), recover from a live failure without debugging on stage, read the audience (exec / IT / user), and follow up while it’s hot.
Security & Compliance for FDEs
Enough security to earn a customer’s "yes": what SOC 2, HIPAA, GDPR and PCI actually ask, how to handle data and secrets, what a security review checks, and the AI-specific risks (prompt injection, data leakage to model providers, PII in prompts) an FDE has to manage.
Solutions Engineering & Stakeholder Management
The non-code half of the FDE job: mapping the room (champion, blocker, decision-maker, user), managing scope creep with a visible later-list, saying no kindly, setting expectations and surfacing risk early, and multi-threading so one person can’t sink the deployment.
From POC to Production: Hardening
The gap between "it demoed" and "people depend on it": how FDEs harden a proof of concept into a real system — reliability (sad-path handling, idempotency, backpressure, validation), observability (structured logs, metrics, health checks), security and config hygiene, and the harden-versus-rebuild decision.
Handoff & Enablement for FDEs
How FDEs hand off a deployment without becoming a permanent, unpaid support team: why the exit is the goal, what to hand off (runbook, docs, architecture, who-to-call), how to write a runbook that survives 2 a.m., enabling the customer’s team hands-on, and defining the exit up front.
Learning a Customer’s Domain Fast
How FDEs get dangerous in a new field in a week: why domain fluency is a superpower, learning from the customer’s real data, running SME interviews that teach you (the naive-question license), building a glossary of their terms, finding the 80/20 of a domain, and how fluency compounds trust.
AI App Patterns for FDEs
The AI toolkit a modern FDE deploys: RAG over the customer’s documents, agents that drive their workflows, and evals as the acceptance test — plus how to choose between prompting, RAG, agents, and fine-tuning, and how to ship AI honestly with a good-enough bar and a human in the loop.
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.
Evals for Client Work
The most-cited hard skill in frontier-lab FDE job descriptions and the least taught anywhere: turning “it should be accurate” into a gate. Measure inter-expert agreement before you promise a number, build a golden set that survives contact, calibrate an LLM judge against human grades, wire the CI gate (including the per-case regression check), and hand the whole thing over.
Proving Value & ROI
Roughly 95% of enterprise AI pilots showed no measurable P&L impact — and “measurable” is doing the work in that sentence. Capture the baseline in week one, agree one number, instrument adoption and override rate, survive the three standard ROI objections, and run the 45-minute business review that decides the renewal.
Incidents, On-Call & SLAs for FDEs
Production in an environment you do not own: negotiating an SLA whose clock starts when you are paged (not when a user noticed), surviving a one-person rotation, running an incident when logs cannot leave their network, writing a post-mortem with the renewal decision-maker in the room, and engineering your way out of the rotation in four milestones.
Enterprise Identity for FDEs
The layer that blocks more enterprise deals than model quality ever will. SAML vs OIDC and when the customer decides for you, SCIM deprovisioning (a PATCH setting active to false, not a DELETE), group-to-role mapping that survives a reorg, workload identity instead of a static key, and the five artefacts a security reviewer will ask you for.
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.
MCP for FDEs
Anthropic’s FDE job description names MCP servers as a deliverable. Designing a tool surface a model can actually use, wrapping a 2009 SOAP service and a stored procedure as tools, putting the code-to-word vocabulary in the server, and the four trust-boundary questions between customer data and a model that reads anything.
Air-Gapped & Regulated Deployment
Five things customers mean by “air-gapped”, FedRAMP and DoD impact levels explained for engineers, the eight-step path model weights take into a disconnected network, update cadences set by a change board rather than your CI, and why evals are the first thing that breaks when telemetry cannot leave.
IaC for Customer Environments
Terraform and Helm when the account, the cluster and the change process all belong to someone else: who holds state, the seven things a no-egress VPC breaks at runtime, referencing secrets you must not read, and the clean-room rebuild that is the only honest test of a handover.
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 1
System Designs 7
Design Webhook Ingestion at Scale
Build a reliable webhook ingestion pipeline — the backbone of every integration. Learn signature verification and replay protection, acknowledging fast with a durable queue, idempotent processing that turns at-least-once delivery into effectively exactly-once, bounded retries with a dead-letter queue, replay after a fix, and monitoring consumer lag and DLQ depth.
Design a Customer Data Integration Pipeline
Build the pipeline that ingests a customer’s messy data on almost every deployment. Learn source connectors (API, SFTP, database, change-data-capture), staging, validation and mapping to a canonical schema, quarantining bad rows instead of dropping them, incremental sync by checkpoint, idempotent upsert loads with backfill, and reconciliation that proves the data landed.
Design Multi-Tenant Customer Isolation
Serve many customers from one system without ever leaking data between them. Learn tenant context propagation, the data-isolation spectrum (row-level, schema-per-tenant, database-per-tenant), preventing noisy neighbors with per-tenant quotas, per-tenant encryption keys and config, and audit plus automated cross-tenant tests that make isolation provable.
Design an Audit Logging & Compliance Trail
Build the audit system that passes a customer’s security review. Learn structured capture of who-did-what-when, an append-only immutable (WORM) store, tamper-evidence with hash chaining, retention and archival for compliance windows, and access-controlled querying that redacts sensitive data and audits the auditors.
Design an Enterprise Eval Pipeline
Turn “it should be accurate” into a gate that blocks a merge. Learn a stratified frozen golden set, the inter-expert agreement ceiling that sets a defensible target, an LLM judge reported with its calibration, a CI gate asserting per-case regressions rather than an average, drift monitoring that separates distribution shift from score decay, and the one business number the renewal actually turns on.
Design an Agent Harness (AI-Supervised Delivery)
The shift from writing feature code to writing the systems that write it. Learn task decomposition into machine-verifiable units, a narrow designed tool surface instead of shell access, per-task sandboxes that make failure cheap, a verification gate the agent cannot reach, a review queue routed by blast radius, repo-grounded context, and the ledger that makes agent work auditable.
Design Enterprise SSO & Provisioning
The layer that blocks more enterprise deals than model quality. Learn multi-tenant SAML and OIDC federation, keying users on an immutable subject identifier, SCIM where deactivation arrives as a PATCH rather than a DELETE, group-to-role mapping that survives a reorg, revoking live sessions and API tokens inside the promised window, and the evidence a security reviewer asks for.
AI System Designs 2
Deploy an LLM in a Customer’s Environment
Deploy a large language model inside a customer’s own environment — the constraint a forward deployed engineer meets when a regulated customer won’t send data to a public API. See why a hosted endpoint is a non-starter, right-sizing the model and precision to the fixed hardware they actually own, serving efficiently on limited GPUs, running with no network egress (air-gapped, no phone-home), shipping model and security updates as signed bundles into a locked-down environment, and getting observability out without exfiltrating customer data.
Design Secure Document Ingestion + RAG
Build a retrieval-augmented assistant over a customer’s sensitive internal documents, where security — not relevance — is the hard constraint. See why naive RAG leaks documents across users, classifying and tagging access on ingest, permission-aware retrieval that intersects relevance with what the user may see, redacting PII and secrets before the prompt and logs, defending against prompt injection carried inside untrusted documents, and citing sources plus auditing every access so the pipeline can pass a security review.
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 16
Retry with Exponential Backoff
Tools time out and APIs rate-limit — a production agent retries without hammering. Exponential backoff waits longer after each failure (1s, 2s, 4s, 8s…) up to a cap. Compute the delay schedule: delay[i] = min(cap, base·2ⁱ). Solve it in Python or TypeScript.
Verify a Webhook Signature
Every real integration sends signed webhooks — and every FDE has to verify them. Recompute the signature over the payload, compare in constant time, and reject stale events to stop replay attacks. Solve it in Python or TypeScript, with hidden tests.
Idempotency Key Handler
Networks retry. A webhook fires twice; a payment is re-sent after a timeout. Without idempotency you double-charge or double-write. The fix: dedupe by a client-supplied key and always return the first result. Solve it in Python or TypeScript, with hidden tests.
CSV → Schema Mapper
Every customer hands you a messy export. Before it flows into your system, each row must be coerced to a schema — strings to ints, "true" to booleans — and the rows that don’t fit quarantined, not silently dropped. Solve it in Python or TypeScript, with hidden tests.
Data Reconciliation Diff
The customer swears the migration worked. You reconcile: compare source records against what landed in the target, keyed by id, and report exactly what was added, removed, or changed. Solve it in Python or TypeScript, with hidden tests.
PII Redactor
Before customer data touches a log line — or a third-party LLM — the personal bits have to go. Mask emails, SSNs, credit cards, and phone numbers with pattern matching, leaving the rest readable. Solve it in Python or TypeScript, with hidden tests.
Config Validator
Half of "it doesn’t work at the customer" is a bad config — a missing key, a string where an int belongs, an env that isn’t allowed. Validate it up front and fail loudly with a clear list instead of crashing three layers deep. Solve it in Python or TypeScript, with hidden tests.
API Pagination Collector
The customer’s API returns 100 rows at a time behind a cursor. You need all of them. Follow the "next" pointer page by page until it runs out — the loop behind every "sync everything" integration. Solve it in Python or TypeScript, with hidden tests.
Exponential Backoff with Full Jitter
When a customer’s API throws 503s, everyone retrying on the same doubling schedule stampedes it in sync. Full jitter spreads the retries randomly across the window so the herd disperses. Compute the delay schedule. 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.
Reconcile Two Systems That Disagree
The customer is certain the ERP and the CRM agree; they have never checked. Build the reconciliation that produces a report someone can act on — normalised matching, per-field discrepancies, missing on each side, and duplicate keys reported rather than silently dropped. Solve it in Python or TypeScript, with hidden tests.
Harvest a Flaky Paginated API
The vendor API is paginated, occasionally 500s, rate-limits without documenting it, and returns overlapping pages when the data moves under you. Collect everything, retry what deserves retrying, deduplicate, and return a partial result with the failures recorded rather than an exception. Solve it in Python or TypeScript, with hidden tests.
Labs 12
The Deployment Target Chooser
Don't guess where a customer solution should run — answer the constraints and watch the recommendation fall out. The FDE question that reshapes an architecture most is "where can this run?". Toggle whether data can leave, whether it's regulated, whether there's internet, and how fast you must ship updates, and see how the four targets — SaaS, customer VPC, on-prem, air-gapped — score, with the reasoning behind the winner. Made playable, with theory and a quiz.
The Integration Reliability Lab
Don't read about reliable integrations — watch a flaky endpoint drop and duplicate events, then fix it. Send a stream of deliveries through an endpoint that sometimes fails or times out, and toggle the three patterns that make it survive real traffic: retries (fewer losses, but new duplicates), idempotency (kills the duplicates), and a dead-letter queue (turns loss into something recoverable). Watch the exactly-once delivery rate climb — made playable, with theory and a quiz.
The Data Mapping Lab
Don't read about data mapping — do it, and watch rows pass or fail. Every customer hands you a messy export; before it flows in, each column must be mapped to a canonical field and coerced to a type, with the rows that don't fit quarantined, not silently dropped. Pick which column feeds each field and watch validation light up green and red, row by row — a wrong mapping fails everything, a right one quarantines only the bad values. Made playable, with theory and a quiz.
The Rollout Strategy Lab
Don't read about rollout strategies — ship a bug and watch the blast radius. How you roll out a change to a customer's users decides how many people a bad release hits before you catch it: big-bang exposes everyone, a canary exposes 1% first. Pick a strategy, ship a buggy or healthy release, and see the blast radius — and the rollout speed you trade for safety. Made playable, with theory and a quiz.
The Scoping Simulator
Don't read about scoping — cut it under a deadline. You have a two-week budget and a wishlist. Pick the features for a proof of concept and watch the verdict: does it include the one vertical slice that proves value, and does it fit the timebox? Overload it and you ship nothing; skip the core and you prove nothing. Find the smallest slice that makes the customer believe — made playable, with theory and a quiz.
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.
Eval Builder: From Fuzzy Goal to CI Gate
A customer says the system “should be accurate”. Turn that into something a contract can rest on, in four acts: pick metrics (two of the strongest are not accuracy at all), discover the real ceiling by measuring how often the two human experts agree with <em>each other</em>, configure and calibrate an LLM judge, then set a CI gate and watch it catch a change that raises overall accuracy while more than doubling the expensive errors. The most-cited hard skill in FDE job descriptions, made playable.
Security Review Gauntlet
The review that blocks more enterprise AI deployments than any technical problem, in three rounds. Answer a SIG/CAIQ-style questionnaire where a specific <em>no</em> with a compensating control outscores a vague <em>yes</em> — and a false yes ends the review. Survive a live CISO call with a trust meter that punishes bluffing exactly as the real one does. Then threat-model an LLM application, where the plausible mitigation is usually not the one that holds. Ends with a findings report: approved, approved with conditions, or blocked.
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 2
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.