14. Why this stack — mechanisms, follow-ups, honest 10×

The obvious RAG is a vector index and a demo. Two-hundred-page BRDs have clause IDs, table names, and annexes. Cosine returns similar “retention” paragraphs and misses R-141. Hybrid means lexical plus semantic in one retrieve. Lexical catches the ID. Semantic catches “what is the policy.” Semantic ranking on Azure is the second-stage reorder, not a second product I will invent. I did not use Qdrant. I did not train a private embedder. Stuffing the PDF into one prompt dies on tokens and invents citations. Hybrid retrieve a small set of chunks. Cite or abstain.

query
  → Azure hybrid (lexical + vector)
  → semantic rerank (small set)
  → GraphDB hop if the question is a dependency
  → writer: overlapping span or abstain

Follow-up: why Azure and not “another vector DB”? The intern path is Azure AI Search as named. Hybrid and semantic are product features I can defend. Switching the story to Qdrant or a blog Pinecone is how you fail the next sentence. Confidential BRDs stay in the cloud the job already used. Credentials in env or a secret store, not in traces.

Follow-up: hybrid versus semantic — are they the same? No. Hybrid is lexical plus vector retrieval. Semantic ranking reorders the retrieved set. Adaptive retrieval in LangGraph chooses lexical versus semantic versus a graph hop instead of always embedding. That is the Invent card, not three synonyms for RAG.

Deep Research is coverage and contradiction across more than two hundred websites. A linear LangChain chain cannot retry a dead scrape, fan out four tools, or checkpoint state. LangGraph gives nodes, state, and edges. A planner fans Firecrawl, Bing, DuckDuckGo, and Google Playwright. Parallel writes go into graph state. A failed scrape retries or degrades instead of restarting the run. A ranker scores quality, recency, and agreement. A writer synthesizes. Two high-ranked pages that contradict each other is the hard part — first-hit retrieval looks confident. I rank by agreement and refuse a span-less sentence.

planner → [Firecrawl | Bing | DDG | Playwright]
       → rank (quality, recency, agreement)
       → writer
state checkpointed; empty scrape does not feed the writer silently

Follow-up: what is state? The working set for one research run: URLs attempted, scrape text or failure, rank scores, citations reserved for the writer. It is not a chat log I dump into the next LLM call. If LangSmith shows empty scrapes still feeding the writer, the edge into the writer is wrong — that is an orchestration bug, not a smarter prompt.

Follow-up: why LangGraph versus “multi-agent” as a slogan? Multi-agent without a graph is still a pile of calls. The product is retries, parallel tools, and a ranker. Agents that wander two hundred sites without a ranker are curiosity without a stop condition. Learn and Be Curious on this resume is the graph plus LangSmith pass/fail.

Requirement documents are not a bag of paragraphs. “What else breaks if this clause changes” is a graph. Cosine similarity does not hop. A GraphDB hop is cheaper than another generation when the question is relational. Example: FR-214 requires wet ink; three test cases hang off it. Vector-only retrieves “signature” annexes. The hop returns dependents. I will not invent a node count. I will not say Neo4j ops I did not run. The resume claim is GraphDB hops on 200+ page BRDs alongside Azure hybrid.

Follow-up: GraphDB versus Azure hybrid — who runs first? Adaptive retrieval chooses. Lexical if the query looks like an ID. Semantic if it looks like policy language. Hop if it looks like a dependency. Always-embed is the discarded default. Always-hop is also wrong — not every question is relational.

A fluent paragraph can have no overlapping span with retrieved chunks. A generated test case can come from the wrong section. LangSmith is how we see query, retrieval set, tool order, and answer. Gold questions with expected citations. Fail if there is no overlapping span. Test-case generation is itself a traced job; humans spot-check a sample. I will not log full BRD text in traces in production. Secrets stay out of traces. I will not steal LangSmith onto Ylogx or GiftedBooks as a shipped claim. Ylogx eval is SQL shape plus denied-tier fixtures. GiftedBooks does not claim LangSmith; I would add a small citation eval — would, not did.

LangSmith: query → chunks → answer
fail if no overlapping span
empty scrape must not reach the writer

Follow-up: verify GenAI code / not blind trust IE-asked LC 8014509; Vaishali. Compile and run. Check bounds. Models miss RLS. Fluency is not correctness. If the same hour pastes LCA or Next Greater, I write the algorithm first. If the invite said Fluency and they paste Distance K, I write the tree first — LC 7623949. One IQVIA sentence after code only if they still ask.

RBAC is what the role can do: read reports, run the bot, admin a tier. RLS is which rows the database will return even if the handler is wrong. JWT or session at the API proves who you are. Execution of generated SQL is as the user’s database role, not as a service superuser. App-only WHERE org_id = ? fails the moment someone writes a JOIN or the model asks for a table the UI never showed. NestJS can still enforce route-level RBAC so you do not even hit SQL for a forbidden verb. That is defense in depth, not two names for one check. I will not ship the bot on a service-role connection string.

API: JWT → map to DB role (RBAC: can this user query?)
Postgres: SET ROLE tenant_user;  -- RLS: which rows exist for this role
JOIN still filtered; pg_catalog denied; SQL parameterized, timed, row-capped

Follow-up: why both, not just RLS? RLS does not decide whether you may hit /admin/export. That is an API concern. RBAC does not survive a generated JOIN if the connection is superuser. Different layers, same three tiers.

Follow-up: XSS / CSRF / CORS in one breath Standard CS plus Ylogx. XSS is script in the page. CSRF is the browser using an existing cookie. Parameterized SQL always, including LLM-generated SQL. CORS is browser-enforced; curl does not care. Isolation still lives in Postgres.

Every natural-language turn hitting Postgres made latency feel like the model thinking when the database was the cost. Repeat questions and schema metadata are cache-shaped. A bigger RDS is the wrong first spend. I put Redis on the hot bot path. Cache-aside: miss, query as the RLS role, set, return. The cache does not skip RLS. Key includes tenant or role plus query fingerprint, not raw NL. Redis down: fail-open to Postgres for analysis availability; never fail-open RLS. Result: minus 35 percent bot database latency. I will not invent a TTL or a p95.

Follow-up: invalidation without a TTL story. The resume does not detail TTL. Honest answer: a cached answer is wrong when the underlying facts for that tenant change. I would version the fingerprint with a data version or invalidate on report rebuild. I will not quote a number I did not write down. The number I defend is minus 35 percent.

Thirty KPI dashboards, Recharts, sub-210 milliseconds, plus 60 percent ops efficiency. That path is REST plus cache plus Postgres aggregations. An LLM on every tile is tokens, tail latency, and invented numbers. SQL RAG is the chatbot path: natural language to SQL behind RLS, plus 65 percent analysis productivity. Frugality is also “do not put a foundation model on the hot path.” Deepak-style “highest KFC orders last three months”: do not dump ninety days of rows into a prompt. Pre-aggregate in SQL; the model returns SQL or explains the result. If they want an in-memory top-K, that is a heap — DSA, not GenAI.

Dashboards: Browser → CloudFront → ALB → ECS → Postgres/cache    (no LLM)
Chatbot:    NL → Redis (tier-scoped) → SQL RAG → Postgres as user role

Follow-up: then why have a chatbot at all? Non-technical users could not pull analysis without an analyst. The bot is for ad-hoc questions that are not a tile yet. Tiles cover the thirty KPIs operators already need. Different jobs. A chatbot that is slow or leaky is not the tile replacement. Isolation and cache made the bot trustworthy enough to claim plus 65 percent.

Argus needs bounding boxes at 24 FPS on more than twenty camera feeds. YOLO is one-stage: predict boxes and classes in one network. Two-stage detectors (propose, then classify) are typically more accurate and slower. At this camera count, a model that cannot hold 24 FPS is not “more right” — the floor does not pause for your batch size. 73 percent mAP was already the wrong ship bar; a heavier backbone that drops FPS would have been a second wrong bar. Convolution shares weights and is translation-equivariant; that is why a small kernel beats a fully connected layer on images. mAP averages precision across recall and classes. IoU is overlap. NMS drops duplicate boxes. I will not invent precision and recall beyond mAP. I will not invent Haar as a first attempt. OpenCV decodes and resizes. Video stays off Postgres; events go in.

Follow-up: 10× cameras. Do not run twenty copies of a fatter model if 24 FPS breaks. Workers per stream or batch. Postgres for events, not video blobs. I would add a per-camera error budget — the resume does not state it; I say would. Gate remains 89 percent mAP and 24 FPS before more cameras. I did not claim EKS. Argus was containerized feeds. Ylogx is the ECS story.

Horizon needed a live operator feed at 60 FPS on a rover that also mapped. A Flask MJPEG or naive TCP webcam drops frames in the field. GStreamer is a pipeline: capture, encode, payloaded UDP-family transport. UDP is not reliable; that is the point — loss versus latency. TCP will stall the operator to retransmit. ERC is not a file upload. Public Gstreamer-UDP is a webcam analogue in the same family, not a second resume project and not extra metrics. Horizon is video infrastructure and mapping, not Argus YOLO. Do not steal 24 FPS into this story. This rate is 60 FPS camera.

Follow-up: why not send the full ZED cloud to a laptop? More than two million points per second cannot all leave the rover. Downsample for RViz. Keep density for the local costmap. Streaming the full cloud melts the link. That is Frugality on student hardware, not a cloud GPU bill I will invent.

ERC is localization, planning, and comms. ROS2 is the integration bus. A weights file is one node. OpenCV blob-only is not how plus 40 percent obstacle detection happened. Bump-and-turn is not how minus 55 percent collision happened. Extra sensors as the first move is delay dressed as prudence — the date does not wait on a purchase order. Costmap path planning plus sensor fusion is occupancy over time. Predictive fusion on the ZED 2 we had. Gazebo lighting is not dirt. The ship-blocker was stale occupancy: operator feed looks live, planner sees last second’s rocks. Debug is three clocks: GStreamer pipeline latency, ROS2 callback, ZED rate. We fused instead of buying another unit the week of the contest.

ZED 2 → point cloud → costmap
Camera → GStreamer 60 FPS → operator / autonomy
Sensors → fusion → planner → actuators

Follow-up: why ROS2 versus a single Python script? Separate nodes for perception, mapping, planning, comms. Time sync and launch order are the product. A solo notebook does not place 17th of more than eighty. Sharing launch files is Hire and Develop / Earth’s Best on a student team — no mentee count.

NestJS: modular TypeScript for auth, RBAC, report CRUD, dashboard APIs. FastAPI: Python for SQL RAG next to LangChain. Postgres: joins, aggregations, transactions, RLS — the warehouse. Redis: cache, not the system of record. Mongo is a skill, not the Ylogx warehouse. GraphDB is IQVIA BRDs. FAISS is a skills-list vector store, not this BI. I did not rewrite Ylogx in Spring. I did not shard. Kubernetes is on the skills list; I was not platform owner of a cluster. The defensible path is Docker plus ECS plus CloudFront plus CI/CD. REST for thirty KPIs; I will not invent a GraphQL tree or a WebSocket bus the resume does not name.

Local-only inference made every experiment a machine problem. Browser inference dropped ML iteration 30 percent. Marketplace of more than fifty models and datasets. URDF plus WebGL so people who are not ROS experts can still prototype. Gemini RAG bots are scene-conditioned, not a generic chatbot beside a canvas. GitHub README is default Next.js — resume wins. Do not merge Horizon Gazebo into this lab. Think Big is reusable experiment, not a TAM I will invent.

A definition in a table on page forty must come from that table inside the latency budget. Dumping the whole PDF misses grounding and sub-300 milliseconds. Retrieve plus a small generate. Embed once per PDF; do not re-embed on every question. PYQ topic ranker is deterministic analytics, separate from the generator — honesty about what exams ask, not an LLM guessing the syllabus. 99.5 percent uptime is hosting, not a model trick. Resume only; not AegisAI.

If they push “how would you design this at Amazon scale”: I say what I actually shipped, then the next honest increment. I did not operate Kafka. I did not shard Ylogx. I did not run EKS as a Ylogx claim. HLD of Amazon retail is not the SDE I UTA default — do not spend the hour on load balancers as a product. Ylogx already has an ALB. That is the intern serving path, not a textbook.

Amazon’s loop language is Java. Ylogx and IQVIA shipped Python and TypeScript. Horizon was ROS2. HashMap, heap, and graph-of-nodes ideas transfer. I did not pretend the internships ran on the JVM. I can sketch RLS as a SQL role in any language and then write the Live Code problem in Java.