Skip to content

    Forward Deployed Engineer

    Capstone Demo Script and Interview Presentation

    A timed six-minute demo of the Product Discovery Copilot, a ten-minute interview version, honest limitations, and likely questions with answer outlines.

    By Published 9 min read

    Share

    This lesson is part of FDE Interview: Answer Framework and Design Exercises. Enroll for free, then sign in, to read it in full.

    What you'll learn: a six-minute demo script with timings and real inputs, how to stretch it into a ten-minute interview presentation, the limitations you must say out loud, and the questions a reviewer is likely to ask with outlines for good answers.

    What a good demo proves

    Composite scenario, not a real company. You are showing the Lumen Industrial Supply Product Discovery Copilot to a sales-engineering lead, or to an interviewer who asked you to walk through something you built. Both audiences want the same thing: evidence that you know where the system works, where it does not, and how you can tell.

    The three behaviours to prove are the ones the brief names. Each gets at least one scene:

    • it cites evidence;
    • it refuses when the documents do not support an answer;
    • a public user never sees partner-only content.

    At the customer: "Show me it failing." A strong demo includes a failure you chose in advance, because it shows you measured the system instead of hoping.

    The six-minute script

    Figure 1. Demo scenes and minutes

    flowchart LR accTitle: Six-minute demo in eight scenes accDescr: Frame the problem for 30 seconds. Run the headline request for 75 seconds. Open the cited passage for 45 seconds. Show a refusal for 45 seconds. Show a clarifying question for 30 seconds. Show the access-control difference between roles for 60 seconds. Show two documents that disagree for 30 seconds. Close with the evaluation table and the limits for 45 seconds. A["Frame
    0:30"] --> B["Headline request
    1:15"] B --> C["Open the citation
    0:45"] C --> D["Refusal
    0:45"] D --> E["Clarify
    0:30"] E --> F["Role switch
    1:00"] F --> G["Conflict
    0:30"] G --> H["Eval and limits
    0:45"]

    How to read this: eight scenes left to right, each with its running time for that scene; the total is six minutes.

    Clock Scene What you do What you say
    0:00 Frame Slide or terminal, no demo yet "Sales engineers lose hours matching vague requests to datasheets. This returns cited matches and says when it cannot answer."
    0:30 Headline request Public role; paste the vibration request for 40 pumps Point at requirements, two recommendations, citations and confidence
    1:45 Open the citation Open data/docs/ds-vs-100.md, the chunk named in the citation "This sentence is where the claim comes from, not the model's memory."
    2:30 Refusal "Who is the CEO of Lumen Industrial Supply?" The message "I cannot answer this from the documents."
    3:15 Clarify "I need a sensor for my plant." Three questions come back, no guess
    3:45 Role switch As public: "What is the partner price for the LUM-VS-900?" Then switch to partner and repeat Public is refused; partner gets LUM-VS-900 with a partner-guide citation
    4:45 Conflict "How long does the LUM-VS-200 battery last?" Confidence is medium and the documents are reported as disagreeing (5 years against 3)
    5:15 Eval and limits Show eval/results/latest.md The table, the known miss and the limits below

    The scene times add up: 30 + 75 + 45 + 45 + 30 + 60 + 30 + 45 = 360 seconds, which is six minutes.

    NOTE

    Everything above was checked by running the reference build's pipeline with the mock provider. The UI was component-tested, but the reference build's own report says it was not driven in a browser against the running API. Rehearse in the UI, and keep the curl commands from the contract page ready as a fallback.

    What the evaluation scene shows

    Show the strategy rows from eval/results/latest.md, copied from the harness output.

    Strategy Access leaks Stale citations Conflicts flagged Refusal accuracy Doc recall@3
    baseline 5 2 0.0% 94.4% 94.2%
    A 0 2 0.0% 97.2% 94.2%
    B 0 0 100.0% 97.2% 94.2%

    Read it in one sentence per row. The filter inside the query removes all five leaks, excluding superseded documents removes the two stale citations, and flagging conflicts catches both contradictory-spec questions. Retrieval quality does not differ across strategies: doc recall@3 is 94.2% in every row.

    Then show the miss. Question q36 asks whether Lumen sells a white-label version of its monitoring software with the customer's logo. It should be refused, but the service asks clarifying questions, because most of the words appear somewhere in the public documents and the coverage check scores 0.71 against a 0.6 threshold. Nothing partner-only leaks. Naming the miss yourself earns more trust than waiting for someone to find it.

    Limits you must say out loud

    Limit One-sentence version
    In-sample evaluation The 36 questions were written with the system and the pipeline was tuned while looking at them, so the numbers are regression checks, not an accuracy estimate
    Mock provider The default provider is a rule-based stand-in for a model, so extraction and wording are far more predictable than a real model's
    Adapter not run live AnthropicProvider has never been run against the live API in the reference build; it is a reference adapter to verify with your own key
    UI not driven live The reference UI was component-tested but never driven in a browser against the running API, so rehearse yours end to end
    Keyword search only BM25 misses paraphrases; there are no embeddings
    Teaching-grade auth and state HMAC dev tokens, with idempotency keys and approvals in one process's memory

    If you did not tune against your own golden set, say so truthfully for your build. If you did, say that.

    The ten-minute interview version

    Minutes Part Goal
    1:00 The problem One sentence of customer pain, one of success criteria
    2:00 Architecture The component figure; name where identity and the visibility filter sit
    3:00 Live demo, shortened Headline request, refusal, role switch
    2:30 Evaluation, honestly The table, the in-sample caveat, one miss
    1:00 What you would do next Two items, ranked, with why
    0:30 Buffer Absorb the one thing that goes wrong

    The parts add up to 1:00 + 2:00 + 3:00 + 2:30 + 1:00 + 0:30 = 10:00.

    In the interview: you will usually be interrupted. Let it happen. A presentation that survives three interruptions and picks up where it left off shows more than a perfect monologue, and the buffer is for exactly that.

    Likely questions and answer outlines

    These teach how to reason. Do not memorise them; your answers should come from your build.

    Why not let the model answer straight from the catalog?

    • Code, not the model, must decide which SKUs exist and whether a citation is real.
    • The model proposes drafts; the pipeline keeps a draft only if the SKU is real and the cited chunk names the product.
    • That is what makes "no citation, no claim" enforceable and measurable.

    How do you know it works?

    • Name the golden set: 36 questions, including 9 expected refusals and 4 expected clarifications.
    • Quote the numbers from the output file, then state the in-sample caveat.
    • Say what you would add: questions written by people who did not build it, and a held-out set that you never tune against.

    The provider is a mock. What did you actually learn?

    • The mock proves the contracts, the validation, the limits and the evaluation harness, because those do not depend on the model.
    • It cannot prove answer quality or prompt robustness. A real model needs its own run, and the compose prompt in particular was only ever answered by the mock.
    • Offer the next step: run the same golden set with your own key and compare.

    How do you stop partner data leaking?

    • Identity comes from a verified token, never from the body or the model.
    • The visibility filter runs inside the retrieval query and the tools, so partner-only chunks never reach the context.
    • Evidence: the leak count is 5 for the baseline and 0 for the filtered strategies, and security tests cover the roles.

    What breaks first in production?

    • State lives in one process: idempotency keys and approvals are lost on restart and not shared across instances.
    • Keyword search misses paraphrases, and the refusal check is a word-coverage heuristic that can be wrong in both directions.
    • Authentication is a development token, not an identity provider.

    Why keyword search and not embeddings?

    • Start with the simplest thing you can measure. Keyword search is explainable and the failures are visible in the output.
    • Name when you would change: when misses come from paraphrase, and the evaluation shows it.
    • Say that embeddings need their own evaluation, and that you would compare against the keyword baseline, not replace it on faith.

    How would this fit the customer's systems?

    • Point to your integration note: where the service sits, how identity passes through, what happens on a timeout.
    • Say what you would need from the customer: the catalog source of truth, a refresh path for documents, and an identity provider.
    • Mention the rollout path, starting with a pilot group of sales engineers.

    Walk me through a failure.

    • Use q36. State the expected result, the actual result, the cause (the coverage score of 0.71 against 0.6) and what you would try.
    • Say why you did not simply change the threshold: the same threshold was tuned while looking at the other questions, so moving it for one question risks breaking another.

    Rehearsal checklist

    A demo that works once is not rehearsed. Run it three times with a timer, and check these before each run.

    • The service is started fresh, so no idempotency key from an earlier run replays an old answer.
    • You know which role the UI is set to before you paste each request.
    • The cited file is already open in a second window, scrolled to the sentence.
    • eval/results/latest.md was produced by a run you can name, and you re-ran the harness after your last code change.
    • You have one sentence ready for each limit in the table above.
    • You have decided in advance which scene you will drop if you are running two minutes late. The usual choice is the conflict scene.

    Time each scene, not just the total. If the headline request takes 2 minutes instead of 75 seconds, the problem is the scene, and you can fix it by pointing at three things instead of seven.

    Explain it back. In three sentences, tell a sales director why a refusal is a feature. A good answer says what the refusal prevents (an invented product in front of a customer), what it costs (an unanswered question), and how you know it fires when it should (the six unanswerable golden questions and the one known miss).

    Backup plan

    What goes wrong What you do
    The UI will not load Use the curl commands and show the JSON
    A scene returns something unexpected Say so, show the trace_id, and move on; you have a buffer
    You are asked about a real model Say it was not run live, and show what you would measure
    The network is down Nothing changes: tests and the mock need no network

    What not to claim

    • That the evaluation is an accuracy estimate.
    • That the real provider works, unless you ran it.
    • That this build is production-ready.
    • That finishing it leads to a job. It is evidence of a skill, and you still have to show the skill.

    Last verified: 2026-11-02

    Next

    This is the last capstone page. To rehearse a design defence under pressure, continue to Architecture review board simulation in the AI Solution Architect course.

    To check yourself, take the interview and career practice quiz and then the longer scenario-based practice exam; every wrong answer links to the lesson section to revise. The build modules have their own quiz and exam.

    Enroll to keep reading

    Lesson 6 of 6 · FDE Interview: Answer Framework and Design Exercises

    A timed six-minute demo of the Product Discovery Copilot, a ten-minute interview version, honest limitations, and likely questions with answer outlines.

    In the rest of this lesson

    • What the evaluation scene shows
    • Limits you must say out loud
    • The ten-minute interview version
    • Likely questions and answer outlines
    • Rehearsal checklist
    • Backup plan

    Enrolling is free. It unlocks every lesson in FDE Interview: Answer Framework and Design Exercises, tracks your progress across devices and keeps your quiz scores. The newsletter is optional.

    Ask about this article

    Get answers grounded in this post. AI-generated — based on this article, and may be imperfect.

    Scaled AI Weekly

    Enjoyed this? Get more like it every Monday.

    Real architecture decisions, LLMOps patterns that survive production, and engineering leadership advice — from 12+ years of building at enterprise scale. Free. No spam. Unsubscribe anytime.

    Get new articles by email

    Free. We email a confirmation link first, and you can unsubscribe from any email.

    Join engineers building production AI systems

    Comments