Forward Deployed Engineer (FDE) Interview Prep

What a forward deployed engineer does, why the role has two halves (shipping one customer's outcome and feeding what generalizes back to the product), where it came from, and what interview rubrics score.

Tell an FDE role apart from product, sales and solutions engineering and solutions architecture by asking who you answer to and when, then build a why-FDE answer that survives pushback.

Each FDE interview round recreates a piece of the job. See how reported loops and AI-tool rules differ by company, and turn your target list into a prep plan.

A fictional freight-invoice engagement walked through embed, ship, productize and hand off, the evidence that interviews score each phase, and how to budget a decomposition hour across all four.

Turn a vague customer brief into a plan you can defend by walking users, workflow, data, systems, MVP, metrics and risks in order, naming each step aloud, and closing with a one-week MVP and a baselined metric.

Ask the three to five questions whose answers would change the design (current process, who decides, failure cost, existing data), state assumptions when answers are withheld, and reflect back before designing.

Cut a sprawling request to one user, one data source and one decision on real data, plan it day by day, tell the sponsor what was cut and when it returns, and agree on the demo that counts as acceptance.

Choose one outcome metric tied to the sponsor's business, add guardrails, measure the baseline from the customer's own records, and keep model accuracy and latency as release gates.

Rank the assumptions a plan rests on by consequence, give each an owner and a cheap test, and roll out from shadow to assisted to automated with go or no-go criteria and a rollback a non-engineer can trigger.

Work a vague city-traffic brief: pick the user who can act, check sensor coverage and outages before modelling, scope congestion detection on one corridor, and set metrics with a historical baseline.

Decompose a two-system employee sync: assign an owner per field, match people without a shared key using review tiers, design an idempotent sync with a change log, and settle privacy before data moves.

Turn a client's request for a route optimizer into a cost model, cut the loss by route, driver, customer and failed attempt, find the largest controllable loss, and pilot a fix with a comparison group.

Scope a postal contraband-screening brief around fixed inspector capacity, lopsided error costs and biased labels: rank parcels for human review, reserve a random sample, and monitor for drift within legal limits.

Run a discovery conversation that gets past a customer's feature request to the job they need done, the workaround they use today and its cost, and turn their own words and numbers into success criteria.

Restate what a customer told you so they can correct it, then write scope as in, out and depends-on-customer with a ranked priority list, and reissue it as a new version when facts change.

Map the sponsor, end users, IT and security, and budget owner on one project, give each the evidence they act on, and turn conflicts between them into a written tradeoff the sponsor decides.

Decline a risky or misdirected customer request by naming their underlying need, giving an impact-based reason, offering a smaller first step and recording the decision.

Tell a customer about a slip or failure as soon as you can size it, with headline, measured facts, impact, plan and a dated checkpoint, then rebuild trust by keeping each small promise.

Explain to a non-technical buyer what an AI system does well, where it fails and what a person still checks, using counts from a test set of their own data and a clear fallback path.

Use CTEs, ROW_NUMBER, LAG and running totals to answer a client's question from messy exports, with a stated dedupe rule and row-count checks that catch join fan-out before it reaches a report.

Inspect a messy client file, clean dates, currencies and text into new columns with vectorized pandas, merge with key validation, and end with assertions that fail loudly when the data changes.

Write a field-by-field mapping table between two systems, link records with layered rules and a review queue, measure precision and recall on a labelled sample, and keep a crosswalk so any merge can be undone.

Build a loader that can be rerun safely, checks schema, nulls, uniqueness, ranges and freshness at the boundary, quarantines bad rows with reasons, and reports quality to the customer in plain terms.

Turn a vague brief and an 8,000-row taxi file into a one-week plan: profile, agree cleaning rules with the client, load with a quality report, and ship a demand-by-zone insight by midweek.

Write a REST sync that refreshes tokens, pages to the API's real end signal, backs off on rate limits with jitter and Retry-After, and retries only calls that are safe to repeat.

Build webhook handlers that verify HMAC signatures with a timestamp window, acknowledge fast, deduplicate by event id inside the same transaction as the side effect, and reconcile missed events.

Tell authentication from authorization, walk through the authorization code flow with PKCE, validate an OIDC ID token, explain SP- versus IdP-initiated SAML, and debug common SSO failures.

Build connectors to CSV drops, SFTP and SOAP that only load complete files, survive encoding and header changes, and hide the legacy interface behind a clean internal record.

Structure code for requirements that arrive in stages: rules as small functions or data, a test per stage, earlier behaviour kept unless the customer changes it, and the cost of each change stated in numbers.

Work through a staged credit ledger: grants and spends as replayable events, expiry with exclusive UTC boundaries, soonest-expiry spending, partial refunds, and an injected clock for tests.

Write versioned prompts with role, task, constraints and examples, get schema-shaped output, validate it with a capped repair retry, and measure every prompt change on a labelled set.

Chunk documents by structure with metadata, combine vector and keyword search with rank fusion and reranking, and judge retrieval on its own with labelled queries and recall at k.

Walk a RAG pipeline from ingest to cited answer, enforce document permissions inside retrieval, design an explicit no-answer path, and keep the index fresh as documents and permissions change.

Choose between prompting, retrieval and fine-tuning by the type of failure, prove the choice with a short test on the customer's own data, and say what would make you revisit it.

Turn token counts and real traffic into a monthly cost, budget latency per stage, find the stage worth optimising, and report cost per successful outcome instead of per request.

Design tools a model selects correctly, validate every call in code before it runs, and return results and errors the model can recover from.

Build an agent loop with step limits, budgets, per-tool caps, checkpoints and step logs, and explain how each common failure mode is caught.

Explain MCP hosts, clients and servers, its tools, resources and prompts, its transports, and how to secure a server or decide not to use one.

Sort agent actions into risk tiers, put hard limits in code, design approvals people can actually judge, and use override rates to decide what to automate.

An eval set turns the customer's definition of good into a number you can rerun. Build a small one from real data, report it per slice, and pick the cheapest grader that captures each criterion.

A folder of hand-picked examples measures the folder. Sample real traffic by slice, size the set for the change you need to see, label with the customer's experts against a written guide, and protect a held-out split.

An LLM judge is a measuring instrument that needs calibrating. Grade one criterion against a reference, design around position, verbosity and self-preference bias, and check the judge against expert labels with kappa.

Run the eval suite automatically on every prompt, model or retrieval change. Pin the configuration, compare case-level flips against a measured noise floor, read broken cases by slice, and block on must-pass failures.

LLM systems fail with a 200 status code and a fluent wrong answer. Trace every request, watch segmented quality signals, track input, document and model drift, and turn each production failure into an eval case.

A falling agent metric worked end to end: confirm the drop is real, split mix shift from a real drop inside a segment, find the changed component, rank fixes in the customer's units and add the check that catches it next time.

Run an applied-AI design round in a fixed order: clarify who acts on the output and what a wrong answer costs, draw a staged pipeline, revisit it for evals, failures, security and cost, then argue build versus buy and a gated rollout.

Product-catalog search has to honour hard constraints: hybrid keyword and vector retrieval with attribute filters, rank fusion, a reranker only when the numbers call for it, incremental indexing and a labelled query set.

Claims ingestion from emails and PDFs: classify, parse and extract only the relevant pages, validate with checks you can trust, route uncertain fields to clerks, and measure per-field accuracy with the straight-through rate.

A customer-support agent resolves a few scoped intents, binds identity in the session, lets code rather than the prompt decide refunds, and is judged on resolution, escalation quality, satisfaction and cost.

Regulated document QA starts with residency, permissions, audit and change control; the permission filter sits inside the retrieval query, every answer carries verified citations, and the system refuses without evidence.

A 10x LLM traffic spike is a tokens-per-minute problem: do the arithmetic against provider limits, split interactive and batch lanes, cache, trim context, route simple questions to a small model and agree a degradation order early.

Plan a deployment into a customer VPC, data center or air-gapped network: offline packaging, model access, release cadence and support without logging in.

Answer a security questionnaire, draw an accurate data-flow diagram, and explain HIPAA, SOC 2, GDPR and India's DPDP Act at a practical level.

Roll out in gated stages with agreed success checks, drive adoption with an objection log, hand off to a named owner, and turn field work into product requests.

Debug unfamiliar code by stating a hypothesis, predicting what you would see, and running the cheapest check, while ruling out red herrings such as noisy warnings before you follow them.

Get productive in an unfamiliar codebase by starting from entry points, tests and config, tracing one flow end to end, writing a small map, and proving it with the smallest change plus a test run.

Work through a reported Palantir-style learning round: find the extension point in an unfamiliar library, copy its pattern, narrate what you know and guess, and ship a working increment before discussing the rest.

Build with a coding agent under time pressure: write the plan and first tests yourself, give the agent one verifiable step at a time, review every diff like a junior's, and own every line you submit.

Check AI-written code for the error classes agents produce, write tests from the spec that can actually fail, prompt with constraints and examples, and know when to stop prompting and type the fix.

Scope a take-home to one path that works end to end, prove it with tests and a small measured evaluation, write a README that anticipates the questions, and defend every choice, including AI use, in the live review.

Build six to eight true, high-stakes stories mapped to ownership, ambiguity, customer conflict, failure, fast learning and pushback, so you can adapt them to any behavioral question.

Say what you personally did, state results with baseline, timeframe and method, and tell a pushback story that ends with the customer still trusting you.

Prepare one project for a deep dive: problem, constraints, a three-minute diagram, decisions with rejected alternatives, a real failure, and what you would change.