Skip to content

    Forward Deployed Engineer

    Capstone Brief: Requirements, Dataset and Phases

    The Product Discovery Copilot brief for Lumen Industrial Supply: ten requirements, the real dataset counts, and the eight build phases P1 to P8 with hours.

    By Published 8 min read

    • fde
    • capstone
    • requirements
    • dataset
    • product-discovery-copilot
    Share

    This lesson is part of Forward Deployed Engineer: Evaluate and Capstone. Enroll for free, then sign in, to read it in full.

    What you'll learn: exactly what the capstone asks you to build, what is in the dataset (with the real counts), which traps the data contains on purpose, and how the eight phases P1 to P8 map onto the course modules and hours.

    Scenario

    Composite scenario, not a real company. Lumen Industrial Supply is a fictional distributor of industrial equipment. Its sales engineers receive vague requests such as "We need something to monitor vibration on 40 pumps in a humid plant, budget around 30k, must work with our existing OPC UA setup". Today they search a catalog by hand and scan datasheets for the supporting sentence.

    The customer wants a first version that turns such a request into structured requirements, finds matching products with the document passage that supports them, and says plainly when the documents cannot answer. All names, prices and numbers in the data are invented and illustrative.

    What you build, in one picture

    Figure 1. The eight phases, their host modules, hours and what exists when each is done

    flowchart LR accTitle: Eight capstone phases with modules, hours and results accDescr: P1 in M1, 0.4 hours, gives models and data. P2 in M1, 0.7 hours, gives the API and deterministic search. P3 in M2, 0.5 hours, gives structured requirement extraction. P4 in M3, 0.7 hours, gives retrieval with citations. P5 in M4, 0.7 hours, gives a bounded tool workflow. P6 in M5, 0.4 hours, gives validation, access control and errors. P7 in M6, 0.5 hours, gives tests and evaluation. P8 in M6, 0.6 hours, gives the UI, documentation and demo. P1["P1 - M1 - 0.4 h
    models and data"] --> P2["P2 - M1 - 0.7 h
    API and search"] P2 --> P3["P3 - M2 - 0.5 h
    extraction"] P3 --> P4["P4 - M3 - 0.7 h
    evidence"] P4 --> P5["P5 - M4 - 0.7 h
    workflow"] P5 --> P6["P6 - M5 - 0.4 h
    access and errors"] P6 --> P7["P7 - M6 - 0.5 h
    tests and eval"] P7 --> P8["P8 - M6 - 0.6 h
    UI and demo"]

    How to read this: each box is one phase with its host module, planned hours and the result you can run when it is done; the arrows are hard dependencies.

    • You build a Python service with a small API: one discovery endpoint, one product search endpoint, one health check and a development-only token endpoint.
    • A reference build exists in the course's capstone folder. It is complete and its tests pass, so you can compare your work phase by phase.
    • Hours are the plan for a focused learner. Use the overrun factor from your 30/60/90 plan.

    Requirements

    Ten requirements define done. Each has a check you can run, which is what the rubric later scores.

    # Requirement How it is checked
    R1 Turn free text into structured requirements (category, quantity, budget, protocols, environment), with one bounded repair retry on malformed model output A test with a deliberately malformed reply
    R2 Recommend only products that exist in the catalog the caller may see Code-side validation of every SKU
    R3 Every recommendation cites at least one chunk that exists, as doc_id#chunk, and that really speaks about the product Citation check in code and in the evaluation
    R4 When the documents cannot support an answer, return the refusal "I cannot answer this from the documents." Six unanswerable golden questions
    R5 When the request is too vague, ask clarifying questions instead of guessing Four ambiguous golden questions
    R6 A public user never receives partner-only products or documents; the filter runs inside the retrieval query Four access-control questions and a leak count
    R7 Superseded documents are not cited; documents that disagree are flagged to the user One superseded and two conflict questions
    R8 The tool workflow is bounded (step limit, time limit, step log), tools are read-only, and the one sensitive action needs approval Workflow tests
    R9 One error shape for every failure, no stack traces, and an idempotency key on the discovery endpoint API tests
    R10 Tests run offline, and an evaluation harness compares strategies and writes its results to files Test run and eval/results/

    At the customer: "What will it never do?" A good answer is R2 to R6 in one breath: it will not invent a product, will not answer without evidence, will not guess when the request is vague, and will not show partner-only material to a public user.

    The dataset, with real counts

    Everything lives under the capstone's data/ folder. These counts were read from the files, not from a plan.

    Part Count What is in it
    Products (products.json) 40 5 categories (sensors, gateways, controllers, enclosures, software), 8 each; 35 public and 5 partner-only
    Documents (docs/*.md) 30 datasheets, FAQs and compatibility notes; 29 public and 1 partner-only; each body is roughly 190 to 240 words
    Golden set (eval/golden_set.json) 36 hand-written questions, all asked as a public user

    The golden set breaks down as 12 discovery, 7 factual, 2 conflict, 1 superseded, 4 ambiguous, 6 unanswerable and 4 access-control questions. By expected outcome that is 23 answers, 9 refusals and 4 clarifying questions. Each question carries its expected SKUs, expected documents, a kind and a one-line why.

    Figure 2. How the three data parts relate

    erDiagram accTitle: Products, documents and golden questions accDescr: A product is described by documents and a document may describe several products. A golden question expects products and documents and is graded against what the service returns. PRODUCT }o--o{ DOCUMENT : "described by" GOLDEN_QUESTION }o--o{ PRODUCT : "expects" GOLDEN_QUESTION }o--o{ DOCUMENT : "expects as evidence"

    How to read this: products and documents link in both directions (a datasheet can cover two SKUs), and the golden set points at both so that recommendations and evidence can be graded separately.

    One request, traced against the requirements

    Take the headline request. The reference build, run with the mock provider, extracts category sensors, quantity 40, budget 30,000, protocol OPC UA and environment humid. It recommends two products, LUM-VS-100 (a wired vibration sensor, IP67) and LUM-GW-200 (a gateway that exposes the sensor's Modbus RTU readings as OPC UA), each with citations such as ds-vs-100#3 and ds-gw-200#3.

    Assumptions:

    • Prices are the data's illustrative prices, EUR 349 for the sensor and EUR 690 for the gateway.
    • One sensor per pump, and one gateway is enough, as the cited datasheet sentence says.

    It also adds one open question: the gateway is rated IP20, so it belongs in an enclosure rated IP65 or better. Confidence is high. The response reports 9 provider calls and 6 workflow steps.

    Item Calculation Result
    Sensors 40 x 349 13,960
    Gateway 1 x 690 690
    Total 13,960 + 690 14,650
    Budget left 30,000 - 14,650 15,350

    The answer fits the budget with room for an enclosure, which is exactly the kind of check R2 and R3 exist to make verifiable: the SKUs are real, the prices come from the catalog, and the sentence about one gateway for 40 pumps is quotable.

    How to use the reference build

    Do not copy it. Build each phase yourself from its lesson, run the tests, and only then open the reference code for that phase. Compare three things: the public names, the error cases it handles, and the tests it writes.

    If your version differs, ask whether yours is wrong or just different. A different chunk size or a different budget split is fine if you can defend it with a measurement. A missing check on a model's output is not.

    Traps planted on purpose

    The data is small but not clean, because real customer data is not clean. Each trap is there to teach one defence.

    Trap Where Defence you build
    A superseded datasheet ds-vs-100-reva is replaced by ds-vs-100 Exclude superseded documents from retrieval (R7)
    Two documents that disagree ds-vs-200 says battery life is 5 years at a 10 minute reporting interval; faq-vs-200 says 3 years Flag the disagreement, lower confidence, do not pick silently (R7)
    A partner-only guide and five partner-only products partner-programme-guide and the -900 SKUs Filter by visibility inside the query (R6)
    Protocol gaps The wireless VibraSense 200 has no route to OPC UA in one hop Verify compatibility with a tool instead of trusting wording (R8)
    Unanswerable questions A lead time to Brazil, a warranty period, the company's CEO Refuse (R4)
    NOTE

    A partner-only product is the one place where a correct answer for one role is a leak for another. That is why the golden set asks the access-control questions as a public user, and why role handling is tested separately in the security tests.

    The eight phases in detail

    Phase Work Module Hours You are done when
    P1 Requirements and dataset M1 0.4 Models validate every product and the data loads
    P2 API and deterministic search M1 0.7 GET /api/v1/products/search returns filtered keyword results
    P3 LLM requirement extraction M2 0.5 Free text becomes Requirements; malformed output is repaired once or fails cleanly
    P4 Retrieval and evidence M3 0.7 Chunks carry citation ids; unsupported questions are refused
    P5 Bounded tool workflow M4 0.7 Three read-only tools run under step and time limits; the approval gate works
    P6 Validation, access control and errors M5 0.4 Identity comes from a verified token; one error shape; idempotency works
    P7 Tests and evaluation M6 0.5 Three strategies are compared and results are written to files
    P8 UI, documentation and demo M6 0.6 One page, a README that runs from scratch, a rehearsed demo
    Total 4.5

    The hours add up as 0.4 + 0.7 + 0.5 + 0.7 + 0.7 + 0.4 + 0.5 + 0.6 = 4.5.

    What is given and what is a stand-in

    Three facts about the reference build set the honest limits of everything you will claim about your own.

    • The default provider is a mock: a rule-based stand-in for a model, built from regular expressions and word lists. It makes the course runnable and gradeable offline. It is not a model, and a real model behaves less predictably.
    • The optional AnthropicProvider is a reference adapter. It has never been run against the live API in the reference build, so verify it with your own key before you rely on it.
    • Retrieval is hand-written BM25 keyword search. There are no embeddings and no vector store.

    Prices in the data are illustrative, and the token prices used for cost estimates are placeholders: fill in your provider's published price list before you quote a cost.

    Out of scope

    The capstone deliberately has no database, queue, vector store, streaming, retry with backoff or multi-process deployment. Idempotency keys and approvals live in memory, in one process. Authentication is a signed development token, not an identity provider. create_quote_draft is a library function behind an approval gate, not an HTTP endpoint.

    Writing these limits down is part of the work. A reviewer who finds an undeclared limit trusts the rest of your page less.

    Run it before you read on

    From the capstone folder, these commands run the tests and the evaluation without a key or a network.

    python -m pytest                      # backend tests (no network, no API key)
    python -m eval.run_eval               # writes eval/results/latest.json and latest.md

    The reference build has 151 backend tests. If your own count differs, that is fine: what matters is that they pass offline and that you can say what each group covers.

    Last verified: 2026-11-02

    Next

    Capstone architecture and API contract

    Enroll to keep reading

    Lesson 5 of 8 · Forward Deployed Engineer: Evaluate and Capstone

    The Product Discovery Copilot brief for Lumen Industrial Supply: ten requirements, the real dataset counts, and the eight build phases P1 to P8 with hours.

    In the rest of this lesson

    • One request, traced against the requirements
    • How to use the reference build
    • Traps planted on purpose
    • The eight phases in detail
    • What is given and what is a stand-in
    • Out of scope

    Enrolling is free. It unlocks every lesson in Forward Deployed Engineer: Evaluate and Capstone, 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