Build and Present an Embedding Pipeline in 90 Minutes Using AI Coding Agents

This is a 90-minute mini project with two interviewers watching. You log in over SSH to a prepared environment that already contains: - a dataset for the task, - access to an embeddings API, and - two AI coding agents from different vendors, preconfigured with a usage budget of \$500. Within the 90 minutes you must build the whole pipeline over the provided data and run it end to end, put a UI on top of the results, and keep the final ten minutes to present your results and a plan for scaling the pipeline up. The candidate who reported this round found the time very tight. What the pipeline had to compute was not recorded. Assume the interviewers give you a concrete goal at the start that needs the provided records to be embedded (for example, semantic search or grouping similar records), and plan around the pieces any such goal shares: loading and cleaning the data, calling the embeddings API, storing and querying the vectors, computing the requested result, and showing it in the UI. Explain how you would run the 90 minutes, in two parts. ### Clarifying Questions - What exactly should the pipeline produce, and how will the result be judged: a working end-to-end run, the quality of the output, the code, or the presentation? - How large is the dataset, and what are the embeddings API's rate limits, maximum batch size and price? - Does the usage budget cover only the coding agents, or the embeddings calls as well? - Is any UI acceptable (a notebook view, a small web page, a terminal view), or is a web UI expected? - May I install packages, such as a vector index library or a UI framework, or must I use only what is already installed? ### Part 1 — Plan, split and verify the build Describe the first 80 minutes: what you decide before any code is written, how you split the work between agents, what you build first, and how you check agent-written code, stay on schedule and stay within budget. ```hint Fix the seams before the code Work out what each module takes in and hands on before any agent starts, so that pieces written at the same time actually fit together when you join them. ``` ```hint Price the full run early Estimate how long, and how much, one pass of the embeddings API over the whole dataset will take before you commit to it, and decide what you will do if the answer does not fit. ``` #### What This Part Should Cover - A decomposition into modules with agreed interfaces, which of them can run in parallel, and the critical path - How the agents are instructed, supervised and checked, rather than trusted blindly - Time checkpoints, and a fallback that keeps an end-to-end result working at every stage - Control of API cost, rate limits and failures during the embedding run ### Part 2 — The ten-minute report and the scale-up plan Describe what you show in the final ten minutes: the results, how you back them up, and your plan for running the pipeline on far more data. ```hint Decide your numbers in advance Choose early which few measurements the report will need, and make the pipeline record them as it runs, so you are not reconstructing them at minute 85. ``` #### What This Part Should Cover - Results supported by measurements from the actual run, including a quality check - An honest statement of what was not finished or not validated - A scale-up plan that names the first bottleneck at each growth step (embedding throughput, vector storage and search, serving, cost) and the change that removes it ### What a Strong Answer Covers - A thin but complete end-to-end path early, then improvement, instead of perfecting one module at a time - Parallel agent work that stays coherent because the contracts between modules were fixed first - Visible evidence that agent-written code was reviewed and tested - Budget and time awareness for both the coding agents and the embeddings API - A presentation that connects the demo, the measurements and the scale-up plan within ten minutes ### Follow-up Questions - With 15 minutes left, two agents' modules disagree about the record format at integration time. What do you do? - The embedding run hits the API's rate limit halfway through the dataset. How should the runner have been built so that nothing is lost and nothing is paid for twice? - How would you check the quality of the pipeline's output when there are no labels? - In your scale-up plan, the dataset grows a thousandfold. Which part of the code you wrote today breaks first, and why?