Vibe Engines is free, interactive AI engineering & system design — runs in your browser. Pick a learning path →
The OpenAI FDE
interview
OpenAI’s FDE posting asks you to own a deployment from discovery to production rollout, and the loop a named candidate describes is built to test exactly that. The centrepiece is a substantial take-home you then have to defend on camera. The build is table stakes; the defence is the interview.
What the role is here
OpenAI’s FDE posting says FDEs “lead complex end-to-end deployments of frontier models in production alongside our most strategic customers”: discovery, technical scoping, system design, build and production rollout. Success is measured through production adoption, workflow impact and “eval-driven feedback that changes product and model roadmaps”, with travel up to 50%.first-party71
At the time of writing OpenAI’s own careers board lists 31 postings on its Forward Deployed Engineering team, spanning verticals such as healthcare, financial services and legal, and regions from New York to Tokyo.first-party79
Practical implication for candidates: this is an applied role at a research company. Deep model expertise is not what is being screened. What is screened is whether you can take an API, a messy enterprise problem and a sceptical stakeholder, and produce something that works and gets used.
FDE, forward deployed software engineer, or architect?
OpenAI hires several customer-facing technical roles with similar names. The postings separate them clearly; make sure you are interviewing for the one you want.
| Role | What its posting says it does | Who owns production |
|---|---|---|
| Forward Deployed Engineer | Owns technical delivery across deployments, from first prototype to stable production; builds full-stack systems; scopes and sequences the work.71 | You, through rollout. |
| Forward Deployed Software Engineer | Builds custom software on OpenAI’s APIs, codes beside the customer’s team, and designs abstractions that speed up every FDE engagement. Asks for 7+ years of full-stack work.72 | The build; alongside FDEs. |
| Applied AI Engineer, Enterprise | Designs, builds and deploys AI systems, with hands-on code, evaluation harnesses and production launch.74 | Shared with the customer’s team. |
| Applied AI Architect | “The CTO of your book of business”: technical account plan from pre-sales discovery through adoption, pulling in delivery specialists. “Delivery teams own implementation execution once engaged.”73 | The outcome, not the implementation. |
This matches the dividing question in FDE vs solutions engineer: who is accountable once it runs in production? I found no general Solutions Engineer posting on OpenAI’s board — the only ones are in Ads Solutions — so the architect role is the closest pre-sales-to-adoption equivalent. Expect more design and account strategy in that loop, and more code in the FDE one.
The reported loop
Based on a named first-hand candidate account; OpenAI does not publish stage details, and loops change. Verify with your recruiter.
Recruiter screen
About 30 minutes on why you want customer-facing technical work specifically, and whether you have deployed AI in production and dealt with the mess.named first-hand21
Prepare: a two-minute story of a thing you shipped end to end, with the number that moved and the thing you got wrong.
The take-home — about five hours, building on OpenAI’s APIs
A substantial project against the APIs, delivered with a recorded video walkthrough.named first-hand21 The account stresses production considerations: error handling, graceful degradation, logging.
Prepare: practise time-boxed scoping. Ship a smaller thing that is complete, tested and explainable rather than a larger thing that is half-wired.
Technical screen on your submission
A 60-minute session on your own take-home: why this chunking strategy, why not another retrieval method, what changes at 100x the data. Then rate limiting, retries, prompt robustness, evaluating quality beyond “does it look right”, and diagnosing latency in an inference pipeline.named first-hand21
Virtual onsite: three 60-minute sessions
A hiring-manager conversation on customer-facing experience; a solution-design round on an open-ended customer scenario, where the interviewer stopped the candidate for jumping to architecture before asking what questions the customer needed answered; and a technical deep dive on RAG, fine-tuning trade-offs, guardrails and evaluation.named first-hand21 The same account puts the whole process at about three weeks.
Prepare: the client roleplay simulator covers the customer-scenario shapes.
Most engineering loops treat the take-home as a filter and the onsite as the decision. Here the take-home is the artefact the later sessions interrogate. Budget your effort accordingly: a well-scoped four-hour build with an excellent defence beats an eight-hour build you cannot justify.
A practice take-home, with a rubric
A spec in the style of the reported take-home, not OpenAI’s. Time-box it to five hours, record the walkthrough, then score yourself.
A manufacturer has 400 supplier contracts as PDFs. Procurement wants to know, for each one, the supplier, the renewal date, the notice period and whether it auto-renews, and wants to ask follow-up questions in plain English. Some contracts are scans, some amend earlier ones, and nobody has said how accurate it must be. You have the OpenAI API and ten labelled examples. Deliver something procurement could try on Monday, plus a five-minute video.
The traps
- Ten labels is not an eval set. Do you say so and grow it?
- “Renewal date” in an amendment overrides the original. Do you notice?
- A missing field is a normal case, not an error.
- The API will rate-limit you partway through 400 files.
- Accuracy is undefined. Can you propose a target and who signs it off?
A strong submission
- Scope memo, including what you did not build (no UI, no OCR tuning).
- Typed extraction with nullable fields, plus a human-review route for low confidence.
- Batch run with retries, resumability and a per-file error log.
- A held-out check with a stated metric and the failures listed.
- A runbook paragraph and a “two more days” section.
| Criterion (points) | Full marks look like | Typical loss |
|---|---|---|
| Scoping (4) | Written before coding; cuts named with reasons. | README describes what was built, not what was refused. |
| One complete path (4) | PDF in, validated record out, errors routed. | Happy path only; one bad file kills the batch. |
| Verification (4) | Metric, target, labelled failures, and honesty about n=10. | “It worked on my samples.” |
| API fluency (3) | Structured output, retries with backoff, sensible state handling. | Regex over free text; no rate-limit handling. |
| Operability (2) | How to run it, what breaks first, what to log. | No instructions. |
| Walkthrough (3) | Problem, decisions and trade-offs in five minutes; shows a failure. | Reads the code line by line. |
Twenty points; under fourteen would not advance in a competitive loop. For the timing method and a second spec, see the take-home playbook.
The OpenAI API surface worth knowing in 2026
Checked against OpenAI’s documentation in October 2026. The notable part is what is being retired: a candidate who builds on a sunsetting API signals they have not been reading.
import json from typing import Optional from openai import OpenAI from pydantic import BaseModel client = OpenAI() # 1. Structured output: the schema is the contract. Strict mode makes every field required, # so "optional" is spelled as nullable. class Renewal(BaseModel): supplier: str renewal_date: Optional[str] notice_days: Optional[int] auto_renews: bool r = client.responses.parse(model=MODEL, input=contract_text, text_format=Renewal) renewal = r.output_parsed # check for a refusal before trusting this; route it to a person # 2. A tool round trip: each function_call is answered by a function_call_output, same call_id. r = client.responses.create(model=MODEL, input=items, tools=TOOLS) items += r.output for item in r.output: if item.type == "function_call": result = run_tool(item.name, json.loads(item.arguments)) items.append({"type": "function_call_output", "call_id": item.call_id, "output": json.dumps(result)}) r = client.responses.create(model=MODEL, input=items, tools=TOOLS) # 3. State on the server instead of resending the transcript every turn. r = client.responses.create(model=MODEL, previous_response_id=r.id, input="And the notice period?")
| Piece | What to be able to say |
|---|---|
| Responses API | The current interface. A tool call arrives as a function_call item and you answer with a function_call_output carrying the same call_id; previous_response_id keeps state server-side.75 |
| Structured outputs | A strict JSON Schema the model must follow; text_format with a Pydantic model in the Python SDK. Strict mode needs every field required, so optional means nullable, and refusals are programmatically detectable.76 |
| Agents SDK | Agents, tools, handoffs, guardrails, sessions and tracing; Runner.run_sync(agent, input) returns final_output. Know what it hides, as in the Sierra take-home.78 |
| Evals | OpenAI has announced that the Evals platform becomes read-only on 31 Oct 2026 and shuts down on 30 Nov 2026, and points to Promptfoo, now part of OpenAI, as the migration path. Keep your golden set and graders in your own repo.77 |
| Retired or retiring | The Assistants API had a scheduled shutdown of 26 Aug 2026, with the Responses and Conversations APIs as replacements; Agent Builder is scheduled to shut down on 30 Nov 2026.77 |
A platform deprecating under a customer is a normal FDE incident. The senior answer is that the dataset, the rubric and the pass criteria belong to the customer and live in version control, so the runner can change without the measurement changing. Evals for client work →
How to win the take-home
The evaluation rewards judgement over volume. These six habits are what that looks like concretely.
| Habit | What to actually do |
|---|---|
| Write the scope first | A README section: what you built, what you deliberately did not, and why. Written before you code, kept honest afterwards. |
| Make one thing complete | A narrow path that works end to end — input, processing, output, errors — beats three half-features. |
| Handle the ugly cases visibly | Rate limits, timeouts, malformed responses, partial failures. This is the enterprise reality the role exists for. |
| Show how you know it works | Tests, or an eval, or a reproducible check. “It works” without evidence is the single weakest signal you can send in an FDE loop. |
| Leave a runbook | How to run it, what breaks first, what you would monitor. Two paragraphs. Almost nobody does this, and it reads as senior. |
| Name the trade-offs | Three decisions with the alternative you rejected and why. These become your defence script. |
Take-home plus defence, as a drill
A timed spec, a rubric, and a defence checklist — the same structure as the reported loop.
The customer-scenario sessions
In the reported loop these sit in the onsite, and engineers under-prepare for them by a wide margin.
What they look like
- “The customer wants a feature you know will not solve their problem. What do you do?”
- “Your deployment has stalled for three weeks waiting on data access. Walk me through the next fortnight.”
- “The demo fails live in front of their CTO. Talk me through the next sixty seconds.”
- “How would you measure whether this deployment succeeded?”
What scores well
- Ask what the customer is actually trying to achieve before designing anything.
- Name the constraint honestly, then offer a path — not a promise.
- Have a measurement answer ready for everything. Evals are the FDE’s native language.
- Show you would keep momentum while blocked, rather than waiting.
The measurement point matters at OpenAI in particular: the FDE posting itself names eval-driven feedback as a success measure.71 Turning a fuzzy customer goal into a golden set, a calibrated judge and a gate is the skill that separates a strong answer from a plausible one. Evals for Client Work →
The picture: one artefact, interrogated twice
Worked example: scoring two submissions against the rubric
Two illustrative submissions to the supplier-contract brief above. A built a chat UI, tuned OCR and answers questions over all 400 contracts. B followed the “strong submission” list. Here is how each scores on the page’s 20-point rubric.
| Criterion (points) | A: the big build | B: the scoped build |
|---|---|---|
| Scoping (4) | 1: README lists features, no cuts | 4: memo written first; UI and OCR tuning cut, with reasons |
| One complete path (4) | 2: happy path; one bad scan stops the batch | 4: PDF in, validated record out, failures routed to review |
| Verification (4) | 0: “it worked on my samples” | 3: 9 of 10 right, the miss listed, n=10 flagged; set not grown |
| API fluency (3) | 1: regex over free text | 3: structured output, nullable fields, retries with backoff |
| Operability (2) | 0: no instructions | 2: how to run it, what breaks first, what to log |
| Walkthrough (3) | 1: reads the code line by line | 2: shows a failure; runs over five minutes |
| Total (bar: 14) | 5 | 18 |
A did more work and scored 5. B did less and scored 18. Look at the verification row. Nine right out of ten sounds like 90%, but with only ten labels the honest range is wide: a 95% Wilson interval for 9 of 10 runs from about 60% to 98%. B earns its points by saying that out loud and proposing to grow the set, with procurement signing off the target. B still loses a point for not growing it, and that point is the cheapest fix left.
Cost and trade-offs: spending the five hours
Here Time is a rough share of the five hours (illustrative), Space is the rubric points the work can earn, and Why is the reason to do it or cut it.
| Case | Time | Space | Why |
|---|---|---|---|
| Scope memo | ~15 min | Scoping (4) | The cheapest points on the rubric, and the start of your defence. |
| Typed extraction, nullable fields | ~1 h | One path, API fluency | The schema is the contract. A missing field becomes null, not an error. |
| Batch with retries and resume | ~1 h | One path, API fluency | You will be rate-limited partway through 400 files. That is part of the test. |
| Grow the labels, held-out check | ~1 h | Verification (4) | Turns “it worked” into a number with a range. |
| Runbook and video | ~45 min | Operability (2), walkthrough (3) | Easy points that almost nobody collects. |
| Chat UI or OCR tuning | Open-ended | None directly | Name it as a cut. Building it is what sank A. |
The kept rows add up to about 4 hours, which leaves an hour for whatever breaks. That buffer is what the page means when it says a well-scoped four-hour build beats an eight-hour one.
Check yourself
Your batch hits a rate limit at file 230 of 400. What should the code already do?
Retry that call with exponential backoff, and record per-file state so a restart resumes at file 230 rather than at file 1. Files that still fail go to an error log, not a crash. The rubric checks this under “one complete path”, and the brief predicts it, so not handling it reads as not having read the brief.
A contract has no notice period anywhere. What does your extractor return?
null for notice_days. Strict structured output makes every field required, so “optional” is a nullable type. A missing field is a normal case, not an error. Do not guess a default, which would look like a real answer to procurement. If the field matters for this contract type, route it to human review.
An amendment changes the renewal date. Which date does your record hold?
The amendment’s. Process each supplier’s contract and its amendments together, apply them in date order, and record which document each field came from. Reading every PDF on its own gives two conflicting records, and it is exactly the trap the brief plants.
In the tech screen you are asked how accurate the extractor is. You have 9 of 10 correct on your labels. What do you answer?
“On ten labels, somewhere between about 60% and 98%, so I don’t know yet.” That is the 95% Wilson interval for 9 of 10. Then say how you would narrow it: label more contracts, including scans and amendments, and agree a target with whoever in procurement owns the result. Saying “90%” reads as not knowing what ten labels can tell you.
Quick answers
What is the OpenAI forward deployed engineer interview process?
A named first-hand account describes a recruiter screen, a take-home of about five hours built on OpenAI’s APIs with a recorded video walkthrough, a 60-minute technical screen on your submission, and a virtual onsite of three 60-minute sessions: hiring manager, solution design and technical deep dive. The process took about three weeks. OpenAI does not publish stage details, so verify with your recruiter.
How long is the OpenAI FDE take-home?
Reported at about five hours of work building something with OpenAI’s APIs, delivered with a video walkthrough. The same account says the walkthrough should focus on decisions and trade-offs rather than the code line by line, and that production concerns such as error handling, graceful degradation and logging matter. A well-scoped smaller build with a strong defence beats a larger one you cannot justify.
What is the difference between an OpenAI FDE and an Applied AI Architect?
OpenAI’s postings describe the FDE as owning technical delivery from first prototype through stable production, writing production code, while the Applied AI Architect is the technical owner of an account portfolio, shaping strategy from pre-sales through adoption and relying on delivery teams for implementation. A separate Forward Deployed Software Engineer role focuses on building custom software on the APIs.
Which OpenAI APIs should I know for the FDE interview?
The Responses API with function calling and structured outputs, the Agents SDK, and a way to evaluate your own systems. Know what is being retired: OpenAI’s deprecations page schedules the Assistants API for shutdown on 26 August 2026 and the Evals platform and Agent Builder for 30 November 2026. Keep evaluation datasets and graders in your own repository so they survive platform changes.
How should I prepare for the OpenAI FDE onsite?
Rehearse customer scenarios: a demo failing live, a stalled deployment, a customer demanding the wrong feature, and a request you should decline. Start each with questions about the customer’s goal rather than architecture, and have a measurement answer ready: a golden set, a calibrated judge and a gate. Be ready to discuss RAG, fine-tuning trade-offs, guardrails and evaluation in depth.
Sources
Every number on this page traces to one of these. Where a figure is self-reported or crowd-sourced rather than first-party, it is labelled inline.
Cited on this page
- Gaijineer — OpenAI Forward Deployed Engineer interview process — named first-hand candidate account. gaijineer.co/openai-forward-deployed-engineer-interview-process
- OpenAI — Forward Deployed Engineer (FDE), SF (job posting, first-party) — discovery to production rollout; eval-driven feedback; travel up to 50%. jobs.ashbyhq.com/openai/967f94aa-1706-4dba-ac89-bfbc2c38b688
- OpenAI — Forward Deployed Software Engineer, SF (job posting, first-party) — jobs.ashbyhq.com/openai/00207abc-49b7-465c-a219-f7c1140f8047
- OpenAI — Applied AI Architect, Enterprise (job posting, first-party) — “CTO of your book of business”; delivery teams own implementation. jobs.ashbyhq.com/openai/1953efa7-5c1f-4878-b4cb-926cd35aafdb
- OpenAI — Applied AI Engineer, Enterprise (job posting, first-party) — jobs.ashbyhq.com/openai/01091aed-427d-4e10-8cdb-fb500cf55bb9
- OpenAI API docs — Function calling — developers.openai.com/api/docs/guides/function-calling
- OpenAI API docs — Structured model outputs — developers.openai.com/api/docs/guides/structured-outputs
- OpenAI API docs — Deprecations — Assistants API, Evals platform and Agent Builder timelines. developers.openai.com/api/docs/deprecations
- OpenAI — Agents SDK for Python (README) — github.com/openai/openai-agents-python
- OpenAI — careers board (counted 22 Oct 2026) — 31 postings on the Forward Deployed Engineering team. jobs.ashbyhq.com/openai
Explore the topic
See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.
More Handbooks
- The Agentic AI Interview HandbookTwenty topics every senior AI engineer should be able to reason about live — from eval pipelines to reliability patterns for generative systems.Read →
- The Senior AI Engineer Interview Handbook60 questions across architecture, production incidents, agentic systems, RAG, evals, cost, safety, and leadership — what staff-level AI interviewers actually probe for.Read →
- 50 Angular Interview QuestionsA visual handbook covering components, change detection, RxJS, signals, routing, forms, performance, and testing — what interviewers actually probe for in senior Angular roles.Read →
- 50 Python Interview QuestionsFundamentals 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.Read →
- 51 LLM Evals Interview QuestionsGolden sets, LLM-as-judge, regression testing, offline vs online evals, RAG evals, agent evals, red-teaming, and observability — demystified for interviews and production.Read →
- The Agent Evaluations HandbookA 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.Read →