The Forward Deployed Engineer: Role & Mindset
A grounded definition of the job: how an FDE differs from a software engineer, a solutions engineer and a consultant, what a typical week contains, and the mindset shifts such as speed over polish. It prepares you for the opening question of almost any loop, "what does this role actually do, and why do you want it?", and shows which skills to build first.
Forward-Deployed Engineer Roadmap
The role laid out as eighteen stations in three tracks: the craft, the field, and the outcome. Treat it as the table of contents for everything that follows. Check off the stations you already know, and use the gaps to decide how much time each later section of this path deserves.
Customer Discovery & Scoping for FDEs
Why discovery is the highest-leverage hour of an engagement, why watching beats asking, and which questions surface the real problem behind the stated request. It prepares you for the scoping conversation itself and for interview prompts that begin with a vague customer ask and wait to see whether you ask before you build.
The Scoping Simulator
You get a two-week budget and a wishlist, and you have to cut the project down to the slice that proves value. Playing it makes the trade-offs concrete: what to defer, what to refuse, and how to defend the cut. It rehearses the moment a customer asks for everything at once.
Rapid Prototyping for FDEs
How to build something convincing in days: throwaway-first thinking, the smallest demoable vertical slice, and a deliberately boring, fast stack. It prepares you for take-home projects and live build rounds, where the evaluator cares less about elegance than about whether you shipped a working slice and explained what you left out.
Applied AI Engineer, Explained
Several AI labs use the title Applied AI Engineer for work that overlaps heavily with this one. The handbook explains how it differs from AI engineer, ML engineer and FDE, and gives two questions that reveal which variant an offer really is. Read it before you compare postings or accept a job description at face value.
Scoping Question Log
A drill with a budget of six clarifying questions to spend on an underspecified customer ask. Each question is scored, you see the real answer it would have drawn out, and you can export a scoping document. It trains the habit that decomposition-style interview rounds grade: questions first, proposals second.
Customer Integration Patterns for FDEs
The integration playbook: REST and GraphQL, webhooks, file drops and SFTP, database and change-data-capture connectors, queues, and how authentication works into customer systems. After it you can answer "how would you get data out of their legacy system?" by naming options, costs and failure modes instead of picking one reflexively.
Verify a Webhook Signature
You write the check that recomputes a signature over the payload, compares it in constant time, and enforces a replay window. Hidden tests probe tampered bodies and stale timestamps. Expect this as a practical coding question, plus follow-ups about why a plain equality comparison leaks information.
Idempotency Key Handler
Networks retry, so a webhook can fire twice and a payment request can be re-sent after a timeout. You build a handler that processes each key once and returns the stored result on repeats. It prepares you to explain exactly-once effects, and to spot the race when two identical requests arrive together.
Exponential Backoff with Full Jitter
When a customer's API starts returning 503s, clients retrying on the same doubling schedule hit it in lockstep. You implement exponential backoff with full jitter and cap the delay. Interviewers like asking why jitter matters, which errors are retryable, and when a retry should stop and escalate.
CSV → Schema Mapper
Every customer exports messy data, so you coerce rows onto a schema: strings to integers, text to booleans, missing values handled deliberately. The tests reward careful error handling over clever parsing. It prepares you for take-home tasks that start with a bad spreadsheet and ask what you do with the rows that will not fit.
Data Reconciliation Diff
The customer says the migration worked, so you compare source records against what landed in the target, keyed by id, and report what is missing, extra or changed. It builds the instinct to prove a migration instead of trusting it, and it is a common shape for data-focused take-home exercises.
The Integration Reliability Lab
You watch a flaky endpoint drop and duplicate events, then fix it in stages. Retries alone create duplicates, idempotency removes them, and a dead-letter queue recovers what would otherwise be lost. Seeing the failure first makes the earlier challenges feel like parts of one design you can sketch on a whiteboard.
The Data Mapping Lab
A hands-on version of the messy-export problem where you map rows and watch which pass and which fail. The key lesson is to quarantine bad rows with a reason instead of silently dropping them. It prepares you for questions about data quality, auditability and how you would report problems back to the customer.
Deploying in Customer Environments
The four places your software can run: your own SaaS, the customer's cloud or VPC, on-premises hardware, and an air-gapped network. Each changes how you ship, update and debug. It prepares you for deployment-architecture questions where the right answer depends on the customer's constraints rather than on your favorite stack.
The Deployment Target Chooser
You answer a set of constraints about data residency, connectivity, staffing and risk, and the recommended target falls out of the model. Playing several scenarios shows how one changed constraint flips the answer. It gives you a repeatable way to justify a deployment choice aloud.
IaC for Customer Environments
Terraform and Helm change shape when the account, cluster and change board all belong to the customer: who holds state, what a no-egress VPC breaks, and how private endpoints get wired. It prepares you for questions about delivering infrastructure you do not control and for reviewing a plan the customer's team must approve.
Air-Gapped & Regulated Deployment
FedRAMP and DoD impact levels explained for engineers, how model weights and updates cross an approved boundary into a network with no egress, and how to plan updates that survive a change-control board. Read it to answer how you would deploy and maintain software the internet can never reach.
Security & Compliance for FDEs
Enough security knowledge to earn a customer's yes: what SOC 2, HIPAA, GDPR and PCI actually ask for, how to handle data and secrets, and what a security review checks. It prepares you for the questionnaire stage of a deal and for interview questions about handling sensitive data on a customer's behalf.
Enterprise Identity for FDEs
Identity is where enterprise deployments stall. The handbook covers SAML versus OIDC and when you get no choice, SCIM provisioning, least privilege, and the deprovisioning question that can decide a deal. After it you can explain how a new employee gets access and how a departing one loses it.
Security Review Gauntlet
You sit the review that blocks more enterprise AI deployments than any technical problem: the security questionnaire, the call with the CISO, and a threat model for an LLM feature. It rehearses answering precisely under scrutiny, including saying "we do not do that yet" without losing trust.
PII Redactor
Before customer data reaches a log line or a third-party model, the personal parts have to go. You write a redactor that masks emails, phone numbers and similar patterns while keeping the rest of the text useful. Expect follow-ups on false negatives, structured fields and where in the pipeline redaction belongs.
The Demo & Storytelling Playbook
A demo is a performance, not a code review. The handbook covers preparing with the customer's own data, rehearsing, keeping a fallback recording, and shaping the story around their outcome. It prepares you for presentation rounds and for the real moment when the room has executives in it.
Solutions Engineering & Stakeholder Management
The non-code half of the job: mapping the room into champion, blocker, decision-maker and user, managing scope creep with a visible later-list, and saying no kindly. It prepares you for behavioral questions about conflict, an unreasonable request or a stakeholder who goes quiet.
Stakeholder Politics Lab
Deployments fail on org charts, not architecture. You classify six people at a realistic customer from one sentence each, then handle the gatekeeper and a resignation mid-project. It trains reading a room quickly and choosing whom to spend your limited time on.
From POC to Production: Hardening
The gap between "it demoed" and "people depend on it": sad-path handling, idempotency, observability, security and an honest conversation about what is not ready. It prepares you for questions about taking a prototype live, and for deciding which hardening work is worth doing first.
The Rollout Strategy Lab
You ship a bug and watch the blast radius under different rollout strategies. Big-bang releases expose everyone; canaries and staged rollouts bound the damage and buy time to notice. It prepares you to justify a rollout plan and to explain how you would limit harm to a customer's users.
Config Validator
Half of "it does not work at the customer" is a bad configuration: a missing key, a string where an integer belongs, an environment value that is not allowed. You write a validator that fails loudly with a clear message. It is good practice for the small utilities FDEs write constantly.
API Pagination Collector
The customer's API returns a hundred rows at a time behind a cursor, and you need all of them. You follow the cursor, stop correctly and combine pages without losing or repeating rows. It is a frequent warm-up for integration-flavored coding rounds, and a base for the flaky harvester later.
AI App Patterns for FDEs
The AI toolkit a modern FDE deploys: retrieval over the customer's documents, agents that drive their workflows, and evaluation as the acceptance test. It prepares you for questions about when to use each pattern, what breaks at the customer's scale, and how you would show the result is good enough.
MCP for FDEs
Wrapping a customer's legacy system as a set of tools an agent can use safely is now a named deliverable in some FDE job descriptions. The handbook explains what that means in practice, including tool design, permissions and failure behavior. Expect it to help with questions about exposing old systems to agents.
Handoff & Enablement for FDEs
How to hand off a deployment without becoming a permanent, unpaid support team: treating the exit as the goal, and handing over a runbook, documentation, architecture notes and training. It prepares you for interview questions about ownership, and for the final weeks of a real engagement.
Learning a Customer’s Domain Fast
The meta-skill of getting dangerous in an unfamiliar field within a week: learn from the customer's real data, find the vocabulary and the workflow, and locate the unwritten rules. It prepares you for questions about a domain you have never worked in, which FDE interviews ask on purpose.
Domain Ramp Sprint
You pick insurance claims, hospital revenue cycle or legal discovery and ramp on it under time pressure: the codes, the workflow and the rule nobody wrote down. It drills the habit of asking which part of the process is actually costly, which is what the learning-oriented interview rounds look for.
Evals for Client Work
How to turn "it should be accurate" into a measurable acceptance test, including negotiating what correct means when the customer's experts disagree. It prepares you for evaluation questions in client settings, and for the conversation where someone asks how you know the system works.
Eval Builder: From Fuzzy Goal to CI Gate
You build an enterprise evaluation in four acts: choose metrics for a fuzzy business goal, measure agreement between experts to find the real accuracy ceiling, calibrate a judge, and set the gate that catches what an average hides. It makes the previous handbook something you have actually done.
Design a Customer Data Integration Pipeline
An interactive design built step by step: ingesting a customer's data through connectors, validation, mapping and recovery. It ties the earlier integration challenges into one architecture. Use it to practice the system-design round where the prompt is "pull this customer's messy data in reliably", and to draw the pipeline from memory.
Design Webhook Ingestion at Scale
The design for receiving webhooks that survive a two-hour outage without losing events: fast acknowledgment, durable queuing, deduplication and replay. It prepares you for questions about ordering, retries and backpressure, and connects directly to the signature and idempotency challenges you solved earlier.
Design Multi-Tenant Customer Isolation
Building isolation that a bank's security team will accept: tenant context carried through every call, separated data paths, and noisy-neighbor protection. It prepares you for questions about serving many customers from one system, and for explaining where a boundary could leak.
Deploy an LLM in a Customer’s Environment
Designing an LLM deployment with no internet and no egress: model delivery, serving, updates, observability and capacity inside the customer's own environment. It prepares you for the hardest deployment questions an AI-focused FDE meets, and it builds on the air-gapped handbook you read earlier.
Design Secure Document Ingestion + RAG
Building retrieval over confidential documents, where security matters more than relevance: permissions enforced at retrieval time and not only at indexing time, plus redaction and auditing. It prepares you for questions about leaking one user's documents into another user's answer.
Design an Audit Logging & Compliance Trail
The design of an audit trail a regulator will accept: structured capture of who did what and when, tamper evidence, retention and queryability. It prepares you for compliance-driven design questions and shows how the audit story connects to identity and data handling covered earlier.
Design Enterprise SSO & Provisioning
The identity layer that enterprise deals stall on, including the SCIM PATCH operations that teams often skip. You design login, provisioning and deprovisioning flows. It prepares you for questions on SSO architecture and for reasoning about what happens when an account is removed mid-session.
Design an Enterprise Eval Pipeline
The pipeline an enterprise AI deployment is judged on, turning "it should be accurate" into a gate that blocks a merge. You design datasets, scorers, versioning and reporting. It prepares you for questions about running evaluations continuously instead of once, and it extends the Eval Builder lab.
Design an Agent Harness (AI-Supervised Delivery)
The harness engineers use to supervise agents doing delivery work: task isolation, permissions, logging, review points and rollback. It prepares you for design questions about letting agents act inside a customer's systems while keeping a human accountable for the result.
Incidents, On-Call & SLAs for FDEs
Running production in an environment you do not own: negotiating a service level you can actually meet, handling being the only person who understands the system, and engineering your way out of the rotation. It prepares you for questions about on-call, incident communication and sustainable support.
The 95% Number, Examined
The most-cited statistic in enterprise AI, that roughly 95% of pilots show no measurable profit-and-loss impact, read carefully. The breakdown shows why the word measurable carries the whole sentence. It prepares you to discuss why pilots stall and to cite the number without overstating it.
Proving Value & ROI
Most enterprise AI pilots die because nobody proved they worked. The handbook covers instrumenting adoption, choosing the one number that matters, and showing it before the renewal conversation. It prepares you for questions on success metrics and for building the evidence a champion can take to their boss.
The Commercial Layer for FDEs
The part of the job nobody teaches: reading a statement of work before it binds you, how pricing models work, and the services trap where custom work swallows margin. It prepares you for discussions about scope, change requests and why an engineer should understand the contract.
The FDE Canon
An annotated reading shelf of ten sources that explain the role, from first-hand accounts to job descriptions worth reading as documents, with a note on what each one leaves out. Use it to choose your next reading and to speak knowledgeably about how the role is described in public.
FDE Interview Prep: The 9 Rounds
The nine round archetypes used across several well-known employers, and what each one scores. Use it as the checklist for the remaining steps: decide which rounds apply to the company you are targeting, then spend your practice time where the gaps are largest.
The Decomposition Round, Simulated
The decomposition round, playable: pick a real case such as a taxi fleet, emergency response or fraud unification, and you are scored on your questions before you may propose anything. It is the most direct rehearsal for the signature FDE interview, and it rewards structure over speed.
The Learning Round, Simulated
You get the documentation for a library that does not exist, a package installer with dependency resolution, and absorb it under gates. The round tests learning speed and careful reading rather than prior knowledge. Practice it until you read the docs first and test your assumptions early.
Re-Engineer a Legacy ETL
You inherit an aggregation nobody can explain and the totals are wrong, with three separate planted defects. The lesson is to read before rewriting: reproduce the failure, find each bug, and fix it with a test. It prepares you for code-comprehension rounds built on inherited code.
LRU Cache, Constraint by Constraint
An incremental-coding round packaged as a challenge: a cache that becomes bounded, then least-recently-used, then instrumented, with each stage changing the shape of the last. It prepares you to write code that survives new requirements and to talk calmly while refactoring.
Deep Clone, Constraint by Constraint
Copy an object, then nested structures, then a cycle that breaks the obvious design. The twist is that a visited set alone is not the whole fix. Working through it prepares you for incremental rounds where stage three invalidates your first approach and you must explain why.
Rate Limiter, Constraint by Constraint
A fixed-window counter becomes a sliding window, then per-key limits, and stage two outright invalidates stage one. Practice saying "that counter has to go" and refactoring without panic. It pairs naturally with the rate limiter system design if you want the design view as well.
Reconcile Two Systems That Disagree
The customer is certain the ERP and the CRM agree, and nobody has checked. You build a reconciliation that produces a report someone can act on, covering missing records, conflicting fields and duplicates. It is realistic week-two work and prepares you for open-ended data tasks.
Harvest a Flaky Paginated API
The vendor API is paginated, occasionally returns 500 errors, rate-limits without documenting it, and repeats rows when data moves under you. You combine pagination, retries and deduplication into one collector. It pulls several earlier lessons together in a single realistic exercise.
Client Roleplay Simulator
Four customer situations that decide deployments, including a demo that fails live in front of executives, played with a live trust meter. You see how your word choices raise or lower trust. It prepares you for the behavioral and role-play rounds, where composure and honesty are graded.
Forward Deployed Engineer Salary, Explained
How to read an offer properly: the six employer tiers, the equity share, and the questions to ask before comparing numbers. It explains why public salary figures vary so widely. Read it near the end of your preparation, once you know which kind of employer you are actually talking to.
FDE Comp Explorer
An interactive explorer that decomposes an offer by tier, level and market into base, equity and bonus, with reported bands and confidence labels. Use it to organize the questions you will ask a recruiter. Treat every figure as a reported range, not a promise.