Vibe Engines
YouTube

Vibe Engines is free, interactive AI engineering & system design — runs in your browser. Pick a learning path

FDE interview prep  /  OpenAI
Interview Track~15 min readUpdated Oct 2026
Company Loop 02

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.

01

What the role is here

First-party framing

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.

02

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.

RoleWhat its posting says it doesWho owns production
Forward Deployed EngineerOwns technical delivery across deployments, from first prototype to stable production; builds full-stack systems; scopes and sequences the work.71You, through rollout.
Forward Deployed Software EngineerBuilds 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.72The build; alongside FDEs.
Applied AI Engineer, EnterpriseDesigns, builds and deploys AI systems, with hands-on code, evaluation harnesses and production launch.74Shared 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.”73The 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.

03

The reported loop

Based on a named first-hand candidate account; OpenAI does not publish stage details, and loops change. Verify with your recruiter.

Stage 1

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.

Stage 2

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.

Stage 3

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

Stage 4

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.

→ The distinguishing feature of this loop

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.

04

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.

Brief: “Supplier contract assistant”

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 likeTypical 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.

05

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?")
PieceWhat to be able to say
Responses APIThe 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 outputsA 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 SDKAgents, 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
EvalsOpenAI 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 retiringThe 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
→ Why the eval point matters

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 →

06

How to win the take-home

The evaluation rewards judgement over volume. These six habits are what that looks like concretely.

HabitWhat to actually do
Write the scope firstA README section: what you built, what you deliberately did not, and why. Written before you code, kept honest afterwards.
Make one thing completeA narrow path that works end to end — input, processing, output, errors — beats three half-features.
Handle the ugly cases visiblyRate limits, timeouts, malformed responses, partial failures. This is the enterprise reality the role exists for.
Show how you know it worksTests, 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 runbookHow to run it, what breaks first, what you would monitor. Two paragraphs. Almost nobody does this, and it reads as senior.
Name the trade-offsThree decisions with the alternative you rejected and why. These become your defence script.
Rehearse the whole shape

Take-home plus defence, as a drill

A timed spec, a rubric, and a defence checklist — the same structure as the reported loop.

07

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

The picture: one artefact, interrogated twice

Recruiter~30 minwhy this work Take-home~5 h + videoon the APIs Tech screen60 minon your build Onsite3 × 60 mindesign, deep dive the artefact:repo + video interrogated twice about 9.5 h of your time; the take-home is 300 of 570 minutes
Most loops use a take-home as a filter and then move on. Here it is the subject of the next two stages. The technical screen asks why you chose this chunking strategy and what changes at 100× the data. The onsite deep dive goes back to RAG, guardrails and evaluation. So the five hours are not only build time. They also decide what you will be questioned on for the next four hours.
By the numbers

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 buildB: the scoped build
Scoping (4)1: README lists features, no cuts4: memo written first; UI and OCR tuning cut, with reasons
One complete path (4)2: happy path; one bad scan stops the batch4: 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 text3: structured output, nullable fields, retries with backoff
Operability (2)0: no instructions2: how to run it, what breaks first, what to log
Walkthrough (3)1: reads the code line by line2: shows a failure; runs over five minutes
Total (bar: 14)518

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.

Trade-offs

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.

CaseTimeSpaceWhy
Scope memo~15 minScoping (4)The cheapest points on the rubric, and the start of your defence.
Typed extraction, nullable fields~1 hOne path, API fluencyThe schema is the contract. A missing field becomes null, not an error.
Batch with retries and resume~1 hOne path, API fluencyYou will be rate-limited partway through 400 files. That is part of the test.
Grow the labels, held-out check~1 hVerification (4)Turns “it worked” into a number with a range.
Runbook and video~45 minOperability (2), walkthrough (3)Easy points that almost nobody collects.
Chat UI or OCR tuningOpen-endedNone directlyName 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.

Self-check

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.

Frequently asked

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.

Receipts

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

  1. Gaijineer — OpenAI Forward Deployed Engineer interview process — named first-hand candidate account. gaijineer.co/openai-forward-deployed-engineer-interview-process
  2. 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
  3. OpenAI — Forward Deployed Software Engineer, SF (job posting, first-party) — jobs.ashbyhq.com/openai/00207abc-49b7-465c-a219-f7c1140f8047
  4. 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
  5. OpenAI — Applied AI Engineer, Enterprise (job posting, first-party) — jobs.ashbyhq.com/openai/01091aed-427d-4e10-8cdb-fb500cf55bb9
  6. OpenAI API docs — Function calling — developers.openai.com/api/docs/guides/function-calling
  7. OpenAI API docs — Structured model outputs — developers.openai.com/api/docs/guides/structured-outputs
  8. OpenAI API docs — Deprecations — Assistants API, Evals platform and Agent Builder timelines. developers.openai.com/api/docs/deprecations
  9. OpenAI — Agents SDK for Python (README) — github.com/openai/openai-agents-python
  10. OpenAI — careers board (counted 22 Oct 2026) — 31 postings on the Forward Deployed Engineering team. jobs.ashbyhq.com/openai
OpenAI FDE Interview · the interview track of the FDE course · Vibe Engines · 2026
Finished this one? 0 / 209 Handbooks done
NextThe Anthropic Applied AI / FDE Interview Next on the “Getting hired as an FDE” ladder · rung 7 of 9

Explore the topic

See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.