14. Why this stack — mechanisms, failure modes, honest 10×

1. Why LangGraph instead of a linear LangChain chain? Resume-derived

Mapping. Exact resume hook: IQVIA LangGraph Deep Research, stateful agent orchestration, and ranked research across 200+ websites. The architecture/Frugality prompt reported by another candidate is LC 7981646; that candidate’s loop may differ, and this is not a Job 10454435 forecast.

Problem without it. Deep Research is not one model call followed by one scraper. A linear sequence loses useful Bing results when Playwright fails, cannot fan tools out safely, cannot loop retrieve → grade → retrieve, and cannot resume a long run from workflow state.

Alternatives considered. I considered a one-shot prompt, a sequential plan → scrape → write chain, and a home-grown loop with one mutable dictionary. Those shapes can demo the happy path, but they do not isolate retries, parallel updates, bounded cycles, or resumable work.

Why not the alternative; precise failure. A sequential chain is a linked list of side effects: the Playwright timeout either aborts everything or leaves half-mutated global state. It also has no explicit edge for a citation failure to return to retrieval. A giant prompt fails before orchestration even starts because neither 200+ sites nor 200+ pages fit as reliable evidence.

Do not use GenAI for. The model may plan and synthesize cited evidence; it must not decide authorization, silently convert a failed scrape into a fact, or keep looping merely because its prose still sounds plausible.

Honest 10×. Cap fan-out, cache completed scrapes, prefer snippets when a full render adds no value, and resume from checkpoints when one domain fails. That is more of the mechanism that already worked. I did not operate a sharded research index and have no IQVIA latency percentage to quote.

Concrete example. Bing has already returned evidence for REQ-1044 when Playwright times out on a JavaScript-heavy page. The checkpoint retains the Bing documents, retries only that branch, then the ranker compares all survivors instead of restarting the run.

1 — Isn’t LangChain enough? LangChain provides tools and chain patterns, but this run needed parallel branches, retries, checkpoints, and cycles, so I used LangGraph.
2 — What is state? It is typed workflow data such as query, documents, ranks, answer, and errors; nodes return partial updates rather than mutating an opaque transcript.
3 — What is a checkpoint? It persists workflow progress after a node so one failed branch can resume without erasing completed branches; I do not claim a private storage topology.
4 — Can it loop forever? No: retrieve → grade → retrieve has an explicit maximum iteration count and otherwise escalates or abstains.
5 — Did you ship a human-in-the-loop console? Checkpoints make review and resume possible, and humans spot-check generated tests, but I do not claim a separate console absent from the resume.
6 — Why not one mega-prompt? It has no robust coverage, retry boundary, ranking stage, or citation gate for 200+ sites and pages.
7 — Could the same idea be implemented in another language? Yes, nodes, state, reducers, and retry edges are language-independent; that does not turn the shipped agent into a different production stack.
8 — Was the Ylogx chatbot also LangGraph? No; Ylogx was LangChain SQL RAG, and claiming otherwise would merge two distinct systems.

2. Why Azure AI Search Hybrid + Semantic instead of vector-only search or stuffing the PDF? Resume-derived

Mapping. Exact resume hook: IQVIA Hybrid RAG Agent using Azure AI Search (Hybrid + Semantic), GraphDB, and LangGraph on 200+ page BRD/PDF documents. No first-hand source names this as a Job 10454435 live question.

Problem without it. BRDs contain clause IDs, table names, headings, policy paraphrases, and dependencies. Vector-only retrieval can miss exact identifiers such as R-141 or REQ-1044, while stuffing the document into a prompt exceeds useful context and produces confident citations to the wrong annex.

Alternatives considered. The discarded shapes were whole-PDF prompting, local vector-only FAISS, a keyword-only index, and operating another vector database. FAISS is on the skills line, not the IQVIA production bullet; Qdrant was not the shipped system.

Why not the alternative; precise failure. Whole-PDF prompting has no stable retrieval boundary and can cite a nearby but wrong section. Vector-only FAISS can rank a generic “retention” paragraph above the exact requirement token. Keyword-only retrieval misses a paraphrase. Naming an unshipped vector database would create an operations story I cannot defend.

Do not use GenAI for. Generation cannot repair a missing gold clause. If retrieval has no supporting span, the system must abstain rather than ask a larger model to invent connective tissue.

Honest 10×. Index once, retrieve a small set, bound graph hops, and expand the frozen eval slice before adding another retrieval mode. I did not re-embed the BRD on every question, and I do not claim an index-sharding design or a cloud bill.

Question: "What does REQ-1044 require?"
  → lexical + vector hybrid retrieval
  → Azure semantic rerank
  → optional dependency hop
  → 5–20 evidence chunks
  → cited answer or abstain

Concrete example. “REQ-1044” should survive because of its exact token, while “how long must these records be kept?” can surface the same clause through semantic ranking. A vector-only result from a similarly worded annex is rejected when its citation ID is wrong.

1 — Hybrid versus Semantic? Hybrid combines lexical and vector retrieval in one query; Semantic is Azure’s reranker over candidates, so the two stages solve different failures.
2 — Why not FAISS? FAISS is a listed skill, while the exact internship evidence is Azure AI Search; vector storage alone does not solve rare clause-ID recall.
3 — Did you use Qdrant? No, and I would not replace the resume’s Azure + GraphDB stack with it in an answer.
4 — Did you train the embeddings? I do not claim a private embedder; the resume claim is the managed Hybrid + Semantic retrieval architecture.
5 — How many chunks reach the writer? A deliberately small set, conceptually about 5–20 rather than 200 pages; I do not invent a token invoice.
6 — Did GiftedBooks use Azure too? No; GiftedBooks is the student-PDF RAG lane, while Azure + GraphDB belongs to IQVIA.
7 — Was this a multi-tenant BRD SaaS? The resume does not say that, so I do not import Ylogx’s JWT and RLS model into IQVIA.
8 — What latency SLA did IQVIA have? None is printed on the resume, so I do not borrow Ylogx’s sub-210 ms or GiftedBooks’ sub-300 ms.

3. Why GraphDB dependency hops instead of increasing vector top-k? Resume-derived

Mapping. Exact resume hook: GraphDB inside IQVIA Hybrid RAG for 200+ page BRD/PDF processing. Neo4j appears on the skills line; the internship bullet itself says GraphDB, so I do not invent a named production cluster.

Problem without it. “What changes if this requirement changes?” is a relationship query. Cosine similarity returns similar prose, not necessarily the requirements connected by a dependency edge, so generated tests can be attached to the wrong section.

Alternatives considered. I considered vector-only retrieval, keyword-only retrieval, stuffing more chunks into the writer, and flattening all relationships into a prompt or recursive query. Each loses the explicit meaning of a dependency.

Why not the alternative; precise failure. A larger vector top-k returns more semantically similar prose but still cannot guarantee a DEPENDS_ON relationship. More chunks increase distraction and can make the model attach a test to the wrong annex.

Do not use GenAI for. The model may explain retrieved dependencies, but it should not hallucinate an edge that does not exist or expand the graph without a hop bound.

Honest 10×. Keep the hop depth bounded, add indexed nodes as BRDs grow, and freeze expected dependency/test cases before adding retrieval complexity. I did not operate or shard a named graph cluster.

REQ-1044 --DEPENDS_ON--> REQ-880
    |                         |
 Azure text               Azure text
    +----------- cited answer -----------

Concrete example. Search first anchors REQ-1044. The question “what breaks if REQ-1044 is removed?” walks its dependency edges to REQ-880; increasing vector k would instead return other paragraphs that merely use similar policy words.

1 — Why not a bigger vector k? Bigger k adds similar prose but does not follow an explicit dependency edge.
2 — Was it Neo4j? Neo4j is on the skills line; I call the internship component GraphDB and do not fake a cluster diagram.
3 — What is a hop? It starts at the matched requirement, walks a bounded dependency edge, and retrieves the neighbor’s supporting text.
4 — Could SQL model the graph? Recursive SQL can express some trees, but the resume architecture used GraphDB beside Azure Search, and I keep that mapping.
5 — What about cycles? I cap hop depth and track visited nodes so cycles do not expand indefinitely.
6 — Do you still use semantic ranking after a hop? Yes; the graph supplies structure, while hybrid/semantic retrieval still ranks text for citation.
7 — What fails in test generation without the graph? A generated test can hang from the semantically closest section rather than the requirement it actually depends on.
8 — What changes at 10× BRDs? I grow indexed nodes and the frozen dependency eval slice before I add another tool; I do not start with sharding theatre.

4. Why LangSmith when the generated answer already sounds fluent? Resume-derived

Mapping. Exact resume hook: IQVIA stateful orchestration, evals, test-case generation, and LangSmith tracing. “Validate AI-generated code; do not trust it blindly” was reported by another candidate; that loop may differ.

Problem without it. A generated paragraph and a generated BRD test can look professional while citing the wrong section. Without node traces I cannot tell whether the ranker chose badly, an empty scrape reached the writer, or the writer ignored good evidence.

Alternatives considered. I rejected “it sounds good,” English BLEU as a citation gate, manual review without gold references, and logging entire confidential documents. Those alternatives either test style instead of grounding or create a new data-leak risk.

Why not the alternative; precise failure. Fluency accepts an answer whose only input was an empty scraper body. BLEU can reject a correctly paraphrased, correctly cited sentence or accept polished text from the wrong clause. Full-document logging can leak the BRD while trying to observe it.

Do not use GenAI for. A model should not grade its own grounding without structured evidence, approve confidential logging, or replace the human spot-check on generated tests.

Honest 10×. Expand a frozen, representative gold slice, store trace IDs and chunk IDs rather than raw annexes, and diagnose retrieval before adding tools. I do not claim a LangSmith bill, dataset size, or pass-rate percentage.

Concrete example. A gold item for REQ-1044 expects section 4.2. If the trace contains only annex B and the answer still says “seven years,” the run fails: the right first fix is retrieval or graph extraction, not a more forceful writer prompt.

1 — Isn’t model confidence enough? No; confidence is presentation, while the gate checks retrieved evidence and span support.
2 — Why not BLEU? BLEU compares wording, but this task needs expected citation IDs and supported claims.
3 — Did Ylogx use LangSmith? No; Ylogx uses SQL-shape/result fixtures and denied-tier checks, so I do not move IQVIA tooling there.
4 — Do traces contain the full BRD? They should contain identifiers and the minimum evidence needed to debug, not full confidential documents or credentials.
5 — Who reviews generated tests? Humans spot-check a sample; I do not invent a reviewer count.
6 — What pass rate did you achieve? The resume does not state one, so I explain fail-on-missing-span and do not manufacture a number.
7 — LangSmith versus unit tests? Unit tests catch deterministic code failures; traces and evals catch wrong retrieval, wrong tool order, and unsupported fluent output.
8 — Does the same principle apply outside this stack? Yes: generated code still must compile and run, but LangSmith itself remains an IQVIA claim rather than a universal tool claim.

5. Why use Firecrawl, Bing, DuckDuckGo, and Playwright instead of one Google path? Resume-derived

Mapping. Exact resume hook: IQVIA Deep Research used Firecrawl, Bing, DuckDuckGo, and Google Playwright while ranking information across 200+ websites. No source says this exact stack was asked for Job 10454435.

Problem without it. One search or scraping method misses entire families of pages: indexes have coverage gaps, APIs rate-limit, crawlable HTML differs from JavaScript-rendered pages, and the first result can be syndicated or stale.

Alternatives considered. I considered one Google search API, Firecrawl only, Playwright on every URL, and RSS-only discovery. A single source was brittle; browser-rendering everything was unnecessarily slow and expensive.

Why not the alternative; precise failure. One API can return zero useful pages after a rate limit or index miss. Playwright-everywhere wastes render time and increases browser failures. Firecrawl-only misses a page that needs client-side rendering.

Do not use GenAI for. The model must not treat an empty scrape as evidence, invent page contents behind a failed render, or override legal and access boundaries.

Honest 10×. Cache repeated URLs, cap concurrency, use snippets before full renders when sufficient, and invest in ranking before adding a fifth scraper. I do not claim crawler sharding or an IQVIA QPS value.

Concrete example. Bing and DuckDuckGo both expose useful text, Firecrawl gets boilerplate, and Playwright renders the one JavaScript page that actually contains the date. The ranker keeps the independent evidence instead of counting boilerplate as a vote.

1 — Why DuckDuckGo if Bing already works? The indexes have different gaps, and cross-engine agreement is a ranking signal rather than redundancy for its own sake.
2 — Is Playwright itself Google Search? No; the resume’s Google Playwright wording describes browser automation for pages that search APIs do not fully expose.
3 — What about legal or terms constraints? I stay within authorized analyst research and access rules and do not turn the interview into an evasion tutorial.
4 — Why not render every URL? A full browser costs more time and fails more often, so I use it selectively when snippets or direct extraction are insufficient.
5 — Were tools run serially? They fan out in parallel and then rank, avoiding a Google-first bias.
6 — Do you cache? Reusing a completed scrape avoids re-rendering the same URL; I do not invent an expiry value.
7 — What changes at 10× domains? I budget browser renders, cap concurrency, and improve candidate filtering before adding tools.
8 — Is valAgent part of this metric? No; valAgent is a separate GitHub ETL-validator artifact, not the source of the 200+ website claim.

6. Why rank by agreement instead of trusting the first high-scoring result? Resume-derived

Mapping. Exact resume hook: IQVIA Deep Research properly ranked information for result generation across 200+ websites. Hallucination, RAG, guardrails, and bias were reported in the intern-format LC 8463405; other candidates’ loops may differ.

Problem without it. First-hit retrieval looks confident even when two credible pages contradict. A single recent blog can outrank a specification, and several syndicated copies can create fake consensus.

Alternatives considered. I rejected top-SERP only, popularity-only ranking, recency-only ranking, and an opaque “ask the LLM which page is best” step. Each hides the evidence needed to explain a conflict.

Why not the alternative; precise failure. First-hit ranking returns whichever scraper completed first. Popularity can prefer a widely copied error. Recency-only can choose a new blog over an authoritative specification. An LLM judge without explicit evidence can merely restate its own bias.

Do not use GenAI for. A model should not hide disagreement, count syndicated copies as independent confirmation, or create a confident average when evidence remains unresolved.

Honest 10×. Filter candidates before pairwise comparison, cap the ranked set, and improve source deduplication rather than sending ten times more pages to the writer. I do not invent a proprietary ranker model.

Concrete example. One page says wet ink is mandatory, two mirrors repeat an e-sign article, and the underlying authoritative document supports wet ink. Mirror detection prevents the copied article from winning “three to one.”

1 — What does agreement mean? It is overlapping claims from independent sources, not duplicated copies of one story.
2 — Who wins a real contradiction? No source wins automatically; I surface both supported spans or abstain when the conflict cannot be resolved.
3 — Recency or agreement? Both matter alongside source quality, because a new post that contradicts a governing specification is not automatically right.
4 — Is the ranker another LLM? I describe quality, recency, agreement, and state; I do not invent a model card absent from the resume.
5 — Was this your hardest production outage? It is an honest ranking failure class, not a named outage; my primary Dive Deep story remains Ylogx Redis plus RLS.
6 — How do you know the result? The resume states that information across 200+ websites was ranked, and I do not add an unsupported accuracy percentage.
7 — Why not popularity alone? Popularity is not correctness for requirement-adjacent research and is vulnerable to copied errors.
8 — What changes at 10×? Better filtering, deduplication, and bounded candidates come before a larger unfiltered pile.

7. Why NestJS + FastAPI + Postgres instead of one Flask app? Resume-derived

Mapping. Resume: Python FastAPI, TypeScript NestJS, PostgreSQL, React, reports, SQL RAG, 40% faster reports, 99.9% uptime. This repo: convbi-backend (Nest), convbi-ai (FastAPI), Postgres via Sequelize.

Problem without it. One process would mix JWT/RBAC/report CRUD, slow LLM generation, and warehouse SQL. A generation timeout (FastAPI gunicorn 180s) would stall KPI GETs. A privileged SQLAlchemy engine used for schema dump would also be the execute path.

Alternatives considered. Standard CS: one Flask/Django monolith; putting ChatOpenAI inside Nest; dumping rows into the model. I did not run a second JVM service. Live Code is Java; this intern is Python/TS.

Why not the alternative; precise failure. One Flask app either blocks dashboards behind generation or executes model SQL as the schema user. Nest-only LLM would still be Node calling OpenAI; the split is isolation of the slow untrusted proposer.

Do not use GenAI for. Role mapping, KPI math, health, or deciding which service executes SQL.

Honest 10×. Scale ECS tasks and the pool of 20 before merging services. I did not shard. FastAPI already runs 8 gunicorn workers — that is generation capacity, not dashboard capacity.

Concrete example. Sales tile: GET /dashboards/sales on the RLS transaction. “Top SKU?”: Nest → FastAPI JSON → Nest SELECT.

1 — What did you do? I can walk the Nest executor + FastAPI proposer + Postgres RLS files, not a slide of logos.
2 — What would you do differently? Private-network the FastAPI URL; do not leave CORS * on the proposer.
3 — How do you know the metric? 40% / 99.9% are resume outcomes. I do not invent a split-service latency budget.
4 — Was the chatbot LangGraph? No. LangChain ChatOpenAI + Pydantic parser. LangGraph is IQVIA.
5 — Java? Same split of proposer vs executor vs row policy. Syntax in the room is Java. Production was not Spring.

8. Why SQL RAG instead of dumping warehouse rows into the model? Resume-derived IE-asked

Mapping. Resume SQL RAG +65% analysis productivity. Code: convbi-ai/prompts.py SELECT-only contract; Nest allow-list execute.

Problem without it. Pasting 90 days of invoices exceeds context, truncates silently, and invites fabricated totals. A fluent paragraph over guessed rows cannot inherit RLS.

Alternatives considered. Stuff rows into the prompt; fine-tune on CSV; only fixed dashboards; let FastAPI’s engine run the SQL.

Why not the alternative; precise failure. Row-dump truncates and lies. FastAPI-as-executor would run as DB_USER from engine.py, bypassing Nest SET ROLE.

Do not use GenAI for. Credentials, table authorization, writes, or replacing SUM/GROUP BY.

Honest 10×. Tighten include_tables and Nest allow-list before exposing more schemas. I did not shard.

NL → FastAPI ChatOpenAI (schema subset)
  → eventQuery
  → Nest SELECT allow-list
  → req.dbTransaction (SET ROLE)
  → RLS rows

Concrete example. “Highest collection last quarter” becomes SQL over outstanding_receivable / collections tables, not a paste of every row.

1 — What did you do? Constrained generation plus Nest execution, not a bigger prompt.
2 — Differently? Pass caller role into the proposer only as allowed table names, never as a superuser DSN.
3 — How do you know +65%? Resume only. Eval is golden NL → SQL shape, not BLEU. No LangSmith on this intern.
4 — Gemini? Frontend lists @google/generative-ai; extractor is ChatOpenAI. I do not say the bot is Gemini.

9. Why Postgres RLS instead of app-only WHERE? Resume-derived

Mapping. Resume: RLS + RBAC for three organizational tiers as roles. Code: CREATE POLICY ... USING (... AND "organizationId" = current_setting('app.organizationId')::uuid).

Problem without it. App WHERE dies on the first missed JOIN, raw SQL path, or generated statement that skips the helper. SQL RAG increases that surface. executeRawSelectQuery even injects org predicates by string — still not enough if the joined table has no organizationId.

Alternatives considered. Nest middleware only; views without row policy; “every query uses one helper”; trusting the model to add the tenant predicate.

Why not the alternative; precise failure. Generated JOIN outruns the helper. Owner connections skip RLS. Scaling ECS without RLS scales the leak.

Do not use GenAI for. Policy DDL, role assignment, or interpreting empty vs leaked rows.

Honest 10×. Expand JOIN fixtures and pooled SET/RESET tests. I did not shard.

Concrete example. sales filtered in app SQL; JOIN to a shared mapping table without org column. RLS still drops foreign facts.

1 — What did you do? Role-bound transaction + policy USING on org, not a promise about helpers.
2 — Differently? Bind the org inject; do not concatenate. Keep generated SQL off RESET ROLE.
3 — How do you know isolation? Zero foreign rows on a deny fixture, not HTTP 200. No leak count on the resume.

10. Why combine three-tier RBAC with RLS? Resume-derived

Mapping. Resume three organizational tiers as roles. Code RoleEnum: SUPER_ADMIN, ADMIN, USER (GUEST exists; dashboards 403 guests).

Problem without it. RBAC alone allows a legal “view dashboard” that reads the wrong org. RLS alone does not stop a USER from hitting admin policy DDL.

Alternatives considered. One admin boolean; endpoint checks only; row rules only; collapsing product tiers to simplify code.

Why not the alternative; precise failure. A single admin flag cannot represent three scopes. Token organizationId is not a substitute for SET ROLE.

Do not use GenAI for. Promoting USER to ADMIN or writing GRANT.

Honest 10×. Keep three product tiers; add members inside them; grow fixtures. Do not explode a role enum per person first.

Concrete example. USER may GET /dashboards/sales but only sees policy-allowed sales rows. SUPER_ADMIN RESET ROLE is an explicit privileged path.

1 — What did you do? Mapped JWT role to Postgres role and policies, including fail-closed rls_no_access.
2 — Differently? Do not take only the first db_role_name without documenting overlapping policies.
3 — Exact tier names on the resume? Not printed. I speak SUPER_ADMIN / ADMIN / USER as this repo’s enum, not invented customer labels.

11. Why Redis on the resume, and what does this Nest snapshot actually cache? Resume-derived

Mapping. Resume: Redis −35% bot DB latency (Dive Deep / Frugality). This Nest/FastAPI tree: no Redis client. Code cache: fieldsCache Map keyed fields:${tableName}, 5 minutes.

Problem without a cache. Repeat NL and schema lookups rerun Postgres. Users feel DB work as “the model is thinking.”

Alternatives considered. Bigger RDS first; CloudFront for private answers; raw-English keys; treating Redis as source of record; this repo’s process Map without org.

Why not the alternative; precise failure. Bigger RDS repeats work. Edge-caching tenant JSON leaks. Map-without-tier is shared across every user on that task.

Do not use GenAI for. Cache keys or treating a denied SQL result as a global hit.

Honest 10×. Process Maps do not span ECS tasks. If Redis returns, every key still needs role. I did not shard Redis or Postgres.

Concrete example. Resume: Tier A and Tier B “top SKU” must not share a Redis value. This repo: two orgs calling dataset fields for sales share one Map entry on that task.

1 — What did you do? On the resume: Redis on the bot DB path. In this checkout: I can show the Map and the missing Redis module.
2 — Differently? Typed keys with org/role; no warehouse payloads in a process Map.
3 — How do you know −35%? Resume only. No TTL/p95 on the resume. The 5 minute TTL is this Map, not Redis.
4 — Dashboards? Sub-210 ms is no-LLM SQL. Do not credit bot Redis for tiles.

12. Why keep the LLM off the KPI dashboard path? Resume-derived IE-asked

Mapping. Resume: 30 dashboards, +60% ops, sub-210 ms. This repo: 9 types in DashboardsController / architecture-docs/06 (multi-page). Speak both; do not invent a third count.

Problem without it. A model per tile adds variable latency, cost, and invented KPIs. FastAPI workers use a 180s timeout — incompatible with sub-210 ms.

Alternatives considered. One ChatOpenAI call per KPI; chatbot fills every tile; Recharts on generated prose.

Why not the alternative; precise failure. Nine types × model calls still couples availability to the vendor and misses sub-210 ms.

Do not use GenAI for. KPI calculation, authorization, or blocking tile JSON.

Honest 10×. Pre-aggregate, kill N+1, pool, more tasks. Keep the model out. I did not invent WebSockets.

Concrete example. Overview revenue is SUM(total_amount) FROM sales with date filters — not eventQuery.

1 — What did you do? Kept dashboard controllers free of the chatbot URL.
2 — Differently? Shared aggregate queries across pages instead of per-page SQL copies.
3 — 30 vs 9? 30 is the resume KPI/dashboard outcome. 9 is this snapshot’s predefined types. I will not invent pages-as-30 unless I count them live and say so.

13. Why CloudFront → ALB → ECS (and GitHub Actions) instead of one EC2? Resume-derived

Mapping. Resume: CloudFront, ECS, Docker, CI/CD, GoDaddy + Route 53 through ALB, 99.9%, sub-210 ms. This repo: .github/workflows/convbi-qa.yml and convbi-prod.yml. backend-docs still draw CodeBuild — speak Actions as what runs.

Problem without it. One mutable VM is one failure domain. Always-on BI is a poor fit for a Lambda-per-request shape, especially with 180s generation.

Alternatives considered. One EC2 + nginx; Lambda for every route; serving JS from ECS; treating latex CodeBuild as the live pipeline.

Why not the alternative; precise failure. Single host: deploy and crash share fate. Lambda: cold start + 180s RAG. CodeBuild-only story contradicts the workflow files.

Do not use GenAI for. DNS, health, secrets, or approval.

Honest 10×. More healthy tasks after pool tests. No multi-region claim. No AWS bill.

Concrete example. React from CloudFront. KPI JSON through ALB to a healthy Nest task. Private JSON is not an edge object.

1 — What did you do? Defend the hop list and the Actions files, including prod approval as a gate.
2 — Differently? Secrets in a secret store, not in task-definition JSON (I will not quote values).
3 — How do you know 99.9%? Resume serving result. No invented outage minutes.

14. Why Docker and ECS when Kubernetes is listed? Resume-derived

Mapping. Resume Docker + ECS + CI/CD. Kubernetes is skills-line. Dockerfile FACT: USER node.

Problem without it. “Works on my machine” and patch-in-place rollback.

Alternatives considered. SSH to a VM; Compose as production; Kubernetes because it is fashionable.

Why not Kubernetes; precise failure. Control-plane operations are not on the intern bullet. Claiming EKS invites questions I cannot evidence.

Do not use GenAI for. Secret placement or skipping health.

Honest 10×. Same image, more tasks, pool of 20 × task count vs RDS max_connections. I did not move to k8s.

Concrete example. Replacement Nest task must pass Terminus DB ping before it is a stable service. Health-green plus RESET ROLE on facts is still unsafe (different class).

1 — What did you do? Artifact + ECS service lifecycle, not cluster-owner theatre.
2 — Differently? Drop synchronize: true in prod-shaped deploys.
3 — Compose? Local docker-compose.yml. Production evidence is ECS workflows.

15. Why SET ROLE on a transaction instead of a global connection role? Resume-derived

Mapping. RLSMiddleware + sequelize.transaction() + SET ROLE + set_config(..., true). Pool max 20.

Problem without it. Pooled connections reuse sessions. A process-wide SET ROLE leaks User A’s role into User B’s request. App WHERE cannot see which role the socket still holds.

Alternatives considered. One DB user for the app; new TCP connection per request; SET ROLE without BEGIN; concatenating org into SQL only.

Why not the alternative; precise failure. Global app role = every tenant is one prompt from a dump if SQL is generated. Per-request TCP without pooling dies at 10×.

Do not use GenAI for. Choosing SET ROLE vs RESET ROLE for unassigned users.

Honest 10×. Each in-flight request holds a pool slot until finish. 10× concurrency needs pool tests first. I did not shard.

Concrete example. Request 1 SET ROLE sales_role; if we returned the connection without ending the transaction, request 2 could read as sales_role.

1 — What did you do? Per-request transaction + SET ROLE stored on req.dbTransaction.
2 — Differently? Rollback on non-2xx; RESET ROLE in finally; never commit blindly on finish.
3 — Metric? Isolation is deny-fixture evidence. No pool-wait SLA on the resume.

16. Why GitHub Actions (qa vs main) instead of SSH or “the latex CodeBuild slide”? Resume-derived

Mapping. Resume automated CI/CD. Files: convbi-qa.yml, convbi-prod.yml. Docs: CodeBuild figure in backend-docs/07.

Problem without it. Laptop deploys drift. QA and prod become the same tag by accident.

Alternatives considered. SSH; CodeBuild-only as in latex; Kubernetes CD; skipping prod approval.

Why not the alternative; precise failure. SSH has no image digest. Claiming CodeBuild when Actions is what runs gets busted if they open the repo.

Do not use GenAI for. Approving prod or writing AWS keys into the workflow (use secrets refs, never values in chat).

Honest 10×. Same pipeline, more tasks. I did not add a canary mesh I did not operate.

Concrete example. A qa tag must not be what prod deploys. Prod uses latest plus SHA after approval.

1 — What did you do? Environment split in Actions: qa auto, prod gated.
2 — Differently? Pin prod to SHA only (not mutable latest); keep approval.
3 — War room? I will not invent hours. The file says a 3-minute approval action.

17. Why Sequelize (typed models + raw SQL) instead of a query-builder-only app? Resume-derived

Mapping. SequelizeConfigModule, models under src/models, dashboards/queryDB use sequelize.query with QueryTypes.SELECT and the RLS transaction.

Problem without it. Auth/RBAC tables need relations (UserRole, RolePolicy, Policy, ModuleRegistry). KPI SQL is too irregular for naive ORM findAll. Without a shared transaction object, SET ROLE would not apply to raw queries.

Alternatives considered. Standard CS: Knex-only; Prisma; raw pg Client without models; auto-sync as a substitute for migrations.

Why not ORM-only; precise failure. Financial dashboards are windowed aggregates and aging buckets. Forcing them into findAll hides the SQL you need to inspect.

Do not use GenAI for. Turning synchronize: true loose on prod schema.

Honest 10×. Migrations, not auto-sync. Pool vs desired count. I did not shard.

Concrete example. Chat.create under executeWithoutRLS vs SELECT SUM on sales under RLS tx — two Sequelize styles, two isolation rules.

1 — What did you do? Models for identity graph; raw SQL for facts on the same transaction.
2 — Differently? Disable synchronize in prod; pass transaction everywhere (no default connection queries for facts).
3 — Metric? No ORM-vs-raw percent on the resume.

18. Why a SELECT allow-list in Nest instead of trusting the prompt? Resume-derived

Mapping. executeRawSelectQuery in queryDB.service.ts. FastAPI prompt also says SELECT-only — defense in depth, not a substitute.

Problem without it. A prompt can emit INSERT/UPDATE, pg_catalog, or a table outside the module registry. FastAPI has no JWT; Nest is the last gate before Postgres.

Alternatives considered. Prompt-only; executing inside FastAPI; allow any SQL as SUPER_ADMIN always; regex-only without hasTableAccess.

Why not prompt-only; precise failure. Prompt injection is not an authorization boundary. Regex startsWith('select') is bypassable with sneaky statements — that is why RLS + role grants still matter. WITH is wrapped by FastAPI so the Nest check sees SELECT.

Do not use GenAI for. Waiving an unknown-table 403 or adding GRANT because the English sounded reasonable.

Honest 10×. Expand allow-list as tables grow; do not “just add *”. I did not claim a formal SQL parser.

Concrete example. Model invents users_backup. Nest 403s before RLS. Model invents a legal JOIN across allowed tables — RLS still filters rows.

1 — What did you do? SELECT prefix + table ACL + RLS transaction, in that order.
2 — Differently? A real SQL parser / deny INSERT|COPY|INTO; bind org instead of string inject.
3 — How do you know? Fixture: forbidden table name never returns rows. No model-accuracy % on the resume.

19. Why Tally zips to S3 instead of database blobs? Resume-derived

Mapping. fileUpload.service.ts, validation util, backend-docs/06. Resume warehouse is Postgres facts after ingest — not zip bytes in a BYTEA column.

Problem without it. Tally backups are large zips (docs: 200MB; service env default 500MB). Storing blobs in Postgres bloats backups, RLS, and the connection that also serves sub-210 ms tiles.

Alternatives considered. BYTEA/OID in Postgres; disk on the ECS task; skipping magic-byte checks; letting the gateway pull from the browser.

Why not DB blobs; precise failure. A 200MB zip on the same RDS instance as KPI SUM queries is a latency and backup tax. Task-local disk dies with the task.

Do not use GenAI for. Trusting a renamed .zip without magic bytes, or putting gateway keys in prompts.

Honest 10×. Stream to S3 (not full buffer) if files grow; I did not claim a streaming upload in this snapshot (memoryStorage). No AWS bill.

Concrete example. Current-year zip and optional previous-year zip become two S3 URIs in details.zip_files, not two BYTEA columns.

1 — What did you do? Validate zip → S3 URI → gateway, keep Postgres for facts.
2 — Differently? Do not leave default placeholder keys in source; use IAM task roles instead of long-lived keys in env JSON.
3 — Metric? No ingest-GB number on the resume. 40% faster reports is the product outcome after data is in tables.

20. Why GStreamer with UDP-family transport instead of TCP for the rover’s live video? Resume-derived Standard CS

Mapping. Exact resume hook: Team Horizon delivered a GStreamer camera feed at 60 FPS for ERC 2024. TCP versus UDP was reported in the GFG SDE-1-17 computer-networks discussion; other candidates’ loops may differ, and the public Gstreamer-UDP repo is supporting evidence rather than a second project.

Problem without it. A rover operator needs the newest frame, not every stale frame in order. TCP retransmission after packet loss can block later bytes, freezing a naive MJPEG stream while the rover continues moving.

Alternatives considered. The comparison set is HTTP MJPEG over TCP, raw ROS image topics over the lossy link without a tuned media pipeline, or recording only with no live operator feed.

Why not the alternative; precise failure. TCP’s ordered byte stream waits for missing data, so one loss can hold newer frames behind retransmission. For an operator driving from current visual state, that freeze is worse than dropping an obsolete frame.

Do not use GenAI for. A model does not belong in packet recovery, frame scheduling, or the rover’s safety-critical planning loop. It cannot turn stale video into current occupancy.

Honest 10×. A rover is not a SaaS camera-count problem. For higher resolution or bitrate, downsample the operator view and preserve only what local planning needs. I do not claim a distributed video cluster, a radio specification, or 120 FPS.

camera → GStreamer capture/convert/encode
       → UDP-family packetization
       → lossy link (drop stale packet; do not stall)
       → depayload/decode → current operator frame

Concrete example. Packet N is lost while N+1 carries a newer frame. TCP holds N+1 until N is retransmitted; the UDP-family pipeline can display the newer decodable frame and keep the operator view current.

1 — TCP versus UDP in one sentence? TCP is a reliable ordered byte stream; UDP is datagrams with no delivery guarantee, which supports drop-over-stall live video.
2 — Is UDP printed on the resume? The resume prints GStreamer at 60 FPS, and the public Gstreamer-UDP artefact supports the transport family without adding a new metric.
3 — Did you use WebRTC? I do not claim it.
4 — Is the rate 60 or 24 FPS? Horizon’s camera feed is 60 FPS; Argus owns the separate 24 FPS detector budget.
5 — Is this tied to the coding-round language? No; networking and media-pipeline reasoning are independent of the language used for algorithm coding.
6 — Why not only publish image_raw? ROS2 is the integration bus, while sustaining field video needs a media transport pipeline rather than a notebook-style topic assumption.
7 — What happens under packet loss? The display drops obsolete frames and continues when possible; I do not invent a bit-error-rate number.
8 — Why not claim a higher frame rate? Sixty FPS is the resume result, so I defend it and do not manufacture 120.

21. Why keep dense ZED 2 data for the local costmap but downsample visualization? Resume-derived

Mapping. Exact resume hook: Horizon used a Stereolabs ZED 2 for 3D environmental mapping at 2M+ data points per second, with RViz and Gazebo. The outcome belongs to the rover system, not Argus mAP.

Problem without it. Shipping every point offboard can saturate the link, while thinning all consumers equally can make the local occupancy map miss obstacles. A smooth RViz display is not proof that the planner has current dense data.

Alternatives considered. I rejected one visualization-quality cloud for every consumer, streaming the full cloud to a remote laptop, driving only from camera pixels, and buying a different depth sensor as the first fix.

Why not the alternative; precise failure. Full-cloud offboard streaming consumes link capacity and delays decisions. Global thinning for a smoother visualization can erase a narrow ridge, so RViz looks healthy while the costmap marks free space.

Do not use GenAI for. Depth-to-occupancy conversion, time synchronization, and the planner’s local safety state must remain deterministic. A fluent scene description is not a costmap.

Honest 10×. Thin visualization more aggressively, use a bounded local costmap window, and profile transform/queue work before changing sensors. I did not shard a map or claim an invented voxel size.

ZED 2: 2M+ points/s
  ├─ dense/local → transform → occupancy → costmap → planner
  └─ downsampled → RViz/offboard visualization
time alignment applies before stale data reaches planning

Concrete example. RViz displays a light point cloud smoothly, but the planner consumes a denser local window. If the displayed cloud is current and the local transform queue is one cycle behind, the occupancy can still be stale.

1 — Why ZED 2 rather than a webcam? The ZED supplies depth for occupancy; the ordinary camera/GStreamer path serves live video.
2 — Do all 2M+ points go to RViz? No; visualization is downsampled while planning retains appropriate local density.
3 — Is Gazebo equivalent to field testing? No; dust, lighting, and physical timing differ, so field runs remain necessary.
4 — Did Horizon use YOLO? I do not claim that; Horizon is the ROS2 mapping/fusion story and Argus owns YOLOv9.
5 — What are the units? The resume says data points per second, and I do not invent a voxel dimension.
6 — Can you relate it to a coding problem? A local costmap can be reasoned about as a bounded grid, without claiming the field implementation was a toy grid exercise.
7 — What happens at 10× map size? Keep a local planning window and downsample visualization instead of building a global pretty mesh.
8 — Did the team miss ERC? The resume reports 17th out of 80+; it does not report a miss, so I do not invent one.

22. Why fuse sensors into a costmap instead of buying extra rover hardware? Resume-derived

Mapping. Exact resume hook: Horizon combined ROS2, sensor fusion, costmap path planning, and predictive algorithms; obstacle detection improved 40%, collision risk fell 55%, and the team placed 17th of 80+ at ERC 2024.

Problem without it. A live video feed or a perception model does not tell the planner where it can safely drive. Buying another sensor near a fixed competition date creates integration delay and still leaves time alignment and planning unsolved.

Alternatives considered. The comparison set is another sensor, a giant vision model, pixel-threshold stopping, bump-and-turn behavior, or waiting for a perfect map. None replaces fused occupancy and a planning interface.

Why not the alternative; precise failure. Another sensor adds drivers, calibration, transforms, power, and field testing. A giant model can label pixels but still leaves no time-aligned occupancy or path. Bump-and-turn reacts after contact rather than reducing collision risk.

Do not use GenAI for. The LLM must not emit occupancy cells, select motor commands, or replace deterministic fusion and planning. Safety cannot depend on fluent world description.

Honest 10×. More sensors still feed one bounded costmap; higher rover speed first demands tighter time synchronization and latency measurement. I do not lead with ten times more hardware or invent a bill of materials.

Concrete example. The operator video already shows a ridge, but a stale occupancy update still marks the corridor free. The planner turns that timing mismatch into a collision unless timestamps and fusion gate the path.

1 — Is this Frugality or Bias for Action? Both can map, but Horizon remains the Bias/Deliver story while Ylogx Redis is the primary Frugality story.
2 — What were “predictive algorithms”? I use the resume wording for planning over fused occupancy through time and do not reduce it to a red-pixel stop rule.
3 — What did you personally own? I owned core software around camera, mapping, and costmap, while the competition placement is a team result.
4 — Was there a fight over buying LiDAR? I describe the engineering trade-off—fuse existing hardware under a fixed date—without inventing a named interpersonal conflict.
5 — Did speed make you skip safety? No; the compromise was software integration versus new hardware, not removal of the costmap or safety checks.
6 — What if rover speed increases 10×? Stale occupancy becomes more dangerous, so time synchronization and end-to-end latency come first.
7 — What would you change for sim-to-real? I would invest more in dust/lighting field fidelity while preserving the ROS2 node split.
8 — Can this be explained in a coding interview? I can use a grid-planning analogy, while keeping the field system honestly framed as ROS2 fusion and costmap planning.

23. Why YOLOv9 one-stage detection instead of a two-stage detector or an LLM on frames? Resume-derived

Mapping. Exact resume hook: Argus used YOLOv9 on 15,000+ images, improved 73% → 89% mAP, held 24 FPS, and supported 20+ camera feeds.

Problem without it. Industrial PPE detection needs boxes and classes while the event is still actionable. A model that scores well on one laptop but cannot sustain the end-to-end frame budget across many streams is not a live safety system.

Alternatives considered. The standard comparison is a two-stage proposal-then-classification detector, a handcrafted OpenCV detector, a heavier backbone per stream, or a vision-language caption on every frame. I do not claim that I operated a full production bake-off of every alternative.

Why not the alternative; precise failure. Two-stage proposal/classification adds work per frame and can miss the 24 FPS multi-camera budget. A handcrafted detector breaks across lighting and PPE variation. An LLM returns non-deterministic prose rather than a bounded box pipeline.

Do not use GenAI for. PPE box generation, alert authorization, or the compliance record. Those outputs require detector metrics and structured events, not fluency.

Honest 10×. Keep the 89% mAP and 24 FPS gates, use workers or batching where it preserves latency, drop stale frames, and store events instead of video blobs. I do not claim a Kubernetes deployment or detector sharding.

frame → OpenCV decode/resize
      → YOLOv9 one-stage boxes/classes
      → confidence filter → NMS
      → event {camera, class, confidence, timestamp, box}
      → Postgres → alert

Concrete example. A two-stage model can look more accurate on a single recorded clip but fall behind by camera 12. Delayed no-helmet alerts then arrive after the worker has left the frame, violating the real-time purpose despite the laptop score.

1 — Why not Detectron/two-stage? The product constraint is 24 FPS across 20+ feeds, and I defend one-stage throughput without inventing a benchmark I did not run.
2 — What about a handcrafted OpenCV detector? OpenCV remains useful for decode/resize, but a handcrafted baseline does not support the 89% mAP production claim across industrial variation.
3 — Did TensorFlow serve the model? TensorFlow is a skill, while the resume-specific Argus claim is YOLOv9; I do not create a serving story.
4 — How does mAP relate to the 50% violation reduction? mAP is the detector gate; violation reduction and 2× compliance are operational outcomes after alerts, so I keep the metrics separate.
5 — Why NMS? It suppresses overlapping duplicate boxes; overly aggressive suppression can merge two nearby workers.
6 — Was this the separate prep-only YOLOv8 story? No; I defend the resume’s YOLOv9, 15,000+, 73→89, and 24 FPS facts.
7 — Did it run on a Kubernetes cluster? I do not claim that; the supported statement is a containerized solution for 20+ feeds.
8 — What if asked for 10× FPS? I defend the 24 FPS budget and stale-frame dropping rather than inventing a higher rate.

24. Why was 73% mAP not shippable, and why improve the gate before scaling cameras? Resume-derived

Mapping. Exact resume hook: Argus trained YOLOv9 on 15,000+ images and improved detection from 73% to 89% mAP before supporting 20+ feeds at 24 FPS. This is the honest Highest Standards / mistake answer.

Problem without it. A 73% detector scaled to many cameras multiplies missed PPE and wrong alerts. People learn to ignore a noisy safety system, so a demo-level score can make the operational product worse.

Alternatives considered. I rejected shipping the demo GIF, hiding behind a threshold tweak, selecting a heavier model that breaks throughput, and calling 73% “good progress” while wiring alerts.

Why not the alternative; precise failure. Scaling at 73% creates alarm fatigue and missed incidents on every added camera. Raising a confidence threshold may reduce one error type while hiding violations. A heavier model can improve notebook quality yet fail the 24 FPS gate.

Do not use GenAI for. A language model cannot relabel 73% as acceptable, replace the detector gate, or approve deployment because a demo caption looks convincing.

Honest 10×. Preserve held-out evaluation and the 24 FPS gate, consider a held-out camera as a future strengthening step, and refuse to multiply a 73% system. I do not claim an image count beyond 15,000+.

Concrete example. A yellow helmet under difficult factory lighting is missed at the 73% stage. Turning that detector on across 20 feeds scales the same miss and trains supervisors to distrust alerts.

1 — What mistake did you make? I treated 73% mAP as progress toward launch rather than a failed safety gate.
2 — What was the negative feedback? The practical feedback was that 73% is not a page-the-floor number, so data and evaluation had to improve before scale.
3 — Did you reach 95%? That number is not on the resume, so I do not claim it.
4 — What were exact precision and recall? The resume reports mAP; I explain the concept but do not invent class-level values.
5 — Why improve data before changing architecture? Lighting and PPE variation are data coverage failures, while one-stage YOLO already served the throughput constraint.
6 — Did an LLM label all 15,000 images? I do not claim an automated labeling pipeline; the supported fact is training on 15,000+ images.
7 — Why not simply collect 10× more images? More data has diminishing returns and must still be judged by held-out mAP plus the FPS gate.
8 — Is detector training part of Live Code? No; coding-round algorithms and the Python CV system are separate evidence lanes.

25. Why store Argus detection events in Postgres instead of putting video in the database? Resume-derived

Mapping. Exact resume hook: Argus provided PostgreSQL logging in a containerized solution supporting 20+ camera feeds, with 50% fewer violations and 2× compliance. The public API README is unavailable, so no route names are inferred.

Problem without it. Safety needs an audit query: which camera, what class, when, confidence, and bounding box. Video blobs inside Postgres inflate storage and backups, while loose files alone cannot provide a reliable event trail.

Alternatives considered. I rejected MP4 or frames in a database blob column, files with no indexed metadata, a dashboard-only animation, and choosing Mongo merely because event documents look flexible.

Why not the alternative; precise failure. Video blobs make relational backups and queries carry media they do not need. Files without event rows cannot answer which detection fired on camera 7 at a given time. Alerting before persistence can create a page with no audit record.

Do not use GenAI for. The model should not turn prose into the official event, invent a missing detection record, or expose unauthenticated camera streams.

Honest 10×. Keep writing compact events, index time and camera, and keep bulk media out of the relational path. I did not shard Postgres or invent retention days.

camera frame → YOLOv9 + NMS
             → event row {camera, class, confidence, ts, box}
             → persist in Postgres
             → notify / dashboard query
video bytes  → separate bulk-media storage class

Concrete example. “Camera 7, Tuesday 18:04, no-helmet, confidence, box coordinates” is a queryable SQL event. A video file alone requires replay, and a database full of video blobs burdens every event backup.

1 — Did you use S3? Object storage is the standard conceptual media destination, but I do not invent an Argus bucket; the shipped resume fact is Postgres logging.
2 — Why not a time-series database? It is a possible future alternative, while the actual system used Postgres events.
3 — Where could ProtoBuf fit? It is reasonable for compact internal event metadata, not as a justification to wrap JPEG bytes in a new story.
4 — Did Argus use Ylogx’s RLS design? I do not claim that; camera access still needs authentication, while the deep three-tier RLS story stays Ylogx.
5 — How does this map to a notification design? Detect → persist → notify is the honest shape, grounded in Postgres logs and 20+ feeds.
6 — What happens at 10× retention? I would revisit indexing and storage policy, but the resume gives no retention SLA to quote.
7 — Did Kafka carry events? I did not operate Kafka here, so I do not invent topics.
8 — Why not keep only files? Files do not provide the indexed audit query that safety events require.

26. Why GiftedBooks RAG over the student’s PDF, with PYQ analytics kept separate? Resume-derived

Mapping. Exact resume hook: GiftedBooks offered contextual PDF RAG at sub-300 ms with 99.5% uptime, PYQ topic suggestions, 35% more reading, 50% more engagement, 2.5× comprehension, and doubt resolution from hours to 3–10 minutes. The GitHub README currently describes AegisAI, so the resume is authoritative.

Problem without it. A generic tutor can hallucinate a syllabus or use a formula that differs from the student’s material. Stuffing a whole textbook into a prompt hurts latency and grounding, while mixing users’ PDFs violates trust.

Alternatives considered. I rejected a generic chatbot, whole-PDF context on every question, an LLM guessing likely exam topics, and importing the mismatched AegisAI README into the product story.

Why not the alternative; precise failure. Whole-book prompting misses the sub-300 ms path and can cite the wrong formula. A generic tutor ignores the user’s source of truth. An LLM-based “syllabus prediction” presents speculation as analysis. Cross-user retrieval exposes another student’s notes.

Do not use GenAI for. The model must not guess PYQ trends, bypass per-user document isolation, or treat latency as proof of faithfulness. I would add a citation eval as a future step; I do not claim it shipped.

Honest 10×. Ingest each PDF once, cache retrieval work, keep top-k small, and preserve user/document metadata on every lookup. I did not shard the index, and the resume gives no student headcount.

student → auth → upload PDF
        → chunk/embed once → vector + user/document metadata
question → scoped top-k → grounded answer (sub-300 ms)
PYQ papers → deterministic topic ranking (separate path)

Concrete example. A student asks for the worked derivation on page 14. The system retrieves that page’s chunk from the student’s file; a too-small chunk loses the derivation, while a whole-book prompt misses the latency and trust boundary.

1 — GitHub says AegisAI? That is a README mismatch, so I answer GiftedBooks from the resume and do not mix features.
2 — Did GiftedBooks use Azure Search? No such claim exists; Azure + GraphDB belongs to IQVIA.
3 — Was the vector store FAISS? FAISS is a skill and this is the vector-plus-metadata lane, but I do not invent a cluster or operations topology.
4 — Did you run LangSmith here? No resume claim says so; citation evaluation is a would-add, not a did.
5 — Which uptime is correct? GiftedBooks is 99.5%, while Ylogx is 99.9%; I keep those systems separate.
6 — Is PYQ inside the LLM? No; it is separate deterministic analytics on past papers.
7 — What changes at 10× PDFs per user? The ingest-once and metadata-isolation rules remain, with bounded retrieval rather than repeated full embedding.
8 — Is sub-300 ms a JVM benchmark? No; it is the resume’s API result, independent of the coding-round language.

27. Why StratifyLabs used browser inference, WebGL/URDF, and a marketplace instead of a notebook-per-user? Resume-derived

Mapping. Exact resume hook: StratifyLabs delivered a 3D simulation lab, browser-based inference that reduced ML iteration time by 30%, a marketplace of 50+ pretrained models/datasets, a WebGL URDF editor, and scene-oriented Gemini RAG voice bots. The default Next.js README does not replace these resume facts.

Problem without it. A notebook or native simulator per person turns every small experiment into environment setup or GPU scheduling. A one-model demo disappears with the person who built it, and a generic chatbot cannot reason about the current simulated scene.

Alternatives considered. I rejected giving every user a full training box, treating Horizon’s native Gazebo stack as the same SaaS, interpreting 50+ catalog items as 50 GPUs, and adding a generic chatbot disconnected from scene state.

Why not the alternative; precise failure. Notebook-per-user repeats environment setup and isolates artifacts. Native-simulator-only raises the entry cost for CV users. Large models can exhaust browser memory. A bot grounded in stale scene data describes objects that no longer exist.

Do not use GenAI for. The scene graph, URDF integrity, model execution, and user-data isolation stay deterministic. Gemini can explain current scene context, but it must not hallucinate objects or access another user’s dataset.

Honest 10×. Grow the catalog, keep only suitable small inference in the tab, move heavy training off the synchronous path, and add a current-scene eval for the bots as a future improvement. I do not invent cluster capacity, user count, or LangSmith usage.

Web client
  → WebGL scene + URDF editor
  → small browser inference → immediate iteration
  → marketplace catalog (50+ models/datasets)
  → Gemini voice bot grounded in current scene
heavy training → separate from interactive request path

Concrete example. A user moves a camera in the WebGL scene and reruns a small detector in the tab. A bot that still answers from last week’s scene is stale, while a large model that crashes browser memory belongs off the click path.

1 — Did you use Three.js? Three.js is a skill; the resume claim I defend is URDF + WebGL and the 3D lab.
2 — Is this the same as Horizon Gazebo? No; Horizon is a field rover and StratifyLabs is a browser CV lab.
3 — Does 50+ mean GPUs? No; it means marketplace catalog items—pretrained models and datasets.
4 — Is 30% an FPS improvement? No; it is reduced ML iteration time, while Argus and Horizon own their separate frame-rate metrics.
5 — Is karyanode part of the resume metric? No; it is a separate GitHub module and cannot inherit StratifyLabs outcomes.
6 — Did StratifyLabs use Ylogx RLS? The resume does not say so; I state the need for user isolation but keep deep RLS evidence on Ylogx.
7 — What changes at 10×? Keep heavy training off the interactive path and evaluate bots against current scene state as a would-add.
8 — Was the client a JVM application? No; I do not rewrite the browser product into a different stack for the interview.

28. Why choose JWT or server sessions, and how does either connect to Ylogx RLS? Standard CS Resume-derived

Mapping. JWT, OAuth 2.0, and Auth0 are skills-line evidence. The exact Ylogx resume hook is NestJS RBAC plus Postgres RLS for three tiers; I say “identity at the API mapped to a database role” and do not claim Auth0 operated the internship. This ConvBI snapshot: jwt.middleware.ts verifies Authorization: Bearer; frontend axios still reads localStorage token. COOKIE_AUTH_IMPLEMENTATION_COMPLETE.md describes HTTP-only cookies that are not what the running middleware does. Speak the code.

Problem without it. Multiple application tasks need a stable caller identity. A session stored only in one process disappears or requires sticky routing, while a long-lived bearer token is difficult to revoke. Neither choice can replace database row security.

Alternatives considered. Standard options are server sessions backed by a shared store, short-lived signed tokens, a one-box in-memory session, or an external identity provider. I reject forever tokens, secrets in token payloads, and “the token contains org_id, therefore RLS is unnecessary.”

Why not the alternative; precise failure. One-process sessions lose logins when routing changes. A forever JWT remains usable after access should end. Putting secrets in a token exposes them to every holder. Treating org_id as authorization lets generated SQL bypass database policy.

Do not use GenAI for. Token validation, session revocation, role mapping, CORS policy, and RLS remain deterministic security controls. A model may explain the flow but cannot approve access.

Honest 10×. Use a shared session store or verified short-lived tokens across tasks, keep role mapping centralized, and retain RLS. I did not operate a token denylist topology and do not invent an expiry or session duration.

identity at API
  → session lookup OR signed token verification
  → RBAC action check
  → map caller to DB role
  → SQL under that role
  → Postgres RLS rows
Authentication transports identity; it does not replace authorization.

Concrete example. A Bearer token honestly says the caller is Tier B, but the SQL connection still assumes the Tier B database role via SET ROLE. If a generated JOIN requests Tier A rows, RLS denies them rather than trusting the prompt or token field alone. I do not speak cookie-only auth as shipped in this checkout.

1 — JWT versus sessions in one comparison? Sessions store state server-side and revoke by deletion; JWT carries signed state and usually revokes through short lifetime or additional server state.
2 — Did Auth0 run the internship? Auth0 is listed as a skill, so I do not claim a production tenant administration story.
3 — Where does OAuth fit? OAuth delegates authorization and uses redirect-state protections; the deeper resume evidence is still Ylogx role mapping and RLS.
4 — XSS versus CSRF? XSS runs attacker-controlled script in the trusted origin; CSRF abuses automatically sent credentials such as cookies, so mitigations differ.
5 — Is CORS tenant isolation? No; CORS is a browser rule, while database RLS enforces row isolation regardless of browser behavior.
6 — Where do authorization conditions live? Route policy and database policy, not scattered façade conditionals or model prompts.
7 — Does the rover use this login flow? I do not invent OAuth on ROS2; unauthenticated telemetry is still unsafe, but the deep auth story belongs to Ylogx.
8 — What changes at 10× tasks? Share session state or validate tokens consistently across tasks, while role mapping and RLS remain unchanged.

29. Why are Java, Kubernetes, FAISS, Auth0, and other skills honest one-liners rather than production stories? Resume-derived Standard CS

Mapping. Exact resume hook: these technologies appear on the skills line, while the project bullets identify stronger shipped evidence. Listed knowledge is not permission to invent a cluster, framework migration, identity tenant, message bus, or database topology.

Problem without it. Saying every listed skill was production-critical creates contradictions: Ylogx becomes a JVM/Kubernetes product it was not, IQVIA becomes FAISS-only despite Azure Search, and Auth0 becomes a named provider without resume evidence. Bar Raiser follow-ups expose that immediately.

Alternatives considered. The wrong approach is to inflate course, lab, adjacent, or conceptual experience into ownership. The honest approach is one line of knowledge, then redirect to the shipped project whose mechanism can be defended.

Why not inflate the alternative; precise failure. Claiming “my Kubernetes cluster” invites questions about scheduling, networking, upgrades, and incidents I cannot answer. Calling FAISS the IQVIA store contradicts Azure Hybrid + Semantic. Naming Auth0 as Ylogx production invents provider operations. Saying Ylogx ran on the JVM contradicts the actual internship path.

Do not use GenAI for. A model should not generate résumé experience, fill missing operational details, or turn a familiar API into a shipped story. It can help rehearse standard-CS distinctions only after the evidence boundary is fixed.

Honest 10×. Scale the mechanisms with real evidence: ECS tasks and pooling for Ylogx, bounded retrieval and evals for IQVIA, FPS/mAP gates for Argus, local costmap fidelity for Horizon, and ingest-once isolation for GiftedBooks. Do not introduce a skill-line technology merely to sound “Amazon scale.”

Concrete example. If asked “why Kubernetes?” I say it is listed knowledge, then explain why the shipped Ylogx path used Docker + ECS. If asked “FAISS or Azure?” I map GiftedBooks to vector-plus-metadata and IQVIA to Azure + GraphDB, instead of merging both into a fictional platform.

1 — Why list skills without a production story? They represent course, lab, adjacent, or conceptual knowledge, and I state that evidence level explicitly.
2 — Can you work in Java? Yes, I use it for Live Code and core data structures, while refusing to relabel non-JVM systems as Java production.
3 — GraphQL versus REST? REST shipped; GraphQL becomes relevant when nested over-fetch is the measured pain, which was not the first Ylogx bottleneck.
4 — MongoDB versus Postgres? BI joins, aggregation, transactions, and row policy support the Postgres choice.
5 — FAISS versus Azure? Azure Hybrid + Semantic is the IQVIA evidence; FAISS remains skills/vector knowledge and the smaller GiftedBooks lane.
6 — Can you answer Kubernetes questions? I can discuss pods, services, and scheduling as standard CS, while identifying ECS as the orchestrator I actually shipped.
7 — What about an Auth0 deep dive? I redirect to token/session trade-offs and Ylogx role-to-RLS mapping rather than inventing provider administration.
8 — ProtoBuf or JSON? Ylogx dashboard payloads stayed JSON; ProtoBuf is a possible compact internal metadata choice, not a shipped gRPC-mesh claim.