Amazon LP Story Bank + Metrics Defense

Speak-first for Customer. Angle is the student’s study loop, not VR as a demo. Think Big later can reuse GiftedBooks only if this hour did not already spend it — and even then the emphasis must be “learning system,” not this 3–10 minute collapse.

Spoken 90–120s. “The customer was a student whose study loop was broken. They could find a chapter, get stuck on a derivation, and lose hours waiting for a person. I did not start from ‘let’s put an LLM in VR.’ I started from that wait. I made their uploaded PDF the source of truth: ingest once, retrieve a small scoped set, answer from those chunks on a sub-300ms API path. I kept previous-year-question ranking as a separate analytics path so the model would not invent the syllabus. In our user testing, doubts that used to take hours landed in a 3–10 minute window, and we reported +35% reading efficiency and +50% engagement. The trust move was grounding plus isolation, not a smarter generic tutor.”

Coaching: different angle from GiftedBooks. Here the customer is the client operator / reviewer on ConvBI, not a student. Do not replay the 3–10 min numbers. Do not invent a named client quote.

Coaching: customer is the non-SQL analyst. Emphasis is access to their own numbers, not “I built LangChain.” FastAPI proposes SQL; Nest executes under RLS. LangChain, not LangGraph.

Coaching: genuine fourth from cover-letter / notes, not a makeup. Keep it high-level. There is no concrete client name in the lock. Do not invent one, a revenue number, or a subscriber count.

Speak-first Ownership. Learn and Be Curious can reuse Y1 later only with the how I learned angle (request map, not library-first). Do not give both openings in the same hour.

Spoken 90–120s. “A teammate left and the SQL-RAG chatbot — the path from a question to SQL to a structured chart — became a gap. I did not wait for someone to assign it. I stood it up locally and traced LangChain state, dynamic prompts, schema lookup, FastAPI SQL generation, Nest execution, and the response parser. I put logs on those boundaries. That is how I found data:null was a format mismatch, not an empty database, and how I found MySQL-shaped SQL hitting Postgres. I fixed the format path, the prompts, and validation. Validation still does not guarantee the SQL means what the user meant. The ownership was the whole hop list, not a single function.”

Coaching: Ownership angle is “I treated isolation as my job.” Highest Standards later is “I refused LLM-as-security.” Do not copy this STAR. I vs we: Nest middleware + policy generator are the pieces to claim carefully; not a hand-written DBA migration of record; intern, not named security team.

Coaching: this story exists to draw a line. Core software member, not team lead. Do not absorb predictive planner, full costmap, or custom sensor-fusion. Resume 17th/80+; public Horizon materials sometimes ~18th and #1 India — flag, do not fight. +40% obstacle definition is weak — do not lean on it.

Coaching: Ownership of the path to users, not “I am the AWS account owner.” Do not dump six metrics. Think Big later can use ConvBI as a product vision — different sentence.

Speak-first Invent. The invention is the contract. The simplify is not building a second chart island. Have Backbone energy if they ask about disagreement — prototype instead of argument — but do not invent a manager fight.

Spoken 90–120s. “The chatbot needed charts, and we already had a report builder with an ElementRenderer. The inventive move was not a new library. It was a structured response — type, data, dimensions, metrics — that the old renderer could consume. I prototyped it so the discussion was a screen, not an opinion. We kept one place that knows how to draw. I may have been misunderstood as ‘blocking a dedicated AI chart module.’ I accepted that. Two renderers would have been the complicated thing.”

Coaching: Invent angle is separation of jobs so retrieval, relationships, and test generation are not one blob. Learn’s Hybrid story is “why hybrid vs vector-only + 2-hop.” Do not paste the same Action paragraph.

Coaching: Invent/Simplify only. Not ownership of the rover. Not Learn’s “layers must agree.”

Coaching: Invent/Simplify = remove local GPU setup and reuse models. Think Big = “this is a platform.” GitHub README is a Next.js scaffold — resume wins.

Speak-first Are Right. You were willing to be wrong about “the detector works.” 73% was a working demo and a bad safety product. Do not invent class-wise AP, train/val split, or a site name.

Spoken 90–120s. “I had a YOLOv9 PPE model at 73% mAP that drew boxes and looked like progress. I did not ship it. Floor safety is not a hackathon demo. I assumed my first ‘it works’ was wrong and I went back to data and training — 15,000+ images — until I had 89% mAP at 24 FPS. Only after that did we go to 20+ cameras and audit logging. The resume’s pilot says recorded violations dropped 50% after alerts. The judgment call was refusing to confuse a running model with a safe one.”

Coaching: Are Right = you were willing to drop the first story you told yourself. Dive Deep can use the same incident; this answer stresses disconfirming the belief.

Coaching: Are Right = mechanism over vibe. −35% methodology is weak — say so. Resume Redis vs this snapshot’s 5-minute in-process Map — say so. Key by role+org, not query text alone.

Coaching: Are Right = you would have been wrong to blame the scrape. Learn uses DeepQuery as orchestration curiosity. Think Big uses 200+ sites as breadth. Keep this on the mis-attribution.

Speak-first Learn. You were curious enough to explore a research workflow that is not “chat with tools.” Acted: you built the graph. Not a book report.

Spoken 90–120s. “I had to learn deep research as a state machine, not as a chatty agent. I built DeepQuery on LangGraph: plan, a light search so clarification is grounded, a bounded 12–15 query generation, fan-out across DDGS, Bing, and Firecrawl, then URL intelligence before I pay for scrape — we often aim to keep the scrape set in a 120–180 band — then waved scrape, cross-page reasoning, a decision loop, and synthesis. HITL is clarify and refine, not a human inside every node. I learned the hard way that a 0% confidence file can still have pages; the lesson was in the synthesizer. A strong run in my notes went 857 URLs to 120 filtered to about 137 pages. I do not have an IQVIA percent to quote.”

Coaching: Learn angle only. Ownership already used “I took the gap.” Here the sentence is how you learn unfamiliar code.

Coaching: Learn = conceptual jump. Not Ownership’s “I owned video.” Not Invent’s “pipeline vs frames.”

Coaching: Learn angle. Invent already used “do not make one model do everything.” Here you learned why BM25 + kNN + semantic rerank + 2-hop is a different question than “embed the PDF.”

Speak-first because it is the honest campus leadership line. Strength is humility plus a real mechanism: pairing on tech-team work. Weakness is no named mentee and no count. If they ask for “one person you developed,” do not mint a name.

Spoken 90–120s. “I am an IEDC Tech Team member, not the lead and not a hiring manager. The resume has no mentee count and I will not invent one. What I actually did was pair: they drive, we reproduce the break, we name the hop, they take the next change. If they wanted me to finish the module so they could present, that is not developing them. I do not have a named person and a before/after I can defend in this room. If that is the bar for the question, I would rather say the gap than mint a story.”

Coaching: develop = making the next person able to run GStreamer/ZED when you are not on the headset. Still no named mentee. Still not team lead.

Coaching: develop-the-team via process, not a mentee fable. Earn Trust adjacent. Keep it small and true.

Speak-first Standards. Defects do not go down the line: a weak detector does not get multiplied across a floor. Problems stay fixed: the quality gate is in front of scale, not a hope after alerts.

Spoken 90–120s. “Highest standard on Argus was not a slogan about safety. It was a sequence. I would not send a 73% model down the line into 20 cameras. I held 89% mAP and 24 FPS as the gate — quality and real-time — and only then did we Dockerize multi-feed, log to Postgres, and alert. If I reverse that order I multiply misses. The pilot’s recorded incidents dropped 50% after alerts. I need the incident definition if you press the number. The standard I will repeat is: defects do not get a wider pipe.”

Coaching: Standards angle. Ownership Y5 was “I took the boundary.” Here the sentence is “a fluent SQL is not a control.”

Coaching: handwritten, speakable, no new percents. 40% faster reports and 99.9% are not measured solely from this crash.

Coaching: Standards = observability and not pretending evals you do not have. Cross-wire validator honesty from Ylogx if they stay on “does your check make GenAI safe?”

Speak-first Think Big. Invent already used “browser inference simplifies setup.” Here the sentence is the direction: CV experimentation as a place, not a notebook.

Spoken 90–120s. “I did not want another one-model demo. StratifyLabs was a direction: do computer-vision iteration in the browser — 3D lab, WebGL inference without a local GPU, a marketplace of 50+ models and datasets, URDF prototyping, and voice RAG characters in the scene. The corner I was looking around was the next student’s wasted week on environment setup and the next team retraining a model that already existed. We reported a 30% cut in iteration time. The GitHub README currently looks like a Next.js scaffold; the resume and stratifylabs.design are the product I will talk about, and I would align the repo.”

Coaching: Think Big backup only. Learn is the primary DeepQuery card. Here the sentence is breadth plus filter so cost stays bounded — looking around the corner of “one search box.”

Coaching: Think Big only if Customer did not already spend GiftedBooks this hour. Emphasis is the system, not the 3–10 minute wait — you may mention the wait as a result, not as the whole LP.

Coaching: Think Big for Ylogx is the product shape. Do not dump 40%, 99.9%, +65%, −35%, +60%, sub-210ms. Ownership Y8 was deploy-path. This is the direction you were building toward.

Speak-first Bias. Emphasis is the date and a reversible integration, not rover ownership and not Frugality’s “we did not buy more IMUs.” Deliver later is 17th as we. Earth later is teaching the pipe. Do not open those with this first sentence in the same hour.

Spoken 90–120s. “ERC has a date. I was core software, not team lead. We had cameras and a ZED 2 — stereo plus an IMU — and I did not wait for extra sensors or for a custom fusion stack I was not going to own. I shipped a GStreamer operator POV at 60 FPS and I integrated ZED scanning at 2M+ points per second into the nav conversation. Pipeline stages were swappable, so the risk was reversible at the hop, not a one-way hardware bet. I did not write the planner or a fusion architecture. The ZED SDK can do visual-inertial tracking; that is not me inventing fusion. We placed 17th of 80+ on the resume; some public notes say about 18th. I flag that. I will not hang −55% collisions on my name.”

Coaching: this card exists so you do not invent a heroic cut. Placements are real. A specific risky decision is not locked. If they want Bias as a single bet, either return to Horizon or say the gap.

Spoken. “I have eight hackathons — first at CodeRecet, Best Project at MLH, runner-up at Magnathon 2.0. The pattern is ship a working slice on a weekend clock. If you want one concrete reversible bet from a named night, I have not locked that story and I will not invent it. The calculated-risk story I can defend is Horizon: integrate the ZED and video we had before ERC, stages swappable, no custom fusion. Or Ylogx: I took the orphaned chatbot instead of waiting for a reassignment.”

Coaching: Ownership in 1–8 was “the gap was mine” plus the hop map. Here the sentence is speed: I did not wait for a ticket that said the bot was mine. Do not replay data:null as the opening unless they ask what you found after you moved. Dive Deep owns the hops.

Spoken. “A teammate left and the SQL-RAG chatbot was a hole. I did not wait for reassignment. I reproduced LangChain → prompts → schema → FastAPI SQL → Nest execution → parser, and I put logs on the boundaries so I could name the hop. Speed was owning the path. I was still an intern. I did not become tech lead and I did not migrate it to LangGraph.”

Coaching: handwritten notes, speakable, no IQVIA percent. Highest Standards / Dive Deep can reuse the same defect with a different first sentence. Here the move is reversible config under time pressure, not a redesign.

Spoken. “In an IQVIA stakeholder path the agent clicked the last chart’s zoom. The DOM it was allowed to see was truncated. I did not rebuild the agent under demo pressure. I raised max DOM elements from 50 to 80, raised the character budget, and used medium reasoning because low failed. That is a reversible config. The path then demoed. I do not have an IQVIA percent for that day.”

Speak-first Frugality. Are Right already used Y6 as “I measured instead of guessing the DB is slow.” Here the sentence is constraint: more warehouse is not a prize. Dive Deep can still use cache key as one hop inside the combined anecdote story — do not open both with Redis in the same hour if you can help it.

Spoken 90–120s. “Repeat bot questions were costing warehouse work we had already done. The expensive answer was a bigger RDS. I did not have a budget prize for that. I put a cache-aside path on repeats and I keyed it by role and org, not by English alone, so a faster answer could not become someone else’s numbers. On a miss we still execute as the caller with RLS. The resume says Redis cut that bot-DB latency by 35%. If you open this Nest checkout you will see an in-process Map and a 5-minute fieldsCache — I will not pretend Redis lives in that file. I will not quote a bill I avoided.”

Coaching: Invent’s sentence was the contract. Here the sentence is “I will not spend a second visualization world.” Backbone later is prototype-as-argument. If Invent already used Y4, do not open Frugality with this prototype.

Spoken. “We already had an ElementRenderer on the report builder. A second chart stack for the bot would have been extra surface we did not get points for. I made the bot speak type, data, dimensions, metrics and I reused the renderer. I showed a prototype instead of asking for another library. Same intern team, same product — less world to maintain.”

Coaching: not Bias’s calendar speech. Not Deliver’s place. You did not build custom fusion. Constraint = the camera already on the mast.

Spoken. “Frugality on Horizon was using the ZED 2 we already had — stereo and an IMU — plus the cameras, instead of turning perception into a shopping list. I integrated that scanning and I shipped the GStreamer POV. I did not write custom fusion. I did not own the planner. I will not invent a sensor we almost bought.”

Coaching: original project, not makeup. Invent/Think Big used platform and simplify. Here the sentence is “I did not rent a farm so students could iterate.” README is a Next.js scaffold — resume and stratifylabs.design win. DeepQuery URL-intel is the Scale cost-bound card; do not also open this hour with 857 URLs unless they pull IQVIA.

Spoken. “StratifyLabs was me refusing a GPU farm as the price of trying a model. I put inference in the browser with WebGL and I put 50+ models on a marketplace so the next experiment was reuse. We reported a 30% cut in iteration time. I do not have a GPU invoice I saved. The GitHub README currently looks like a Next.js scaffold; the resume and the live site are the product I will talk about.”

Speak-first Earn Trust. Customer already used the 3–10 minute study loop. Here the sentence is candid trust: their PDF is the evidence, and I will tell you the README is wrong. Scale later is “more students must not mean more hallucination.” If Customer already spent GiftedBooks, keep this only if they pull trust — lead with the README and the refuse-to-invent, not the +35% parade.

Spoken 90–120s. “Earn the student’s trust first: their uploaded PDF is the source of truth. I retrieve a small user-scoped set and I answer from those chunks. I will not mix another student’s notes. Previous-year questions are analytics, not the model inventing the paper. In our user testing, doubts that used to take hours landed in a 3–10 minute window; we also reported +35% reading efficiency and +50% engagement. Uptime on the resume is 99.5%. I do not have a citation eval, so I will not pretend grounded means measured. The awkward part: the GitHub README currently describes AegisAI. The resume and giftedbooks.study are GiftedBooks. I would fix the README rather than hope you never open it.”

Coaching: Ownership was “I took the boundary.” Standards was “LLM is not a control.” Here the sentence is candor about empty versus 403 versus permission denied. Listen to the interviewer’s words; if they say “reject,” correct them respectfully.

Spoken. “I will not earn trust by saying Postgres rejects a cross-tenant SELECT. On our warehouse path, RLS filters. If the session org is A and the SQL asks for B, you can get 200 and zero rows. Missing GRANT is permission denied. App table checks are 403. No db role fail-closes to rls_no_access. Chat metadata can go through executeWithoutRLS — I will not tell you every table is RLS. FastAPI writes SQL; Nest runs it as the caller.”

Coaching: trust = show the screen, listen, no invented fight. If they had rejected reuse, commit wholly is Backbone — say it here as the respectful close, do not manufacture the rejection.

Spoken. “I did not win reuse with a speech. I prototyped the bot payload into ElementRenderer so the team could click it. I do not have a manager fight on paper. If they had said no, I would have built the path they chose. I still think two chart worlds would have drifted — but I would not have quietly refused to ship.”

Coaching: spoken project is Horizon. Other floors stay in follow-ups so you do not stack internships. Volunteer the discrepancy. Correct planner ownership without being asked to be a hero.

Spoken. “I will not pick a fight over Horizon’s place. Resume says 17th of 80+; public notes sometimes say about 18th. I flag that and I will align the source of record. I also will not earn trust by owning the planner. I shipped video and ZED perception. −55% collisions is not my algorithm. +40% obstacle is a weak definition. If you want other floors: I refused to talk about Argus as done at 73%, and I will tell you Redis is resume while this Nest file is a Map.”

Speak-first Dive Deep. Same internship, three hops, one spoken product. Do not open Frugality with Redis in this hour if this is your first story. Are Right Y3 was “I dropped the belief.” Here you stay in the artifacts until the slogan dies.

Spoken 90–120s. “People said the model was slow, or it hallucinated, or the database was empty. I opened the hops. One failure was data:null in the UI while Postgres still had rows — the state format between generation and the parser was wrong, so the chart had nothing to draw. Another was MySQL-shaped SQL on Postgres; I ran the SQL, saw the dialect, and fixed the prompt examples plus validation. Validation still does not mean the total is the business total. When the story was ‘the DB is slow,’ repeats were a cache problem, and the key has to carry role and org or you leak. Resume says Redis cut that bot-DB latency 35%. If you open this Nest file you will see a Map. I will not invent a dashboard to sound deeper than the logs.”

Coaching: Bias already used “I changed config under pressure.” Here you prove the defect from evidence. No IQVIA %.

Spoken. “The anecdote was that the agent could not click. The screenshots said the DOM was truncated — it saw the last chart’s zoom and not the control we needed. I raised max elements from 50 to 80 and I used medium reasoning because low failed. I did not rebuild the agent. I still do not have an IQVIA percent for that demo.”

Coaching: Learn used orchestration. Are Right used “do not blame retrieval.” Here metrics versus anecdote: grade D / 0% confidence looked like a dead search; the folder still had pages. Ranking also means url_intelligence: 857→120 is a filter, not a failure to find the web.

Spoken. “I had DeepQuery runs that ranked as 0% confidence and grade D. The anecdote is retrieval died. The artifacts still had pages. A strong run in my notes went 857 URLs to 120 filtered to about 137 pages. The weak ones were short — a couple hundred words — after scrape had already worked. That is a synthesis JSON parse, not an empty web. If I had loosened URL ranking or paid for 857 scrapes I would have dived into the wrong hop. I do not have an IQVIA success percent.”

Coaching: Invent split jobs. Learn asked why hybrid. Here you defend the detail: token budget and why cosine is not DEPENDS_ON. No labeled IR set — say so.

Spoken. “I do not chunk BRDs by character count. Ingest uses 1500 tokens with 200 overlap on cl100k_base, then 3072-dim embeddings. Characters would silently disagree with the token window. I also do not retrieve vector-only. Requirements have DEPENDS_ON in Neo4j, and BRD identifiers still need BM25. Hybrid plus a 2-hop walk is the detail. I do not have a labeled IR set, so I will not invent nDCG. Redis and Celery are in the file and not in the runtime.”

Speak-first Backbone. Learn/Invent used hybrid as curiosity and job-split. Here you challenged vector-only because requirements DEPENDS_ON, and you say how you would commit if the team had picked vectors anyway.

Spoken 90–120s. “Vector-only on a BRD is the comfortable demo. I disagreed. Requirements DEPENDS_ON each other, and section IDs lose to cosine, so I argued hybrid search plus a 2-hop graph walk. I did not have a labeled IR set, so I did not invent nDCG to win the room. If the team had locked vector-only, I would have built that and I would have committed to evals so we could see the miss class — I would not have kept a shadow hybrid for my ego. I do not have a manager fight on paper. Redis and Celery are not wired; I will not use them as props.”

Coaching: if Invent/Frugality/Trust already spent Y4, skip. Backbone sentence is conviction without a scene.

Spoken. “I disagreed with a second chart stack. I did not give a speech. I showed a prototype on ElementRenderer. If they had rejected reuse I would have committed to their library. I do not have a manager argument to sell you.”

Coaching: Ownership/Standards/Trust used pieces of Y5. Here the fork is where the predicate lives. No manager fight.

Spoken. “I disagreed with app-only WHERE and with ‘the model will add the org filter.’ That is social cohesion around a demo. I wanted RLS in Postgres on a per-request SET ROLE, GUC from the JWT, fail-closed if there is no db role. Zero rows is a filter, not a reject. I do not have a manager fight. If they had locked application filters I would have built that path and I would not have secretly forked a second policy.”

Coaching: original, not makeup — the refuse-to-widen is documented. Are Right was “73% is not done.” Standards was the 89%/24 FPS gate. Here the sentence is: I would not compromise the safety bar so the demo could get wider. No stakeholder shouting match is locked.

Spoken. “I would not put a 73% PPE model on 20 cameras to make the wall look finished. That is compromising a safety bar for a cohesive demo. I trained on 15k+ images to 89% mAP at 24 FPS, then we widened. I do not have a manager fight. The resume’s pilot says recorded incidents dropped 50% after alerts. I need how ‘incident’ was coded if you press the number.”

Speak-first Deliver. Bias already used “I moved on sensors we had.” Here the sentence is the result on the calendar: we competed, I can name my inputs. Earth later is teaching the pipe. If Bias already opened Horizon, use Y8.

Spoken 90–120s. “We took a Mars rover to ERC 2024. I am not going to deliver that sentence as if I built the vehicle. I delivered the operator video — GStreamer, 60 FPS, multi-feed POV — and I integrated ZED scanning at 2M+ points per second into the nav conversation. I did not write the planner or custom fusion. The resume says 17th of 80+; some public notes say about 18th. I flag that. −55% collisions is not my algorithm. The timely part is: those hops were on the rover when we competed.”

Coaching: Ownership Y8 was “I did not stop at localhost.” Think Big was product shape. Here you deliver numbers as product outcomes and you draw I versus we. Do not dump every percent. If Horizon already delivered, this is the backup.

Spoken. “At Ylogx I need to split the scoreboard. What I can call mine is the bot path I inherited and stabilized, the renderer reuse, RLS on the request, the identity-keyed cache, deterministic dashboards, and an intern deploy path onto ECS and ALB. Product-family numbers on the resume — report time, uptime, dashboard count — are we, not a personal A/B. I will pick the one that matches your question instead of reciting the list. FastAPI writes SQL; Nest runs it as the caller. I was not the AWS account owner.”

Coaching: Deliver = quality then width, on purpose. If Are Right/Standards/Backbone/Scale already used Argus, skip.

Spoken. “I did not deliver Argus as 20 cameras at 73% mAP. I delivered 89% at 24 FPS first, then width. The pilot’s recorded incidents dropped 50% after alerts. I need that definition if you press. I will not invent a missed go-live.”

Coaching: Learn was curiosity. Dive Deep was 0% parse. Scale is filter-before-scrape. Here: you shipped a 12-node CLI and you have A-grade runs in the write-up. No product percent.

Spoken. “I shipped DeepQuery as a 12-node LangGraph on a local CLI — plan, light search, clarify, about 12–15 queries, fan-out across DDGS, Bing, and Firecrawl, filter before scrape, then reason and synthesize. In the benchmark write-up, 10 of 12 runs graded A. Two sat at 0% confidence; those still had pages — that was parse, not a dead scrape. A strong run went 857 URLs to 120 filtered. I do not have an IQVIA product percent. Redis and Celery are not wired.”

Speak-first Earth. Ownership was “I owned the pipe.” Hire backup was pairing. This sentence is: the workplace is safer and more productive if the POV is not trapped in my headset. Vision for their success even on launch day without me.

Spoken 90–120s. “I do not have a manager title on Horizon. What I could do for the people next to me was make the video pipe something they could start and debug. I paired on launch: GStreamer up, multi-feed POV, where ZED entered the view, and I said the planner was not mine so I did not train them on a lie. If the feed died I wanted them ready without waiting for me. I do not have a named person and a before/after I can defend. 17th of 80+ is we; some public notes say about 18th. I will not turn that place into a mentorship score.”

Coaching: Hire primary in 1–8 was this card. Here emphasize empathy and whether they can ship without you finishing their module. Still member. Still no mentee count. Hackathon medals are yours, not a coaching scoreboard.

Spoken. “I am an IEDC Tech Team member, not a manager. I do not have a mentee count and I will not invent one. I paired: they drive, we name the hop, they do the next change. Finishing their module so they could present is the opposite of asking whether they are ready. If you need a named person and a before/after, that is missing and I will not fill it live.”

Coaching: Hire used process-as-develop. Here: a more productive, less blamey workplace. No conflict percent. No fight. No missed deadline.

Spoken. “People were stepping on the same files. That is not a high-performing intern week. I pushed for clearer branches — bot versus builder versus dashboards versus RLS — so someone else could ship without waiting on my merge. I do not have a conflict percent and I did not become the GitHub owner. I do not have a fight to sell you.”

Spoken (future tense only). “I do not have an intern buddy program to tell you about. If I were designing one, I would not start with coffee chats. I would sit them on one isolated request and one UI defect class, they would drive, and I would care whether they could do the next one elsewhere. I will not put a name on that person because they do not exist in my facts.”

Speak-first Scale. Secondary effect of width at 73% is a false sense of safety on every feed. Standards used the gate sentence. Are Right used refuse-73%. Deliver used sequence. If any of those already opened Argus, use Ylogx ECS+RLS or DeepQuery filter here.

Spoken 90–120s. “The secondary effect of scaling Argus too early is twenty cameras agreeing on a miss. I would not put a 73% model on that wall. I held 89% mAP and 24 FPS, then we went to 20+ streams with Postgres audit and alerts. Alerts on a bad detector would have scaled noise. The pilot’s recorded incidents dropped 50% after alerts — I need that definition if you press. I did not invent YOLO. I did try not to multiply a defect and call it a deployment.”

Coaching: Ownership/Deliver used deploy and tiles. Here the secondary effect is: more healthy tasks times a missed SET ROLE is more leak surface. Isolation was already the request path — scale must not skip it.

Spoken. “If we scale ConvBI without isolation, we scale leaks. I worked an intern path onto ECS and an ALB with Docker and CI/CD, and the warehouse request still SET ROLEs the caller and sets the org from the JWT. FastAPI does not become the database user just because traffic went up. I did not shard and I was not the AWS account owner. I will not quote a bill. CloudFront is for static assets, not private JSON.”

Coaching: Frugality could have used this; we kept Stratify on Frugality. Here the sentence is secondary cost and junk context, not a bill you will invent. Humble: you did not invent the web.

Spoken. “If DeepQuery scales by scraping every URL we discovered, we scale junk and we consume a context window we did not earn. A run in my notes had 857 URLs. We filtered to 120 and scraped on the order of 137 pages. URL intelligence sits before the scrape wave on purpose. I will not invent a bill I avoided. I will not quote an IQVIA success percent. If I had answered 0% confidence by scraping more, I would have multiplied the wrong hop.”

Coaching: Customer was the 3–10 minute loop. Earn Trust was README plus candor. Here the sentence is secondary effects at width: more students on an ungrounded tutor is more invented syllabus. Cite-or-abstain is design intent, not a scored eval.

Spoken. “If GiftedBooks gets more students and the tutor is not grounded, we scale hallucination. I retrieve from that student’s own PDF and I answer from those chunks. I will not mix another student’s notes just because it looks smarter. Previous-year questions are analytics, not the model inventing the paper. I want cite-or-abstain — if the file does not support it, do not invent — and I will not pretend I scored that. User testing put doubts in a 3–10 minute window. Uptime on the resume is 99.5%. I do not have a headcount. The GitHub README currently describes AegisAI; I would fix it.”

• Why. A KPI tile is a known aggregation. Putting ChatOpenAI on overview would add model time, non-determinism, and a failure class (bad SQL) to a path that should just return numbers. Resume family: 30 dashboards, +60% manual-reporting overhead, sub-210ms.
• What the architecture does. DashboardsService holds hand-written SQL aggregations. Browser sends month/year query strings. Nest runs them on req.dbTransaction after SET ROLE. Response is JSON only. CloudFront serves the SPA; tile JSON still goes CloudFront → ALB → ECS, not as an edge object. Sequelize pool (max 20) borrows a connection per in-flight request.
• What I did. I can walk the tile path and defend “no model on GET.” I do not claim I hand-wrote every one of the resume’s 30 tiles. This checkout’s controller registry is nine dashboard types; some are multi-page. Resume 30 tiles. If they open the registry I say nine types.
• Trade-off. New KPI shapes need a deploy, not a prompt. That is the point. Flexibility lives on the report builder and the bot, not on the tile that finance opens every morning.
• How I would measure. Server duration on the dashboard GET (LoggingInterceptor already wraps controller time; Sequelize benchmark: true can log SQL timing when SQL_LOGGING is on). I would want p50/p95 by route and month/year cardinality. I do not have that panel to quote. Resume sub-210ms is the number I am allowed to say. I do not invent a probe host.
• Follow-up they ask. “Why not cache the dashboard JSON?” Because a cache key without role + organizationId is a tenant bug. I would not cache tiles until the key is tenant-safe. See would-do.

Spoken 15s. “Dashboards are deterministic GETs. No LLM. Pooled Postgres, JSON only, CloudFront for the SPA. Resume says sub-210ms. I will not put the model on that path to look modern.”

• Why. Natural language needs a model. Tenant SQL must not run as the table owner. Owners bypass RLS unless FORCE — this generator does not emit FORCE. Isolation depends on not executing as owner.
• What the architecture does. Nest executeChatQuery POSTs { query, options } to CHATBOT_API_URL (default https://chatbot.projas.in/chatbot). FastAPI SQLQueryAndDetailsExtractor uses ChatOpenAI(model="gpt-4.1", temperature=0) and a Pydantic SQLQueryAndDetails parser. Nest then executeRawSelectQuery on the same request’s dbTransaction. FastAPI never sees the JWT and never runs the warehouse SELECT as the caller.
• What I did. I inherited the chatbot path after a teammate left (Ownership Y1). I own walking Nest execute + RLS + structured JSON into ElementRenderer. I am not claiming I wrote every prompt line on day one.
• Trade-off. Two hops (Nest → sidecar → Nest → Postgres). Tile path stays one hop. If the sidecar is down, tiles still work; bot returns BAD_GATEWAY. Gunicorn timeout in the AI image is 180s — that is not a tile SLA.
• How I would measure. Split logs I already emit: chatbot HTTP durationMs vs SQL durationMs vs total executeChatQuery time. Resume +65% is analyst productivity on the SQL-RAG story, not sidecar p95. I do not invent a LangSmith board on Ylogx.
• Follow-up they ask. “Can the model SET ROLE?” No. The model returns SQL text. Nest binds the transaction that already has the role.

Spoken 15s. “The model proposes a SELECT and chart metadata. Nest executes it as the caller, on the request transaction, after SET ROLE. FastAPI never runs tenant SQL.”

• Why. If the sidecar executed as a privileged engine user, a fluent SELECT could dump another org. Schema context is cheap compared with that failure.
• What the architecture does. SQLDatabase.get_table_info() feeds the prompt. validate_and_sync_schema diffs live info against config.table_descriptions and can auto-sync the config dict. Allow-list in include_tables: accounting_transaction, bs, cashflow_bank, cashflow_others, inventory_stk_masters, inventory_stk_vouchers, outstanding_payable, outstanding_receivable, pl, sales. Ten public fact tables. Not application tables.
• Trade-off. Drift between prompt schema and warehouse still happens; the validator logs and can rewrite descriptions. Auto-sync is convenience, not a migration tool. A wrong column name still produces a failed SELECT that Nest catches and returns as an empty chart plus message.
• How I would measure. Rate of executeChatQuery.sql.errorMeta vs successful row counts. Schema-validator log lines after a warehouse load. I do not have a labeled “SQL exact-match” eval on the resume.
• Follow-up they ask. “Does the validator guarantee the SQL is right?” No. It keeps the prompt’s table map honest. Semantic correctness is still Nest + RLS + the operator’s eyes.

Spoken 15s. “The sidecar reads allow-listed schema through LangChain SQLDatabase and syncs descriptions. It returns SQL and chart fields. It does not execute the tenant query.”

• Why. A generated string is not a security control by itself. I need a cheap reject, an app-level table gate, and then Postgres RLS as the row gate.
• What changed / what the code does. executeRawSelectQuery does sql.trim().toLowerCase() and rejects unless it startsWith('select'). A FROM/JOIN regex collects table names. Each name must pass hasTableAccess or HTTP 403. For non-SUPER_ADMIN, if the table has organizationId, Nest injects "alias"."organizationId" = '…' into WHERE (or before GROUP BY / ORDER BY / LIMIT). Then sequelize.query with QueryTypes.SELECT on dbTransaction.
• Trade-off. Prefix check is not a parser. SELECT …; DELETE is a residual class if we ever stopped treating this as one statement. Regex table extract can miss exotic SQL. App org injection is belt-and-suspenders; isolation is still SET ROLE + policy USING. If a table has no organizationId column, injection no-ops and RLS must carry the row filter.
• How I would measure. Count of executeRawSelectQuery.rejected and 403 table-restricted responses in CloudWatch-style ECS logs. Deny fixtures: ORG_A session asking for ORG_B returns zero rows (RLS), not “Postgres rejected.”
• Follow-up they ask. “Is org injection the isolation?” No. JWT org is not a policy. SET ROLE exists because the Nest login is typically owner/privileged. App WHERE cannot save a RESET ROLE leak.

Spoken 15s. “I trim and require SELECT. I 403 tables the role cannot see. I may inject organizationId. Then I run on the SET ROLE transaction. The row filter is Postgres, not the prompt.”

• Why. The model should not see user, role, policy, or chat-metadata tables. Those are application tables. Some of them are written via executeWithoutRLS after RESET ROLE on purpose. Mixing them into SQL-RAG is a leak class.
• What changed. FastAPI include_tables is the ten fact tables above. Nest systemAccessibleTables / module registry decide what a role can query. Chat conversation rows are a different path.
• Trade-off. A new warehouse table is invisible to the bot until it is allow-listed and described. That is slower than “dump information_schema.” It is the correct slowness.
• How I would measure. Attempts to reference a non-listed table in generated SQL should fail at extract or at hasTableAccess — I would count those, not invent a precision score.
• Follow-up they ask. “Why not pass the whole schema?” Prompt size, wrong-table joins, and application-table leakage.

Spoken 15s. “The bot only sees an allow-list of fact tables. Application tables stay off that prompt. A new table is a deliberate add, not a surprise.”

• Why. Pooled connections reuse sessions. A process-wide SET ROLE leaks User A into User B. App WHERE cannot see which role the socket still holds.
• What the architecture does. JwtMiddleware then RLSMiddleware. Open a Sequelize transaction. SET ROLE to the mapped db_role_name, or rls_no_access if missing (fail-closed — an earlier RESET ROLE path was a leak class). Transaction-local set_config for app.organizationId from the verified JWT. Tenant SQL uses req.dbTransaction. FinishTransactionMiddleware registers res.on('finish') before the handler; this snapshot commits on HTTP finish (docs sometimes say rollback-on-error — speak the file).
• What I did. I implemented the request path and the CREATE POLICY generator in Nest. I did not check in a hand-written warehouse sales.sql. I was not the DBA who applied every GRANT by hand.
• Trade-off. Every authenticated request holds a pool slot until finish. Slow handlers reduce concurrency. SUPER_ADMIN RESET ROLE is an explicit privilege, not “RLS everywhere.” Chat metadata CRUD uses executeWithoutRLS — I say that out loud.
• How I would measure. Isolation is deny-fixture evidence, not a resume latency. Pool wait time vs max: 20 under load is a would-measure. No pool-wait SLA on the resume.
• Follow-up they ask. “Why not FORCE ROW LEVEL SECURITY?” This generator does not emit FORCE. Isolation depends on not executing as owner. I do not claim FORCE in prod.

Spoken 15s. “Each request begins a transaction, SET ROLE to that user’s non-owner role or rls_no_access, and runs warehouse SQL there. I fail closed. I commit when the response finishes.”

• Why. Operators needed joins and charts without a second chart island for the bot. Two renderers diverge. Resume 40% faster report generation is the product-family number — I do not pin it on one prototype.
• What changed. Pick tables → join type → columns → drop-zone aggregation/chart. Save is JSON report config. Chatbot returns structured fields: chartType, data, relevantColumns, axes, showChart. Same ElementRenderer draws it (isChatbotChart). This snapshot: Chart.js on that renderer; Recharts also in the package and on some predefined pages. Resume wording is Recharts. I do not pick a fake single library.
• What I did. I proposed the structured contract and prototyped reuse (Invent Y4). FastAPI still only proposes. Nest still executes.
• Trade-off. The renderer is only as good as the payload. A table with two metrics becomes showChart=false by prompt policy. Unknown chart types normalize toward bar in the architecture notes.
• How I would measure. Time-to-first-chart for a join report vs a blank SQL workflow — that is the spirit of the 40% family. I do not have the study protocol on the resume. I will not invent N.
• Follow-up they ask. “Did reuse fix the crash?” No. Crash was client-side aggregation of a large slice. Reuse is one drawing path. Different defect.

Spoken 15s. “The builder is pick, join, drop-zone. The bot returns the same shape of JSON. One ElementRenderer draws both. I did not buy a second chart world.”

• Why. I put aggregation on the client. A large slice crashed the browser and made the agent path unstable. That was my defect. Cost was a tab, not a number I will mint.
• What changed. Heavy aggregation moved to a server / preload path for the AI-requested report. Explicit click to load full data instead of stuffing the tab. Multi-chart generation stayed as data, not screenshots. I did not weaken RLS to make the chart easier.
• Trade-off. An extra click. The default is no longer “dump the slice.” A hotfix that left aggregation on the client would have come back.
• How I would measure. Tab crash rate and time-to-interactive after the click. I do not have row counts or a browser name locked. I say “large enough to crash the tab.”
• Follow-up they ask. “Is this the 40% or the 99.9%?” No. Those are product-family resume numbers. This story is the defect class and the stay-fixed shape.

Spoken 15s. “I aggregated a large slice in the browser and crashed it. I moved heavy work to the server and required a click to load full data. I did not touch RLS to fix a UI bug.”

• Why. SPA bytes and API JSON have different cache and health stories. Laptop deploys drift. Resume: led AWS deploy, 2× release time, 99.9% uptime.
• What the architecture does. Frontend image: Node 20 build → nginx. Nest: Node 18 alpine, USER node, port 5000. FastAPI: Python 3.12, gunicorn 8 Uvicorn workers, port 80, timeout 180. convbi-qa.yml on push qa auto ECR → ECS. convbi-prod.yml on main plus a 3-minute manual approval, then ECS wait-for-service-stability. ALB health: Nest /health pings Postgres; /health/simple does not. Route 53 / CloudFront on the resume hop list.
• What I did. Intern path included the Actions files and the task definition wiring. I do not invent war-room hours around the 3-minute approval.
• Trade-off. Prod tag latest plus SHA is mutable-tag risk. Compose is local. Latex CodeBuild figures are not this checkout’s pipeline. Kubernetes is listed knowledge, not what shipped.
• How I would measure. Resume 99.9% and 2× release. I do not invent outage minutes or a deploy-duration dashboard. Stability wait is the mechanism I can point at.
• Follow-up they ask. “Why not Kubernetes?” Control-plane operations are not on the intern bullet. ECS matched one API, one SPA, one sidecar.

Spoken 15s. “I shipped Docker images through GitHub Actions to ECS behind an ALB. CloudFront holds the SPA. QA auto-deploys; prod waits for approval. I do not call that Kubernetes.”

• Why. When a bot answer looks empty, the tidy belief is “the model hallucinated” or “the DB is empty.” Those are two different bugs. I needed the SQL string and the duration.
• What the architecture does. Global LoggingInterceptor logs method, URL, user, duration. executeChatQuery logs chatbot duration, sql.generated, SQL duration, row count, and sql.errorMeta. Sequelize can log SQL when SQL_LOGGING is true. ECS logs land in CloudWatch as the AWS destination — I do not claim a Datadog board or a saved Insights query I will recite.
• Trade-off. SQL text in logs is an operational secret class (org filters, business facts). Normalize/truncate helpers exist (SQL to 2000 chars). I would not paste a production SQL log in this room.
• How I would measure. Correlation of empty-chart responses with failed SQL vs zero-row RLS. That is Dive Deep, not a new percent.
• Follow-up they ask. “Did logging prove the −35%?” No. −35% is resume cache-aside. Logging is how I split model time from SQL time.

Spoken 15s. “I log the generated SQL and the two clocks — sidecar and execute. If the chart is empty I can tell failed SQL from RLS zero rows. I do not guess ‘the model hallucinated.’”

• Why this card exists. If they open package.json I will not point at ioredis. If they open the resume I will not pretend the Map is Redis.
• What the resume hop is. Cache-aside on repeat bot questions so the warehouse is not hit again. Key must include role + organizationId, not query text alone, or a cached payload becomes another tier’s answer. On a miss, execution still runs as the caller with RLS. Resume: Redis reduced query latency by 35% on that bot-DB story.
• What this Nest tree does. fieldsCache: Map, TTL 5 minutes, key fields:${tableName}, SHA1 etag of the field list. It caches dataset field metadata for the report builder, not dashboard JSON and not bot result rows. One process: 10 ECS tasks = 10 maps.
• Trade-off. A process Map is simple and wrong for tenant-shared result cache. Redis is the shared hop I speak from the resume, not from this file.
• How I would measure. Resume −35% is the allowed number for the Redis hop. I do not invent hit ratio or a TTL as a resume number beyond this 5-minute field cache.
• Follow-up they ask. “Show me Redis.” I say “resume Redis hop versus this snapshot Map” and I walk the Map key.

Spoken 15s. “Minus 35% is resume Redis cache-aside on the bot path, and the key has to carry role and org. This Nest file caches table fields in a five-minute Map. I keep both sentences ready.”

• FinishTransaction. Docs: commit on OK, rollback on error. File: always tx.commit() on res.finish, rollback only if commit throws. I speak the file. Would-do: inspect statusCode.
• Dashboard count. Resume 30 KPI dashboards. Controller: nine types, some multi-page. I do not hide the registry.
• sub-210ms. resume.md currently says P95. I still will not invent how it was probed. Would-do is measure dashboard p95 properly.
• Cookie MD vs Bearer. COOKIE_AUTH_IMPLEMENTATION_COMPLETE.md is not the running middleware.
• Follow-up they ask. “Which is true?” The live file they opened, then the resume family number, then the gap.

Spoken 15s. “If you open the repo I speak the file — finish commits, nine dashboard types, Bearer JWT, a field Map. If you open the resume I speak Redis, 30 tiles, sub-210ms. I do not mash them into one sentence.”

• Why. Repeat bot questions and field metadata should survive task replace. A cache without role + organizationId is a cross-tenant read.
• What I would change. One Redis (or shared store) for bot-result and field caches. Key = hash(sql or question) + role + organizationId + schema generation. Dashboards stay uncached until that key exists. I would not cache a tile as sales:2024-01 alone.
• Trade-off. Cache invalidation becomes a product. Stale KPI is a trust bug. I would rather miss and hit RLS than hit and leak.
• How I would measure. Hit ratio and p95 of bot SQL time on cache hit vs miss — new measurements, not the resume −35% restated. Cross-tenant canary: User B must not receive User A’s payload.
• Follow-up they ask. “Did you ship that key?” Resume Redis is the hop. This checkout’s Map key is table name only. I say the gap.

Spoken 15s. “I would put a shared Redis in front of repeat bot SQL, and the key would include role and org. I would not cache a dashboard until that key exists.”

• Circuit breaker. Sidecar timeout / 5xx should open a breaker so Nest stops paying 180s per chat while tiles stay healthy. Fallback: message, no empty chart pretending to be data.
• Invalidate on warehouse load. Tally zip → S3 → gateway is async. Field cache and any future Redis must drop when the load finishes, or the builder shows yesterday’s columns.
• p95 dashboards. I would add route-level p95 on the deterministic GETs. That is a measurement I do not currently have as a defended study. I will not announce a new number in the room.
• Other hygiene I already say if they grind. Secrets Manager instead of inline task-definition env. FinishTransaction rollback on non-2xx. Turn synchronize: true off in prod-shaped deploys. ALB must use /health, not /health/simple.
• How I would measure. Breaker open rate, stale-schema incidents after ETL, dashboard p95 by route. No invented baselines.
• Follow-up they ask. “Then why is 99.9% on the resume?” Serving path + Actions + health. Not a promise that every would-do is done.

Spoken 15s. “I would trip a breaker when the sidecar dies, bust cache when the warehouse loads, and actually measure dashboard p95. I am not claiming those panels exist today.”

• Why. Scrape is the expensive hop (Firecrawl + tokens). Search hits are cheap. Thinking after you have paid is how you get a bill I will not invent.
• What changed. After aggregation, url_intelligence scores path (useless-route regex), domain trust, keyword overlap with the plan, per-domain cap, target count often in a 120–180 band. Only then scrape_controller takes unvisited filtered URLs.
• Trade-off. A good page on an untrusted-looking domain can be dropped. Refinement HITL re-enters here if the analyst wants another wave. I do not put a human on every URL in an 857 pool.
• How I would measure. filter_yield = filtered / all_urls. Example: 120/857. Pages that later become citations vs dropped domains. No IQVIA %.
• Follow-up they ask. “Isn’t that just a denylist?” Path + domain + keyword + cap is a cheap ranker, not a legal blocklist I will oversell.

Spoken 15s. “I score URLs on path, domain trust, and keyword overlap before I pay for scrape. The pool can be hundreds. The scrape set is the chosen band.”

• Why. One engine misses. Sequential search multiplies wall clock. The same URL from DDGS and Bing is not two sources. The same markdown body on two URLs is not two facts.
• What changed. Per query, parallel_search runs DDGS (thread pool), Bing HTML (httpx + BeautifulSoup), Firecrawl search if configured. Fan-out typical max_results_per_query=35. Aggregator dedups by URL and skips visited_urls. Scraper MD5-dedups markdown bodies.
• Trade-off. Fan-out without a later filter is just a larger bill. Dedup can collapse mirrors that actually disagree — ranking/agreement still has to happen in reasoning.
• How I would measure. Unique URLs vs raw hits; duplicate MD5 rate; facts per scraped page. Artifact folders already store the lists.
• Follow-up they ask. “Why three engines?” Branch-local failure: a Playwright/Bing miss must not erase DDGS. LangGraph reducers append survivors.

Spoken 15s. “Each query fans out to DDGS, Bing, and Firecrawl. I dedup URLs, then I MD5 the markdown so I do not scrape the same article twice.”

• Why. Unbounded scrape and unbounded context make a fluent, expensive, incomplete run.
• What changed. Waves of wave_size (default 15), concurrent_workers (default 3) semaphore. Page body capped. Cross-page reasoning reads inside cross_page_char_budget. Decision engine hard-stops on completeness threshold, enough facts/pages, few gaps, or iteration_count >= max_iterations. Else it may search_new (up to 4 queries), follow_links, or next_wave.
• Trade-off. Caps can stop before a niche source. That is preferred to a loop that sounds busy. HITL refinement is the escape hatch.
• How I would measure. Iterations, pages, confidence, word count on metadata.json. I do not invent elapsed_seconds if the save omitted it (docs flag that gap).
• Follow-up they ask. “Can it loop forever?” No. Max iterations is explicit. Otherwise it should stop or abstain, not keep paying.

Spoken 15s. “I scrape in waves with a worker cap, I truncate what the LLM may read, and the decision node has to stop on completeness or max iterations.”

• Why. Breadth without a think hop is a crawler. A 0% file looks like retrieval death if I do not open the artifacts.
• What the artifacts show. Strong run in the same family: 857 URLs → 120 filtered → ~137 pages, 99% confidence, long report. Weak runs: on the order of 236–256 words, 0% confidence, grade D, but facts and pages were still collected. That pattern matches synthesis JSON parse failure or a truncated save after scrape and reasoning succeeded.
• Trade-off. Confidence in metadata is not retrieval quality. Blaming url_intelligence or Firecrawl would have been the wrong fix.
• How I would measure. Parse-success rate of the synthesizer JSON separately from page count. I would not use 0% as a scrape KPI.
• Follow-up they ask. “So retrieval died?” No. I open scraped_pages and facts.json before I believe the confidence field.

Spoken 15s. “A strong run went 857 URLs to 120 filtered to about 137 pages. A 0% confidence file can still have pages — that one was a synthesizer parse, not an empty web.”

• Why. Clause IDs and “shall” sentences die if a chunk ends mid-requirement. Stuffing the PDF blows the useful window and cites the wrong annex.
• What changed. RecursiveCharacterTextSplitter with length_function=count_tokens on cl100k_base. CHUNK_SIZE=1500, CHUNK_OVERLAP=200 (~13% overlap). Section/page metadata kept. Upload cap 100MB, PDF/DOCX only.
• Trade-off. More chunks → more extraction calls. Overlap duplicates tokens on purpose. 100MB is a denial-of-service bound, not a quality SLA.
• How I would measure. Chunk count vs tokens; rate of requirement IDs that span two chunks. I do not have a labeled split-error set.
• Follow-up they ask. “Why not 512?” Rare clause IDs and tables need surrounding heading. 1500 is the configured Azure-document-sized choice in this tree, not a mystic number I will mystify.

Spoken 15s. “I chunk on tiktoken 1500 with 200 overlap so a requirement does not split mid-sentence, and I refuse a 100MB-plus upload.”

• Why. Vector-only misses exact tokens like R-141 or REQ-1044. Stuffing 200+ pages is not retrieval. Dependencies are edges, not vibes.
• What changed. Azure hybrid: BM25 on content plus vector kNN on 3072-dim embeddings plus semantic reranker. Neo4j get_requirement_graph_context walks DEPENDS_ON up to 2 hops, limit 50 paths. Test-case RAG uses hybrid_search plus that graph context — not “the model remembers the PDF.”
• Trade-off. Two stores to keep consistent. Graph is only as good as extraction. FAISS was an alternative I did not ship here.
• How I would measure. Clause-ID hit rate on a labeled set — I do not have that set. LangSmith is how we inspect, not a recall number.
• Follow-up they ask. “Why not FAISS?” Listed skill. Internship evidence is Azure Hybrid + Semantic + GraphDB.

Spoken 15s. “I retrieve with BM25 and vectors and a reranker, then I walk two hops of DEPENDS_ON in Neo4j instead of stuffing every chunk into the prompt.”

• Why. Embeddings batch. Requirement extraction is one LLM call per chunk — that dominates. Test cases can fan out.
• What changed. embed_chunks_batch size 16; on batch failure, embed one-by-one; zero-vector fallback; 0.2s sleep between batches. Extract loops chunks in an outer batch of 10 but still calls the LLM sequentially per chunk. Test-case graph uses asyncio.gather (notes: batches of 3 concurrent on generation). Azure index upload batches 100.
• Trade-off. Sequential extract is simpler and slower. Parallel extract would need tighter idempotent dedupe on requirement_id (already deduped).
• How I would measure. Docs’ own accounting: 80 chunks ≈ 5 embed batches + 80 extracts + 1 analysis. I would time those stages separately. No IQVIA $.
• Follow-up they ask. “Can you just embed faster?” Embed is not the driver. Extract is.

Spoken 15s. “I batch embeddings at 16. The cost driver is extracting requirements from every chunk. Test-case generation fans out with asyncio.gather.”

• Why the honesty. Jobs today are in-memory maps and FastAPI BackgroundTasks. A process restart loses status. Claiming Celery would last one follow-up.
• What I would change. Wire a broker and a result backend so ingest and test jobs survive the API process. Keep LangGraph checkpoints out of “I have durable workflow” until they are durable.
• Trade-off. Operational surface. In-memory was enough to demo the graphs. It is not a queue.
• How I would measure. Job completion after a process bounce. I do not invent that I already have it.
• Follow-up they ask. “Is this production multi-tenant SaaS?” It is an intern document pipeline with Azure and Neo4j. I do not grow a second personality.

Spoken 15s. “Redis and Celery are in the requirements file and they are not wired. Jobs live in memory. Wiring them is a would-do I will say out loud.”

• Why. The operator needed a media pipeline — capture, encode, transmit, decode, display — not an application thread copying pixels. Resume 60 FPS on that pipe. Probe host, resolution, and which stage that 60 FPS is are not locked.
• What changed. GStreamer on ROS2 so each stage can be tuned (bitrate, latency, caps) without rewriting the rover app. Multi-feed POV instead of one jammed framebuffer.
• Trade-off. Pipeline complexity vs “it works on localhost.” Field networks punish a naive raw-frame socket.
• How I would measure. Resume 60 FPS. I will not upgrade it to a p95. I would measure capture-to-display separately if we instrumented stages — I do not claim I have that trace.
• Follow-up they ask. “Did you optimize the planner with this?” No. I will not absorb planner work I did not write.

Spoken 15s. “I used GStreamer so capture, encode, and transmit were stages I could tune, instead of shoving raw frames through the app. I did not write the planner.”

• Why. The rover needed a spatial sense of terrain. Building a custom stereo stack was not the intern job I owned.
• What changed. ZED 2 SDK point cloud — resume 2M+ samples/s — visualized in RViz/Gazebo and fed as environment input into the navigation conversation. Costmap / −55% simulated collisions is a team test-track result. I integrated perception. I did not implement custom sensor-fusion or the trajectory chooser.
• Trade-off. Vendor SDK vs full ownership of depth. Field calibration still matters. I do not pretend I invented SLAM.
• How I would measure. Cloud rate and whether navigation received a usable cloud. −55% stays on simulated test tracks. +40% I treat as weak.
• Follow-up they ask. “Walk me through your fusion math.” I redirect to the SDK cloud and the integration boundary. I do not invent equations.

Spoken 15s. “I integrated the ZED 2 cloud as environment input to navigation. I did not write a custom fusion stack or the predictive planner.”

• Why. A 73% detector on 20 feeds multiplies misses and trains people to ignore alerts. Floor safety is not a demo GIF.
• What changed. I refused to ship 73%. I iterated data/training to 15,000+ images until 89% mAP and still 24 FPS. Only then Dockerized multi-feed and Postgres event rows (camera, class, confidence, time, box) plus alerts. Video blobs do not live in Postgres.
• Trade-off. Time-to-width vs a trusted alert. A heavier two-stage model can win a clip and lose camera 12. Threshold tweaks hide violations.
• How I would measure. Held-out mAP and end-to-end FPS. Operational −50% is after alerts, a different metric. I do not invent class-wise precision.
• Follow-up they ask. “Why not 95%?” Not on the resume. I do not claim it.

Spoken 15s. “I did not put a 73% model on twenty cameras. I held 89% mAP and 24 FPS, then I scaled feeds and logged events in Postgres.”

• Why. Safety needs an audit query, not a dashboard animation. Many cameras need the same image, not a laptop notebook.
• What changed. Containerized pipeline, 20+ streams, structured events, alert after persist. I do not claim Kubernetes or detector sharding.
• Trade-off. Event rows vs storing video in the database (backups die). Files without rows cannot answer “camera 7 at 18:04.”
• How I would measure. Events per camera per hour; alert lag vs 24 FPS budget. No retention SLA on the resume.
• Follow-up they ask. “Did Argus use Ylogx RLS?” No. Different product. Camera access still needs auth.

Spoken 15s. “After the gate I Dockerized multi-feed, wrote detection events to Postgres, and alerted from those rows — not from video in the database.”

• Why. A notebook or GPU queue per experiment kills iteration. Resume: −30% ML iteration time (not FPS, not Argus 24 FPS).
• What changed. Small supported models infer in the tab next to a WebGL / URDF scene. Heavy training stays off the click path. Marketplace of 50+ pretrained models and datasets so the next person does not retrain from zero.
• Trade-off. Browser memory. Large models belong off the tab. A bot grounded in a stale scene describes objects that are gone.
• How I would measure. Time from scene edit to a new detection — that is the 30% family. 50+ is catalog items, not 50 GPUs. StratifyLabs GitHub README is a Next.js scaffold; resume and stratifylabs.design win.
• Follow-up they ask. “Is this Horizon Gazebo?” No. Horizon is a field rover. This is a browser CV lab.

Spoken 15s. “I run small inference in the browser so a scene change does not wait on a server GPU queue, and the marketplace is there so people reuse a model instead of retraining.”

• Why. Students treat every chapter as equal until the exam punishes them. A generic tutor invents a syllabus. Whole-book prompts miss the sub-300ms retrieve path and mix editions.
• What changed. PDF ingest once (chunk/embed, user+document metadata). Question time: scoped top-k, generate from those chunks. API path resume sub-300ms — retrieve-and-answer, not faithfulness proof. PYQ topic ranking is deterministic analytics over past papers, not an LLM predicting the exam. Isolation: no cross-user retrieval.
• Trade-off. Latency is not citation quality. I do not claim LangSmith here. GitHub README currently describes AegisAI — resume and giftedbooks.study win.
• How I would measure. Resume user-testing: doubts hours → 3–10 min, +35% reading, +50% engagement, 2.5× comprehension, 99.5% uptime. If they want N and protocol I say I will pull them — I do not invent them.
• Follow-up they ask. “Why not LLM the PYQ too?” Because that presents speculation as a map of the paper.

Spoken 15s. “I retrieve from the student’s own PDF on a short API path, and I rank past-paper topics as analytics — I do not let the model invent the syllabus or run unbounded on every request.”

90s spoken overview. “Ylogx, November 2024 to October 2025, I was an intern on a multi-tenant BI product — folders named ConvBI or Projas are that intern, not a second job. Operators needed KPI tiles, a report canvas, and a natural-language path over accounting tables without one org reading another. We split the runtimes. NestJS owns JWT, RBAC, dashboards, query execution, reports, Tally upload. I owned the request isolation path: per-request transaction, SET ROLE, fail-closed to rls_no_access, policies from a generator. React is the SPA on CloudFront. FastAPI only proposes SQL with LangChain and gpt-4.1 at temperature 0. Nest executes SELECT on that transaction after a trim check and hasTableAccess. I inherited the chatbot after a teammate left. I prototyped structured JSON so the bot reused the report builder’s ElementRenderer. I also sent a large slice through client aggregation and crashed the browser — I moved that to the server and a click-to-load. Resume family I will not dump in one breath: 40% faster reports, 99.9% uptime, SQL-RAG +65%, Redis −35% bot DB, 30 dashboards +60%, sub-210ms, three-tier RLS. Pick the number that belongs to the question. We for the product. I for RLS, the inherited bot path, the renderer, the crash.”

Architecture

[SPA CloudFront] --REST/JSON-- [Nest ECS :5000]
                                  |  Jwt → RLS tx SET ROLE → services
                                  |-- dashboards (fixed SQL)
                                  |-- queryDB (joins, chat execute)
                                  |-- reports JSON
                                  |-- fileUpload Tally → S3
                                  '-- chat CRUD (executeWithoutRLS)
                    POST /chatbot  [FastAPI ECS :80]
                                  LangChain SQLDatabase allow-list
                                  ChatOpenAI gpt-4.1 t=0
                                  never executes tenant SQL
                               [Postgres RLS + Sequelize pool 20]

• Auth in this checkout: Bearer JWT, localStorage, refresh excluded from RLS middleware. Cookie MD is not the running file.
• Warehouse facts on req.dbTransaction. Chat metadata may RESET ROLE.

Technical decisions + trade-offs

• REST not GraphQL or Kafka — every browser feature is an HTTP resource; the sidecar is one POST.
• Propose vs execute — Python parser + Nest transaction, not ChatOpenAI inside Nest as owner.
• RLS in Postgres vs app WHERE only — a generated WHERE cannot survive RESET ROLE.
• Deterministic tiles vs bot — model cost stays off the morning KPI path.
• ECS vs Kubernetes — shipped orchestrator vs listed skill.
• Sequelize vs Prisma — this tree is Sequelize. Resume skills also list Prisma; I do not rewrite the intern.

Challenges / debugging

• Empty chart: log generated SQL — failed execute vs RLS zero rows vs no SQL returned.
• Admin with no SYSTEM role: old RESET ROLE leak class → rls_no_access.
• Client aggregation crash on a large slice.
• Docs vs code: finish-transaction, port 3000 vs 5000, CodeBuild slide vs Actions, Redis vs Map.

Scalability

• I did not shard Postgres. First limits: pool 20 vs RDS max_connections, indexes on filter columns, stop SELECT * on uncapped GETs.
• 10× QPS holds a transaction until finish — pool tests before more tasks.
• fieldsCache does not survive horizontal scale. Resume Redis is the shared-cache sentence.
• I do not invent autoscaling policies or a multi-region active-active.

What I would improve

• Shared Redis, tenant in the key; bust on warehouse load; no dashboard cache without tenant.
• Circuit breaker on FastAPI; measure tile p95; rollback FinishTransaction on 5xx.
• Secrets Manager; synchronize: false in prod-shaped deploys; CORS not * on the sidecar.

Probes

• Open queryDB.service.ts: show the trim check, the Map key, and org injection — then say injection is not isolation.
• ORG_A session, SQL that asks for ORG_B: zero rows, HTTP can still be 200. Permission denied is missing GRANT. 403 is hasTableAccess.
• Which tables use executeWithoutRLS, and why warehouse facts must never ride that path.

LP mapping — allowed primary (at most three): Ownership, Frugality, Dive Deep. Invent can use ElementRenderer reuse if the hour is still on Ylogx and IQVIA Hybrid is unused. Highest Standards can use the crash or “LLM is not a security control” if Argus already filled the hour. Do not make ConvBI six trophies.

90s spoken overview. “IQVIA, April 2026 to present — current intern. DeepQuery is a LangGraph deep-research CLI I built, not a hosted product and not the BRD processor. An analyst gives a topic. I plan, do a light search so clarification is grounded, optionally ask the human auto/hybrid/manual, generate a bounded 12 to 15 queries, fan out to DDGS, Bing, and Firecrawl, dedup URLs, then I score URLs before I scrape. We often aim to keep the scrape set in a 120 to 180 band. I scrape in waves with a concurrency cap, reason across pages, and a decision node either stops or loops. I synthesize a long markdown report. A strong saved run went 857 URLs to 120 filtered to about 137 pages. Some 0% confidence files still had pages — that was synthesizer JSON parse, not empty retrieval. I do not have an IQVIA percent on the resume. This workspace resume.md does not currently list IQVIA; I still own the walk. I for the graph. Local CLI, Azure OpenAI.”

Architecture

CLI main.py
  pre-clarify graph → HITL
  full graph (resume_from context_builder | url_intelligence)
    planner → light_search → clarifier → context_builder
    query_generator → search_fanout → aggregator
    url_intelligence → scrape_controller → cross_page_reasoning
    decision_engine ⇄ fanout | scrape
    synthesizer → responses/<topic_ts>/ artifacts
Azure OpenAI HTTP client    Firecrawl    DDGS    Bing HTML
No vector DB   No multi-tenant SaaS

Technical decisions + trade-offs

• LangGraph vs linear chain — parallel tools, retries, checkpoints, bounded cycles.
• Filter before scrape — cost bound vs missing a long-tail domain.
• HITL only at clarify and refine — not a human on 857 URLs.
• Char budgets vs completeness — decision node must stop.

Challenges / debugging

• 0% confidence with fat artifact folders → parse/save, not scrape.
• One engine timeout must not erase the others.
• elapsed_seconds may be missing from metadata — I do not invent wall clock.

Scalability

• Caps: queries, URLs per domain, scrape count, waves, workers, iterations.
• I did not operate a sharded research index. 10× topics is more runs, not a cluster I will invent.

What I would improve

• Hardened synthesizer parse + retry so confidence cannot go 0% after a good scrape.
• Cache completed scrapes by URL+content hash across runs.
• Persist elapsed time honestly. Still local CLI unless they ask a product conversation — then I say it is not shipped as SaaS.

Probes

• Draw the decision edges: stop / search_new / next_wave / follow_links.
• Name what is in a run folder without inventing a cloud bucket.
• What cheap signal would you add next — I do not invent a production spam-ML model I did not ship.

LP mapping — allowed primary: Learn and Be Curious. Second allowed if the hour stayed on IQVIA artifacts: Dive Deep (0% parse vs retrieval). Think Big (200+ sites / 857→120) is backup only — StratifyLabs is speak-first Think Big. Invent and Backbone belong to Hybrid RAG, not this card as a third trophy.

90s spoken overview. “Same IQVIA intern, different system. QA and BA people upload a BRD — 200+ page class on the lock — and need requirements and test cases they can inspect. I built a FastAPI pipeline: extract text, chunk at 1500 tokens with 200 overlap on cl100k_base, embed at 3072 dimensions in batches of 16, write Azure AI Search index brd-documents, extract requirements per chunk — that extract is the cost driver — analyze relationships, persist Neo4j Document, Requirement, Entity, DEPENDS_ON. Retrieval is hybrid BM25 plus vector kNN plus semantic reranker plus a 2-hop Neo4j walk. Test-case generation is a separate 5-node graph with asyncio.gather, not the ingest graph wearing a hat. Redis and Celery appear in requirements and are not wired; jobs are in-memory maps. I say that. No labeled precision/recall. 100MB upload cap. I for the graphs I can walk. We if I am speaking IQVIA as a team.”

Architecture

POST /api/v1/documents/upload  ≤100MB PDF/DOCX
   → BackgroundTasks → IngestionGraph (8 nodes, MemorySaver)
        extract → chunk → embed(16) → Azure upload(100)
        extract reqs (per chunk) → analyze → Neo4j MERGE
POST test-case job → TestCaseGraph (5 nodes)
        load reqs → hybrid_search → graph 2-hop → generate (gather)
Stores: Azure brd-documents  |  Neo4j KG  |  RAM jobs

Technical decisions + trade-offs

• Hybrid + reranker vs vector-only vs stuff-the-PDF.
• Graph hops vs stuffing dependency chunks.
• Two LangGraphs vs one mega-graph — ingest and tests are different jobs.
• In-memory jobs vs Celery — honesty over fashion.

Challenges / debugging

• Clause-ID miss on vector-only — the reason hybrid exists.
• Extract-per-chunk latency vs embed batches.
• Demo notes (separate story): DOM truncation made an agent click the wrong zoom — I raised DOM max chars and max elements 50→80. I do not hang an IQVIA percent on that demo.
• LangSmith traces; I still will not quote recall I do not have.

Scalability

• Chunk math: roughly ceil(T / (1500−200)). Extract scales with chunks, not pages.
• Process bounce loses job maps — that is the 10× lie if I claim a queue.
• Neo4j path cap 50; Azure upload 100. I did not shard.

What I would improve

• Wire Redis/Celery or any durable job store.
• A labeled clause-ID / dependency eval; keep LangSmith.
• Parallelize extract only with idempotent requirement IDs.
• Make /ready check Azure and Neo4j for real (docs: stub).

Probes

• Write the USING of hybrid vs a 2-hop Cypher in one sentence each.
• What happens if embed batch fails? One-by-one, then zero-vector fallback — I say the fallback is a retrieval defect I would watch.
• Where does MemorySaver die? Process restart.

LP mapping — allowed primary: Invent and Simplify, Backbone, Dive Deep (hybrid vs vector-only + 2-hop + eval honesty). Learn is DeepQuery’s speak-first. Do not also open this as Learn in the same hour with the same “I used LangGraph” sentence.

90s spoken overview. “February to June 2024 I was core software on Team Horizon’s ROS2 Mars rover for the European Rover Challenge. We designed a vehicle with cameras, compute, navigation, and control. I did not own the rover and I was not team lead. I engineered a GStreamer pipeline so the operator had a real-time multi-feed POV — resume 60 FPS — instead of raw frames through the app. I integrated the ZED 2 stereo camera as environment input — resume 2M+ point-cloud samples per second — into RViz, Gazebo, and the navigation conversation. I did not implement the predictive planner, the full costmap, or custom sensor fusion. We placed 17th of 80+ on the resume. Public Horizon materials sometimes say about 18th and number one in India. I flag that. Resume also has +40% obstacle detection and −55% simulated collisions. I treat +40% as weak — compared to other video-feed tools in our notes, not an Argus mAP. We for the rover and the place. I for video and ZED.”

Architecture

Cameras → GStreamer [capture → encode → tx → decode → display]
ZED 2 SDK → point cloud / spatial map → RViz / Gazebo
          → environment input into team navigation / costmap
I did not write: predictive planner, full costmap, custom fusion
Jetson-class compute (team stack)   ROS2

Technical decisions + trade-offs

• GStreamer vs raw frames — tunable stages vs a simple socket that dies on the field.
• Vendor ZED mapping vs writing stereo from scratch — time-to-ERC vs full ownership of depth.
• I vs we on planner — I keep the boundary even if it makes the story smaller.

Challenges / debugging

• Field: pipe is only useful if the next software member can bring POV up — pairing story, not a mentee count.
• Layers must agree: ROS2 frames, media timestamps, stereo cloud. That was the learning jump.
• Place discrepancy 17 vs ~18 — I do not fight the interviewer.

Scalability

• More cameras are more GStreamer branches, not a data-center story.
• I do not claim Kubernetes on the rover. I do not claim I optimized a planner I did not write.

What I would improve

• Stage-level latency (capture-to-display) so 60 FPS has a definition.
• Align the public place with the resume source of record.
• Document the pipe so launch pairing is not tribal knowledge.

Probes

• Name the five GStreamer stages and which one you would turn first if the operator saw delay.
• “Walk me through your planner optimizations” — I stop. That work is not mine.
• Who brings the POV up if you are not in the tent? Pairing, not a mentee headcount.

LP mapping — allowed primary: Bias for Action, Deliver Results, Earth’s Best Employer. Ownership and Learn are backups (boundary; layers must agree). Do not absorb planner credit to make Deliver louder.

90s spoken overview. “Argus is my industrial safety project — YOLOv9 PPE-compliance. I had a model that drew boxes at 73% mAP. That is a slideshow result. It is not a floor product. I did not ship it and I did not scale cameras on it. I went back to data and training on 15,000+ images until I had 89% mAP at 24 FPS. Only after that gate did we Dockerize a multi-feed pipeline for 20+ cameras, write structured detection events to Postgres, and alert. The resume’s pilot says recorded violations dropped 50% after alerts. I need the incident definition if you press that number. I vs we: I for the detector gate and the refuse-to-ship. We once the feeds and alerts were a deployment. This is not a hackathon demo I will relabel as Amazon PPE policy.”

Architecture

camera frame → OpenCV decode/resize
             → YOLOv9 one-stage boxes/classes
             → confidence filter → NMS
             → event {camera, class, confidence, timestamp, box}
             → Postgres → alert
video bytes  → not in the relational event table
Docker multi-feed  20+ streams after 89% / 24 FPS gate

Technical decisions + trade-offs

• One-stage YOLO vs two-stage — 24 FPS across many feeds vs a prettier clip on one recording.
• Quality gate then width — 73% times 20 cameras is alarm fatigue.
• Postgres events vs video-in-DB vs files-only.
• OpenCV stays decode/resize. TensorFlow is a skill; the resume detector is YOLOv9.

Challenges / debugging

• Treating 73% as progress toward launch — that was the mistake I will own.
• Lighting and PPE variation as data coverage, not “swap architecture first.”
• NMS too aggressive can merge two nearby workers.
• Public API README is unavailable — I do not invent route names.

Scalability

• Width is camera count after the gate. I do not claim Kubernetes or detector sharding.
• 10× retention: revisit indexes and media policy. No retention SLA on the resume.
• Drop stale frames if a camera falls behind — I defend the 24 FPS budget, not a new FPS I invent.

What I would improve

• Class-wise precision/recall and a held-out camera — not claimed as shipped.
• Ask the floor what miss is acceptable; I do not import 89% as Amazon’s PPE SLA.
• Keep media in object storage conceptually; I do not invent an Argus bucket name.

Probes

• If I already used Argus for Are Right this hour, Highest Standards must not open with the same 73% sentence — use the gate-before-width sentence or switch project.
• What would you do if Amazon’s miss budget is different? I ask; I do not import 89%.
• Draw detect → persist → notify and say where video lives.

LP mapping — allowed primary: Are Right, A Lot; Insist on the Highest Standards; Success and Scale. Are Right = I changed my mind about 73%. Standards = 89% and 24 FPS before width. Scale = cameras after the gate. Do not open both Are Right and Standards with the same first sentence in one hour.

90s spoken overview. “I built GiftedBooks as a VR learning suite at giftedbooks.study. I — not a company intern. The student I designed for was stuck in a study loop: find what the exam actually uses, read it, get stuck, wait hours for a human. I did not start from ‘put an LLM in VR.’ I split two jobs. One: the student uploads their PDF; I chunk and embed once with user and document metadata; at question time I retrieve a small scoped set and answer from those chunks. Resume API path is sub-300ms — that is retrieve-and-answer, not proof the derivation is faithful. Two: a PYQ topic-prioritization engine as deterministic analytics over past papers, not the model guessing the exam. Those sat inside 3D labs and avatars so the student stayed in one place. User testing we reported: doubts from hours to a 3–10 minute window, +35% reading efficiency, +50% engagement, 2.5× comprehension, 99.5% uptime. I do not invent sample size. The GitHub README on that repo currently describes AegisAI. Resume and the site win. I would fix the README. I do not import Aegis features into this story.”

Architecture

student → auth → upload PDF
        → chunk / embed once → vectors + user/document metadata
question → scoped top-k → grounded answer  (resume sub-300ms API path)
PYQ papers → deterministic topic ranking   (separate path)
VR labs + avatars → one environment
Isolation: no cross-user retrieval
Vector lane: skills-line FAISS / vector+metadata — I do not invent a cluster
Not Azure Search (that is IQVIA)   Not LangSmith on this resume

Technical decisions + trade-offs

• Grounded RAG vs generic ChatGPT wrapper — trust vs fluency.
• Ingest once vs whole-book prompt every question — hits sub-300ms and isolation.
• PYQ as analytics vs LLM syllabus prediction.
• VR as place-you-stay vs VR as the product slogan.

Challenges / debugging

• README mismatch with AegisAI — Earn Trust is saying it before they find it.
• Too-small chunk loses a derivation; too-large misses latency and isolation.
• Latency ≠ faithfulness. I say that if they treat sub-300ms as quality.

Scalability

• 10× PDFs per user: ingest-once and metadata isolation stay. Bound top-k. I did not shard. Resume has no student headcount.
• 99.5% is GiftedBooks. 99.9% is Ylogx. I keep them separate.

What I would improve

• Citation eval / LangSmith-style traces — would-add, not did.
• Fix the GitHub README.
• Lock sample size and instrument for the user-testing percents so I can defend N.

Probes

• What happens if two students upload the same textbook? Metadata still scopes retrieval. I do not mix notes.
• Show me the protocol behind +35% / +50% / 2.5×. I say I will pull N — I do not mint it.
• Why VR at all? Place to stay, not the mechanism that collapsed doubt time.

LP mapping — allowed primary: Customer Obsession, Earn Trust, Think Big. Think Big only if Customer did not already spend GiftedBooks this hour — and even then the angle is “learning system,” not a second 3–10 minute recitation. Do not also use GiftedBooks for Invent if ElementRenderer or Hybrid RAG already filled it.

90s spoken overview. “I built StratifyLabs at stratifylabs.design as a browser computer-vision lab. I — personal product, not an intern. The pain was iteration: a notebook or a native simulator per person turns every small experiment into environment setup or a GPU queue. I put a 3D simulation lab in the browser with a URDF editor and WebGL. Small supported models infer in the tab so a camera move can be checked without a server round-trip. Resume: that cut ML iteration time 30% — iteration time, not FPS. I shipped a marketplace with 50+ pretrained models and datasets so the next experiment starts from a catalog item, not a retrain. Gemini-powered RAG voice characters sit on current scene context. Big training stays off the click path. The current GitHub README looks like a Next.js scaffold. Resume and the site win. I would align the repo. I do not claim 50 GPUs or a user-growth number.”

Architecture

Web client
  → WebGL scene + URDF editor
  → small browser inference → immediate iteration
  → marketplace catalog (50+ models / datasets)
  → Gemini voice bot grounded in current scene / URDF
heavy training → off the interactive request path
Not Horizon Gazebo   Not Ylogx RLS   Not Argus 24 FPS

Technical decisions + trade-offs

• Browser inference vs notebook-per-user vs native-only lab.
• Marketplace reuse vs everyone trains from scratch.
• Scene-grounded Gemini vs a generic chatbot.
• Three.js is a skill; the resume claim I defend is URDF + WebGL + the lab.

Challenges / debugging

• Large models exhaust tab memory — they belong off the click path.
• Stale scene context makes the bot describe objects that no longer exist.
• README scaffold vs resume — same Earn Trust pattern as GiftedBooks.

Scalability

• Grow the catalog. Keep only suitable small inference in the tab.
• I do not invent cluster capacity, user count, or LangSmith usage.
• karyanode is a separate GitHub module and does not inherit these outcomes.

What I would improve

• Current-scene eval for the voice bots.
• Align the repository README with the product.
• User isolation — I state the need; I do not import Ylogx RLS as if it shipped here.

Probes

• What happens if someone loads a huge detector in the tab? I move it off the click path. I do not invent a WASM benchmark.
• How would you stop the bot answering last week’s scene? Pass current scene graph; add an eval I did not ship.
• If Invent already used Hybrid RAG, this is Think Big, not a second “I reused a renderer” story.

LP mapping — allowed primary: Think Big. Invent and Simplify is allowed as a second only if IQVIA Hybrid RAG and Ylogx ElementRenderer were not already the Invent story this hour. Learn is backup (browser-inference curiosity), not a third trophy against DeepQuery.

Which PDF. This workspace resume.md has Aegis AI: geofenced SOS, AI-optimized routing to nearest help centers and hospitals, real-time location tracking, 24/7 voice-to-report, 60% faster crime-report submission and 40% faster emergency-response initiation in simulated testing. ResumeWithSummarySep2026.pdf may omit the project — if they open that PDF I do not invent Aegis into the page. GiftedBooks GitHub currently describes AegisAI; that is a README mix-up, not proof the two products are one. I never blend GiftedBooks VR/PYQ into Aegis.

90s spoken overview. “I built Aegis AI as a personal-safety mobile app — I, not an intern team. The user is a person who needs to call for help and file what happened without losing minutes to a form. I shipped geofenced SOS alerts, routing toward nearby help centers and hospitals, and live location. I added a 24/7 voice-to-report path so the report is spoken rather than typed under stress. In simulated testing we reported report submission time down 60% and emergency-response initiation time down 40%. Those percents are simulated-testing results on resume.md. I do not invent a city deployment, a user count, or a live 911 integration I cannot walk. If your PDF does not list Aegis I will not force it.”

Architecture

mobile client
  → geofence / location stream
  → SOS trigger → notify configured path
  → routing toward nearest help / hospital  (resume: AI-optimized)
  → voice-to-report → structured report
simulated testing: −60% report submit, −40% response initiation
I do not invent: carrier integration, map-provider SLA, model id

Technical decisions + trade-offs

• Voice-to-report vs a long form under stress.
• Geofence SOS vs always-on recording — I do not claim a surveillance product.
• On-device vs server routing — not locked; I will not mint a stack. If they grind, I say what is on resume.md and what is missing.

Challenges / debugging

• Evidence is thinner than Ylogx or Argus. A Bar Raiser can empty this in two probes. I redirect to a deeper project if they want mechanisms.
• README collision with GiftedBooks — I say it first.
• 60% / 40% are simulated testing. I do not upgrade them to a city pilot.

Scalability

• Not locked: shard, queue, map QPS. I do not invent them.
• Safety products fail closed on location permission and false SOS — I can discuss as standard CS, not as a shipped SLA.

What I would improve

• Lock the stack (maps, voice STT, geofence implementation) so this card can survive a deep dive — or drop Aegis from the spoken hour if the PDF they hold omits it.
• Separate the GitHub README from GiftedBooks.
• Keep simulated-testing language every time I say 60% / 40%.

Probes

• They open ResumeWithSummary and Aegis is gone — I do not volunteer the md-only percents.
• They open GiftedBooks GitHub — I separate the products immediately.
• They ask for a sequence diagram with provider names — I stop at resume nouns.

LP mapping — not speak-first on the 8-LP spread. Allowed only as a backup if they pull personal safety: Customer Obsession (person in the SOS loop) or Bias for Action (ship a narrow SOS path). Do not use Aegis as primary for Deliver Results (Horizon 17th owns that) or Highest Standards (Argus owns that). If the hour already used GiftedBooks for Customer, do not also open Aegis as Customer.

What is locked. Resume achievements: 8 national and regional hackathons. Named placements: CodeRecet 1st, MLH Best Project, Magnathon 2.0 runner-up (IEEE). IEDC Tech Team member is a different card — pairing, not these prizes as a coaching program.

Gap — mark it. I do not have a locked technical walk for even one of those eight: not the problem statement, not the stack, not a decision, not a metric, not a teammate name. I will not invent a CodeRecet architecture in the room. If they ask “tell me about a hackathon,” I give placements in one sentence and either (a) ask to use a locked project with the same flavor or (b) say I need to lock one concrete before I deep-dive. Inventing a weekend stack is how I fail Earn Trust.

90s spoken overview — honest, short. “Across campus I competed in eight national and regional hackathons. The named results on my resume are first at CodeRecet, Best Project at Major League Hacking, and runner-up at Magnathon 2.0 with IEEE. Those are my placements. I will not convert them into a mentee program and I will not invent a product walk I have not locked. If you want a weekend-speed decision I can speak Horizon’s ERC date — we fused on sensors we had — or Argus refusing to ship 73%. If you want Customer from a student product, GiftedBooks is locked. I owe myself one concrete hackathon memo; I do not have it in this book today.”

Architecture

LOCKED:   8 hackathons | CodeRecet 1st | MLH Best Project | Magnathon 2.0 runner-up
NOT LOCKED: problem, repo, stack, role split, demo URL, metric, teammate names
DO NOT DRAW a fake architecture box

Technical decisions + trade-offs

• None locked. Decision I will make in the room: do not fabricate.
• Bias for Action on the lock is Horizon ERC date, not “we won because we hacked harder.”

Challenges / debugging

• The challenge is the gap itself. A Bar Raiser who says “walk me through CodeRecet” should hear the gap in ten seconds, then a redirect.

Scalability

• Not applicable. I do not scale a story I did not write.

What I would improve

• Before the hour: lock one concrete — CodeRecet preferred because it is 1st — problem, my modules, one decision, one failure, no new percent unless it is already on a certificate I can show.
• Keep IEDC pairing separate. Keep the eight placements as results, not coaching.

Probes

• They pick one prize and stay there — I repeat the gap; I redirect.
• They try to use hackathons as Hire and Develop — I refuse the conversion.
• After I lock a memo, I replace this card; I do not silently grow details here.

LP mapping — allowed primary: none until a concrete is locked. Backup only: Bias for Action (second story after Horizon). Do not use as Hire and Develop, Deliver Results (Horizon 17th), or Invent. Earth’s Best / IEDC pairing stays off this list.