5. Projects in depth

This is a rehearsal notebook for Adarsh Vishwakarma. Read it as yourself, not as an interviewer. R1 was 13 Aug 2026. R2 was 18 Aug 2026. R3 is done. This folder is the leftover hour only. Live Code is Java. Job 10454435 still has no public write-up that names a live-round question. Other people’s prompts show what a leftover hour can look like. They are not a list for this Job ID. One spoken answer, one product. Internships are a timeline: Horizon February–June 2024, Ylogx November 2024–October 2025, IQVIA April 2026–present.

How to use this page

Each product card is a leftover-hour deep dive. What they might ask is the prompt. What you say is the spoken pitch: the problem without the system, then what you shipped. Data flow is the 4–8 step path if they ask you to walk the boxes. They might ask next unpacks the same product. Keep straight is which number lives here. Tighten is how to stop.

What they might ask

Walk me through this project on your resume.
How does it actually work?
Why this design instead of the obvious option?

Label Resume-derived for the mechanisms. IE-asked only where another leftover hour named current role or a work deep-dive — other loop, not a forecast for Job 10454435.

What you say

I pick one product they named. I speak the problem first, then the modules I shipped, then one resume family. I stop and let them choose a door.

They might ask next

If they ask	You answer
Walk me through your internships.	Dates and what each job was. Horizon February–June 2024: rover software for ERC 2024. Ylogx November 2024–October 2025: production BI. IQVIA April 2026–present: current role, two FastAPI systems. Then stop unless they pick one door.
Which intern ran longest in production?	A date: Ylogx, November 2024 to October 2025. That is chronology, not a contest speech.
Draw it / how does data move?	The numbered flow on that product. Stay on one path.

Keep straight

GraphDB is IQVIA requirement-dependency storage. LangGraph is IQVIA workflow state. They share the word graph. They are not the same component.
Horizon 60 FPS is the rover camera pipeline. Argus 24 FPS is the PPE detector budget.
Ylogx −35% is bot database latency via Redis. sub-210 ms is dashboard serving with no LLM on that GET.
IQVIA has two 200+ families: websites ranked on Deep Research, page BRDs on Hybrid RAG. IQVIA has no extra percent and no latency SLA on the resume.
Argus 73% mAP is a fail for floor alerts. Ship gate is 89% mAP and 24 FPS, then 20+ cameras. mAP is not −50% violations.
StratifyLabs −30% is ML iteration time, not a camera rate. Marketplace 50+ is catalog size, not GPUs.
GiftedBooks GitHub currently describes AegisAI. Resume wins. Disclose the README only if they open GitHub.
valAgent, karyanode, and warpflow are GitHub-adjacent. They are not intern bullets and they do not inherit intern metrics.

Tighten

Do not list StratifyLabs, GiftedBooks, and Argus onto the intern timeline unless they ask for projects. Spoken answers below stay on one product. Leadership Principle spoken STARs live in chapter 3. This page is how the system works.

IQVIA — Software Developer Intern, Apr 2026–present, Kochi

Current role. Two FastAPI-backed LangGraph systems for analysts who cannot treat the first web result as truth and cannot live inside 200+ page BRDs by stuffing a PDF into a context window. Same discipline on both: typed state, tool isolation, cite-or-abstain, LangSmith. Different retrieval. Deep Research ranks across 200+ websites. Hybrid RAG processes 200+ page BRDs with Azure AI Search (Hybrid + Semantic) plus GraphDB. No IQVIA latency or accuracy percent on the resume.

What they might ask

What do you do right now? / Walk me through your current role.
How does Deep Research work? How does Hybrid RAG work?
Why LangGraph? Why GraphDB instead of a bigger vector top-k?
How do you know the model is grounded?

IE-asked current role (GFG 2025 leftover hour, other loop). Resume-derived two systems and both 200+ families. Other loop, not a forecast for Job 10454435.

What you say

Situation. I am a Software Developer Intern at IQVIA in Kochi, April 2026 to present. Analysts in a regulated life-sciences setting cannot treat the first web hit as truth. They also cannot live inside 200+ page BRDs by stuffing a PDF into a context window. Without Deep Research, one scraper or one Google path misses families of pages; a linear chain loses Bing hits when Playwright times out; first-hit ranking looks confident when two credible pages contradict; an empty scrape still feeds a fluent writer. Without Hybrid RAG, vector-only retrieval misses exact clause IDs such as REQ-1044; keyword-only misses paraphrased policy; stuffing 200+ pages invents citations to the wrong annex; “what breaks if this requirement changes” is a dependency edge, not a cosine neighbor, so generated tests hang off the wrong section. Without LangSmith, a professional paragraph and a professional test can both cite the wrong section, and you cannot tell whether the ranker, an empty scrape, or the writer failed.

Task. I needed two retrieval systems with the same gates: stateful orchestration, isolated tools, cite-or-abstain, and a trace that fails if the supporting span is missing.

Action. Deep Research: a planner writes a search plan into LangGraph typed state. Tool nodes fan out in parallel to Firecrawl, Bing, DuckDuckGo, and Google Playwright. Reducers append surviving documents, so a dead Playwright branch does not erase Bing. A checkpoint records progress so one failed domain can resume. A ranker scores source quality, recency, and agreement, and it treats syndicated mirrors as one vote. The writer synthesizes only from ranked evidence; a citation grader may hop back to retrieval with an iteration cap. LangSmith traces node order so an empty scrape reaching the writer is visible.

Hybrid RAG: I ingest a BRD once, chunked by headings, requirement IDs, and table boundaries. I index lexical fields and vectors in Azure AI Search. One hybrid query combines keyword matching with vectors. Azure’s semantic ranker reorders for meaning. If the question is an ID, an impact, or a depends-on, I take a bounded GraphDB hop — one or two hops with a visited set — then fetch the neighbor’s text from the search index. Graph answers structure. Azure answers citeable prose. Adaptive retrieval in LangGraph chooses lexical versus semantic versus hop. The writer sees a small evidence set. No supporting span in retained chunks means no sentence. LangSmith gold items check expected citation IDs. Test-case generation is itself a traced job. Secrets and full confidential bodies stay out of traces.

LangGraph is workflow state: nodes, reducers, checkpoints, bounded cycles. GraphDB is requirement-dependency storage beside Azure. They share the word graph. They are not the same component.

Result. Deep Research: research ranked across 200+ websites. Hybrid RAG: process 200+ page BRDs. Those are two families. The resume has no IQVIA latency or accuracy percentage. Then I stop and let them pick one system.

Data flow — Deep Research

FastAPI accepts the analyst research query.
A planner node writes a search plan into LangGraph typed state.
Tool nodes fan out in parallel: Firecrawl for crawlable HTML, Bing, DuckDuckGo as an independent index, Google Playwright for browser or DOM pages only.
Reducers append surviving documents. A dead Playwright branch does not erase Bing.
A checkpoint records progress so one failed domain can resume.
The ranker scores source quality, recency, and agreement. It rejects empty or boilerplate bodies and detects mirrors so syndicated copies are not extra votes.
The writer synthesizes only from ranked, retained evidence. A citation grader may return to retrieval with an iteration cap.
LangSmith traces node order so an empty scrape reaching the writer is visible. No supporting span, no sentence.

Data flow — Hybrid RAG

Ingest the BRD or PDF once, chunked by headings, requirement IDs, and table boundaries — not a random window on every question.
Index lexical fields and vectors in Azure AI Search.
Issue one hybrid query: keyword or BM25-like matching plus vector.
Azure’s semantic ranker reorders candidates for meaning. I did not train a private embedder.
If the question is ID, impact, or depends-on: a bounded GraphDB hop, one or two hops with a visited set, then fetch neighbor text from the search index.
LangGraph adaptive retrieval chooses lexical versus semantic versus hop. The writer sees a small evidence set, not 200 pages.
Cite-or-abstain: no supporting span in retained chunks, no sentence.
LangSmith gold items with expected citation IDs. Test-case generation is a traced job. Humans spot-check a sample.

What I did not own

Building Azure AI Search itself, or operating a named GraphDB cluster. Skills line says Graph DB (Neo4j); the internship bullet says GraphDB. I speak GraphDB. I do not fake a named cluster.
An IQVIA QPS, bill, uptime, or latency percent — none of those are on the resume.
Sharding a research index, Azure, or a graph cluster.
valAgent. That GitHub ETL validator is adjacent habit, not this intern bullet and not these 200+ numbers.

They might ask next

If they ask	You answer
Why LangGraph instead of a linear LangChain chain?	A sequential plan-scrape-write chain is a linked list of side effects. A Playwright timeout either aborts everything or leaves half-mutated state, and there is no explicit edge for citation failure to return to retrieval. Typed state, parallel tools, append-only reducers, checkpoints, and a bounded retrieve-grade cycle isolate those failures.
Why hybrid plus GraphDB instead of a bigger vector top-k?	Bigger k returns more similar prose. It does not follow an explicit dependency edge, and it still misses rare clause IDs. Hybrid keeps exact tokens such as REQ-1044 beside paraphrases. GraphDB walks stored depends-on edges. Neighbor text still comes from Azure — the graph does not replace citeable prose.
Hybrid versus Semantic — are those the same stage?	No. Hybrid combines lexical and vector retrieval in one query. Semantic is Azure’s reranker over that candidate set. Two stages, two failures.
How does LangSmith fail if there is no span?	Gold items expect citation IDs. Cite-or-abstain: no supporting span in retained chunks means no sentence. A professional paragraph that cites annex B when gold expects section 4.2 fails the item. The first fix is retrieval, not a louder writer prompt. LangSmith has no pass-rate on the resume. I speak the gate, not an invented score.
Can the research graph loop forever?	No. Retrieve → grade → retrieve has an explicit maximum iteration count, then escalate or abstain. Fluency is not a reason to keep looping.
What is state?	Typed workflow data: query, documents, ranks, answer, errors. Nodes return partial updates. A checkpoint persists progress after a node.
10× honesty?	I did not shard a research index, Azure, or a graph cluster. I have no IQVIA QPS, bill, or latency percentage. More of the mechanism that already worked: cap fan-out, cache completed scrapes, snippets before full Playwright, resume from checkpoints, retrieve a small set, bound graph hops, grow a frozen gold slice before adding a fifth tool. Ten times more BRDs without cite-or-abstain is ten times more fluent errors.
What must GenAI not do on this path?	Decide authorization. Convert a failed scrape or empty body into a fact. Loop because prose still sounds plausible. Repair a missing gold clause by inventing connective tissue. Hallucinate a GraphDB edge or expand hops without a bound. Grade its own grounding without structured evidence. Approve logging full confidential BRDs. Hide disagreement by averaging contradictory requirements. Count syndicated mirrors as independent confirmation. The model may plan, retrieve-adapt, and synthesize cited evidence, or abstain.
How do you know the metric?	200+ websites is Deep Research coverage. 200+ pages is Hybrid RAG document size. Two families. The resume has no IQVIA accuracy or latency percentage. I will not borrow Ylogx −35%, sub-210 ms, GiftedBooks sub-300 ms, or Argus mAP.
Conflict — hybrid versus vector-only?	Vector-only misses rare clause IDs. I disagree on retrieval, then commit on evals: a generated test with no overlapping span fails. I do not invent the other person’s words. This is Backbone on this intern, not a second intern’s story.
Did you train embeddings?	I do not claim a private embedder. The resume claim is managed Hybrid + Semantic retrieval.
Was fluent-wrong a named outage?	No. It is the class the architecture prevents: empty scrape as fact, vector-only miss, invented graph edge. I do not invent a ticket or a customer name.

Keep straight

200+ websites ranked is Deep Research. 200+ page BRDs is Hybrid RAG. They are not one number.
IQVIA has no extra percent and no latency SLA on the resume. 99.9% and sub-210 ms are Ylogx. sub-300 ms is GiftedBooks.
LangGraph is workflow state. GraphDB is requirement-dependency storage. Azure Hybrid + Semantic is retrieval. Three different pieces.
LangSmith is IQVIA. The Ylogx chatbot is LangChain SQL RAG. JWT and three-tier RLS are Ylogx, not this intern.
FAISS is a skills line. IQVIA intern retrieval is Azure AI Search plus GraphDB. Qdrant was not shipped.
valAgent does not inherit 200+ websites or 200+ page BRDs.
Dive Deep primary is Ylogx Redis plus RLS. IQVIA ranking contradiction is Dive Deep backup. Invent, Learn, and Backbone are the IQVIA primaries.

Tighten

Stop after the two systems unless they pick Deep Research, Hybrid RAG, GraphDB, or LangSmith. If this intern already appeared: Invent backup is StratifyLabs −30% and marketplace 50+. Learn backup is Horizon ROS2 plus GStreamer plus ZED. Backbone backup is Ylogx RLS-in-database versus app-only WHERE. A backup is a second story, not a fourth trophy on IQVIA.

Ylogx — Software Developer Intern, Nov 2024–Oct 2025, remote

A year of production BI. Custom report builder, LangChain SQL RAG chatbot, 30 KPI dashboards. NestJS owns auth, RBAC, reports, and deterministic dashboard REST. FastAPI owns SQL RAG only. Postgres holds facts and row-level security for three organizational tiers. Redis is cache-aside on the bot path. Dashboards have no LLM on the GET. Serving is CloudFront for static assets, Route 53, ALB, ECS, Docker. 40% faster reports, +65% analysis productivity, −35% bot DB latency, +60% ops on 30 dashboards, sub-210 ms serving, and 99.9% uptime are different families.

What they might ask

Walk me through the Ylogx product.
How does isolation work? Why Redis? Why no model on the dashboards?
Last time you deep-dived a bug / something that was not only your ticket.

IE-asked deep-dived a bug (GFG 2025 leftover hour, other loop). Resume-derived mechanisms. Other loop, not a forecast for Job 10454435.

What you say

Situation. At Ylogx, from November 2024 to October 2025, operators and non-SQL users needed custom reports, ad-hoc questions, and live KPI tiles over shared warehouse facts — without one organizational tier reading another. Without the split, one Flask god-object couples auth, report CRUD, dashboards, and model SQL. Without SQL RAG, pasting warehouse rows into a prompt truncates data and invents totals, and pasted facts cannot inherit Postgres row security the way an executed query can. Without Postgres RLS, an app-only WHERE org_id = ? dies on the first missed JOIN, copied handler, or generated SQL that skips the helper; HTTP 200 with a legal JOIN is still a leak. Without RBAC, row filters do not decide whether a caller may hit an admin export. Without Redis on the bot path, every natural-language turn repeats schema and hot analytics against Postgres, experienced as “the model is thinking.” Without keeping the model off dashboards, 30 tiles become 30 variable generations, inventable KPIs, and the sub-210 ms claim dies. Without CloudFront to ALB to ECS, one mutable VM is deploy, health, routing, and static delivery in one failure domain.

Task. I needed three lanes over one warehouse, three organizational tiers, and a serving path that does not put generation on the KPI GET.

Action. NestJS owns authentication, route-level RBAC, report CRUD, and deterministic dashboard REST. FastAPI owns LangChain SQL RAG only. Generated SQL runs read-only as the caller’s non-owner database role, never table owner, so RLS still filters a JOIN that is too broad. Redis is cache-aside on the bot path; keys carry tier and role. Dashboard GETs never call the model. React and Recharts in the browser. CloudFront for static assets only — private tenant JSON is not an edge-cache object. Route 53 after GoDaddy registrar, ALB health checks, healthy ECS tasks running Docker images, CI/CD rolling replacement.

Result. Those numbers live on different paths. 40% faster reports is the builder. +65% analysis productivity is SQL RAG. −35% is bot database latency via Redis. 30 dashboards with +60% ops, and sub-210 ms, are deterministic serving with no LLM. 99.9% uptime is the deploy path, not a model-vendor SLA. I do not have baseline n, p95, or TTL on the resume. Then I stop and offer one door: isolation, bot latency, or dashboards without the model.

Data flow — browser to data

React and Recharts: report editor, 30 KPI dashboards, chatbot UI.
CloudFront: static assets only. Private tenant JSON is not an edge-cache object.
Route 53 (after GoDaddy registrar) to ALB: L7 routing and health checks.
Healthy ECS tasks running Docker images for NestJS and FastAPI. CI/CD rolling replacement, not SSH-patch a box.
NestJS: identity, RBAC, report CRUD, deterministic dashboard REST.
FastAPI: LangChain SQL RAG only.
Redis: cache-aside on the bot path; keys carry tier and role.
Postgres: facts, joins, aggregates, transactions, RLS for three tiers. Generated SQL executes as the caller’s non-owner database role.

Data flow — SQL RAG

A natural-language analytics question arrives with caller identity and organizational tier.
Redis GET on a tier- and role-scoped fingerprint (schema metadata or a repeat answer). A hit returns only inside that isolation context.
Miss: retrieve allow-listed schema and metric definitions. Prompt constrained to SQL only.
Parse and reject catalog, writes, unknown tables; time and row caps; parameterized.
Execute read-only as the caller database role. RLS still filters rows if the JOIN is too broad.
Return inspectable SQL plus the result. Redis SET of the safe payload only. Redis down means Postgres as the same role — never owner, never fail-open RLS.

The model is the interface. Postgres is the calculation engine.

Data flow — dashboards (LLM off this path)

Browser loads JavaScript from CloudFront.
The view requests deterministic KPI JSON.
ALB to NestJS: identity plus RBAC.
Pooled Postgres with RLS. Optional application cache of safe aggregates only.
API returns numbers and labels — not generated prose.
Recharts renders.
Ad-hoc English stays on the separate Redis → SQL RAG path.

What I did not own

A named SRE on-call title. I was an intern. We promote after gates; I enforced role, no-LLM-on-tiles, and deny fixtures.
Sharding Postgres or Redis. Multi-region. An AWS bill, p95, or TTL.
Kubernetes, Kafka, EKS, or a JVM/Spring rewrite. This intern used Python FastAPI, TypeScript NestJS, and Postgres. Live Code is Java. Spring, Kafka, and EKS are not on this intern’s bullets, so I do not describe Ylogx as if they were.
warpflow and Conv-BI. Those GitHub artifacts are adjacent. They are not this intern product.

They might ask next

If they ask	You answer
Why Postgres RLS instead of app-only WHERE?	An app-only `WHERE org_id = ?` dies on the first missed JOIN, copied handler, or generated SQL that skips the helper. SQL RAG increases that surface. NestJS RBAC decides whether the caller may hit the route. Postgres RLS decides which rows exist for that role. I map identity to a non-owner database role. Policy evaluates on ordinary reads and on generated reads. Cross-tier deny fixtures assert that forbidden rows are absent. I speak org-, team-, and user-shaped levels. Literal tier names are not on the resume.
Why Redis instead of a bigger RDS first?	Without Redis on the bot path, every NL turn repeats schema lookup and hot analytics. Users hear that as “the model is thinking.” A bigger RDS repeats the same work. Redis as source of record would lie when the warehouse moved. Keys from raw English only would share “top SKU” across tiers. Cache-aside key is tier, role, and a fingerprint. Resume result: −35% bot database latency. That is not dashboard latency.
Why not CloudFront for bot answers?	Private tenant JSON is not a public edge object. CloudFront is static React. Redis is the bot reuse layer with identity in the key.
Why no LLM on the 30 dashboards?	Thirty tiles would become thirty variable generations. KPIs become inventable. Availability couples to a model vendor. Sub-210 ms cannot hold. The 30 dashboards are deterministic SQL or a safe aggregate, then Recharts. Ad-hoc English stays on SQL RAG. +60% ops and sub-210 ms live on that GET. Redis −35% does not.
Why NestJS and FastAPI instead of one monolith?	NestJS fit typed auth and business modules. FastAPI fit the Python SQL-RAG libraries. Postgres stayed the system of record because BI needs joins, aggregates, transactions, and row security.
Why not dump 90 days of rows into the model?	Rows truncate, totals get invented, and pasted facts cannot inherit RLS the way an executed query can. Aggregation happens in SQL.
Wrong-org JOIN?	Syntactically valid SQL returns another organization’s rows through a mapping table. HTTP 200 is green. Defense: caller role, RLS on joined protected tables, route-level RBAC, deny fixtures that assert zero foreign rows, cache keys that cannot serve the leaked payload. The model does not “remember org_id.” This is a failure class the architecture prevents. I do not invent a ticket, customer, or outage duration.
Cache without tier?	Identical English, “top SKU,” shared across tiers. A raw-English Redis key returns the wrong organization’s answer. That hit looks like a latency win. It is a leak. Key equals tier, role, query fingerprint, and schema version. Redis down: same caller role against Postgres, never owner.
Dev / QA / prod?	Environments and blast radius, not ticket IDs and not invented private names. Dev is the cheapest blast radius: non-owner SQL, cache miss plus Redis fallback, KPI GET without the model. QA is three roles: allow and deny fixtures, denied JOINs, golden NL to SQL shape, wrong-role cache keys, Redis-down fallback, all 30 dashboards without generation. Prod is the same gates with a larger blast radius. A new image tag is not a safety proof. I did not shard.
10× honesty?	I did not shard Postgres or Redis. I did not rewrite onto Kubernetes, Kafka, or a JVM. I did not operate multi-region. No AWS bill, p95, or TTL. First: more RLS and deny fixtures as tables grow, role-correct pools, tier-safe cache coverage, query shape and N+1 removal, then more ECS desired tasks. A read replica for deterministic dashboards is a would-do, not a shipped claim. Ten times users without RLS is ten times leak. Ten times ECS without deny tests is the same leak, faster.
What must GenAI not do on this path?	Author RLS policy, assign roles, or approve JOINs. Own database credentials or run as table owner. Execute writes from NL. Replace SQL aggregation. Decide whether a cache entry is authorized or build the isolation key. Calculate the 30 KPI tiles, or sit on the sub-210 ms path. Decide DNS, health checks, secret placement, or rollout approval. SQL RAG is allowed only as constrained NL → SQL after those walls.
How do you know the metric?	Each resume number maps to one path. 40% is the report builder. +65% is SQL RAG analysis productivity, not model accuracy. −35% is bot DB via Redis. +60% and sub-210 ms are dashboards with no LLM. 99.9% is serving and deploy. Three tiers is RLS plus RBAC product shape. I will not invent sample size, p95, TTL, or a missed 99.9%.
GoDaddy versus Route 53?	GoDaddy is registrar. Route 53 is the hosted zone that Alias-routes to CloudFront or ALB. DNS does not fix RLS and RLS does not fix DNS.

Keep straight

40%, +65%, −35%, +60%, sub-210 ms, and 99.9% are six families on this intern. They are not one number.
−35% is bot DB latency. sub-210 ms is dashboard serving. They are not interchangeable.
99.9% uptime is Ylogx. GiftedBooks hosting is 99.5%. IQVIA has no uptime percent.
The chatbot is LangChain SQL RAG. LangGraph and LangSmith are IQVIA.
Redis on this intern is the bot path. Dashboards are deterministic NestJS REST plus Postgres RLS.
Kubernetes and GraphQL are skills-line knowledge. What shipped here is ECS, REST, Postgres.
Ylogx primaries are Ownership, Frugality, and Dive Deep (Redis and RLS together). SEO 403 is prep-only, not the Dive Deep lead.

Tighten

Offer one door after the pitch: isolation, bot latency, or dashboards without the model. Do not recite every percentage again as if they were one number. If this intern already appeared: Ownership backup is Horizon GStreamer plus costmap. Frugality backup is Horizon fusion versus extra hardware. Dive Deep backup is IQVIA ranking contradiction. Do not spend a fourth Ylogx primary in the same hour.

Horizon — Software Developer Intern, Feb–Jun 2024, Kochi

Team Horizon rover software for ERC 2024. ROS2. I was a core software member, not team lead. A rover that only sees pixels still collides. Operators need the newest frame, not a stalled historical stream. A live video feed is not a costmap. GStreamer 60 FPS is the camera pipeline. ZED 2 is 2M+ points per second incoming. Costmap fusion is occupancy. 17th of 80+ is we.

What they might ask

Walk me through the rover work.
How did you hit 60 FPS? What is a costmap?
Handled a strict deadline / Bias for Action / Deliver Results.

IE-asked deadline and Bias-shaped leftover hours in other loops. Resume-derived camera, mapping, costmap. Other loop, not a forecast for Job 10454435.

What you say

Situation. I was a Software Developer Intern on Team Horizon in Kochi, February to June 2024, core software on a semi-autonomous Mars rover in ROS2. A rover that only sees pixels still collides. Operators need the newest frame, not a stalled historical stream. Dense stereo points saturate a link if every consumer gets the full cloud; thinning before the planner erases the obstacle. Buying another sensor near a fixed ERC date adds drivers, calibration, and integration delay while time alignment and planning stay unsolved. A live video feed is not a costmap.

Task. I needed a current operator camera, mapping that keeps local density for planning, and a fused costmap the planner can trust — under a contest date that does not move.

Action. I owned software around the camera pipeline, ZED mapping, and costmap. GStreamer delivers a 60 FPS operator feed over UDP-family transport: drop stale packets rather than stall later bytes. ZED 2 produces 2M+ points per second incoming; planning keeps local density; RViz gets a downsampled branch. Other onboard sensing enters ROS2 on separate nodes. Transforms and timestamps go into a shared frame. Fusion writes occupied, free, and uncertain cells. Predictive planning reasons over that grid, not raw pixels. Under the ERC date we fused sensors we already had instead of buying another unit the week of the contest. I am not a manager. I am not team lead.

Result. Resume: 60 FPS on the camera pipeline, +40% obstacle detection, −55% collision risk, ZED 2 at 2M+ points per second. The team placed 17th among 80+ at ERC 2024. Placement is we. I will not invent sample size. Then I stop and let them pick 60 FPS, stale occupancy, or fusion versus extra hardware.

Data flow — camera pipeline (60 FPS, not a detector)

Camera captures the newest frame.
GStreamer source, then convert or encode.
Packetize for UDP-family transport.
Send without waiting to retransmit stale packets.
Receiver depayloads and decodes what arrived.
Operator display prefers current video over perfect historical delivery.
Autonomy consumers stay on the separate ZED and costmap path.
Field tests — loss, dust, lighting. A desk demo is not the metric.

Resume prints GStreamer at 60 FPS. UDP-family is the Standard CS transport that matches drop-over-stall live video. TCP retransmission after loss can block later bytes and freeze a naive MJPEG stream while the rover still moves. Packet N is lost; N+1 is newer. A TCP path holds N+1 until N retransmits. This path can display the newer decodable frame.

Data flow — ZED mapping versus visualization

ZED 2 captures synchronized stereo and depth.
A ROS2 mapping node produces dense points — 2M+ per second incoming rate, not a promise to stream every point to a laptop.
Transform into the rover frame with timestamps.
Planning retains local density for occupancy.
The costmap consumes that occupancy.
A separate branch downsamples for RViz or offboard display.
Gazebo exercises the node graph. Sim is not dust, lighting, or physical timing.
Time alignment so a visually live feed cannot mask stale occupancy.

Data flow — fusion and costmap

Operator camera: 60 FPS view — infrastructure, not a detector score.
ZED 2: depth and dense points.
Other onboard sensing enters ROS2 on separate nodes.
Transforms and timestamps into a shared frame.
Fusion writes occupied, free, or uncertain costmap cells.
Predictive planning reasons over that costmap, not raw pixels.
Planner selects a path under latest occupancy; actuation executes.
Sim and field expose stale-map and dust failures.

What I did not own

Team-lead title. Hardware design of the rover. 17th place as a solo result.
A GPU name, radio spec, voxel size, or bill of materials.
YOLO on the rover. An LLM on occupancy. Those are not resume claims on this intern.
The public Gstreamer-UDP webcam repo as a second internship. It is a supporting analogue for pipeline shape, not rover metrics.

They might ask next

If they ask	You answer
Why UDP-family instead of TCP MJPEG?	An operator needs the newest frame. TCP retransmission after loss can stall later bytes. UDP-family is drop-over-stall for live video, not “more reliable.” The resume prints GStreamer at 60 FPS. I will not claim WebRTC, 120 FPS, or a radio BER.
Why not one pretty point cloud for everyone?	Visualization wants a light picture. Planning wants local density. Blind thinning before the costmap can mark a ridge as free. 2M+ is incoming mapping rate, not a laptop stream.
Why fuse into a costmap instead of buying another sensor?	Near a fixed ERC date, extra hardware adds drivers, calibration, and delay while time alignment and planning stay unsolved. A giant vision model can label pixels and still leave no occupancy grid. Bump-and-turn reacts after contact. Heterogeneous sensors contribute to one spatial risk representation. Horizon primaries for this intern are Bias for Action and Deliver Results. Fusion versus extra hardware can support Frugality as a backup story. Ylogx Redis remains primary Frugality if they name that principle and have not used Ylogx yet.
Stale occupancy versus a healthy 60 FPS feed?	The operator feed can be current while the costmap is late. Transforms or queues sit one cycle behind. RViz looks healthy because visualization was downsampled and refreshed. The planner drives free cells that are no longer free. Camera 60 FPS does not prove the costmap is live. They are different consumers. Defense: timestamps in a shared frame, fusion that will not write occupancy from stale observations, field tests that desk Gazebo will not show. ERC was not missed. Sequencing risk is “the costmap is stale,” spoken early, without inventing a miss.
What were predictive algorithms?	Planning over fused occupancy through time — not a red-pixel stop rule.
10× honesty?	A rover is not a SaaS camera-count problem. I did not shard a map. Higher resolution or bitrate: downsample the operator view; keep what local planning needs. Higher speed: tighter time sync first — stale occupancy gets more dangerous. More sensors still feed one bounded costmap, not ten times more unintegrated hardware the week of the contest. I will not invent voxel size, GPU name, or a bill.
What must GenAI not do on this path?	Packet recovery or frame scheduling. Depth-to-occupancy conversion or time synchronization. Emit costmap cells, select motor commands, or replace fusion. Turn stale video or a fluent scene caption into current occupancy. Sit on the safety-critical loop. No LLM on the costmap.
How do you know the metric?	60 FPS is the camera pipeline. 2M+ is incoming mapping rate. +40% obstacle and −55% collision are perception and planning outcomes on the resume. I will not invent sample size. 17th of 80+ is team placement. ERC listed twice on the resume is the same 2024 result.
I versus we?	I owned core software around camera, mapping, and costmap. Placement 17th is we.

Keep straight

60 FPS is this camera pipeline. Argus 24 FPS is a PPE detector budget. StratifyLabs −30% is ML iteration time.
+40% obstacle and −55% collision are rover outcomes. Argus mAP and Argus −50% violations are a different product.
Horizon is a competition rover, not a SaaS internship.
No YOLO-on-rover resume claim. No LLM on occupancy.
I was core software, not team lead. 17th of 80+ is we.
Horizon primaries: Bias for Action, Deliver Results, Earth’s Best Employer (launch knowledge not one head).

Tighten

Let them pick 60 FPS, stale occupancy, or fusion versus extra hardware. If this intern already appeared: Bias backup is eight named hackathons. Deliver backup is Ylogx 40% faster reports plus 99.9%. Earth’s Best backup is IEDC pairing. Do not I-wash 17th.

Argus — Industrial Safety AI (technical project)

YOLOv9 PPE compliance and attendance. Devfolio. 73% mAP is a fail for floor alerts: it misses violations and also proposes junk boxes. Ship bar is 89% mAP and 24 FPS on 15,000+ images, then 20+ containerized cameras. Postgres stores events, not video blobs. −50% violations and 2× compliance are operational after alerts existed. They are not mAP. Public API README unavailable — no invented routes.

What they might ask

Walk me through Argus. / A project you completed on your own.
Last negative feedback / a time you were wrong.
How did you go from 73% to 89%? Why 24 FPS before more cameras?

IE-asked negative feedback and completed-on-your-own in other leftover hours. Resume-derived gate and runtime. Other loop, not a forecast for Job 10454435.

What you say

Situation. Argus is a real-time computer-vision system for industrial PPE compliance and attendance. Industrial PPE needs boxes and classes while the event is still actionable. At 73% mAP on held-out, IoU-thresholded boxes, the detector misses too many violations and also proposes junk boxes. Either one trains people to ignore alarms. Scaling that detector to many cameras multiplies misses and alarm fatigue. A laptop GIF is not a live safety product. Files-only or dashboard-only cannot answer “camera 7, Tuesday 18:04, no-helmet.” Video blobs in Postgres make every backup carry media. An LLM caption is not an IoU-gated box.

Task. I needed an honest quality gate before scale: held-out mAP plus an end-to-end frame budget, then events operators can query.

Action. First move was data plus an evaluation gate, not a bigger backbone. Lighting, PPE variation, and rare no-helmet misses are coverage failures. I iterated data and configuration on 15,000+ images until 89% mAP. I did not tune NMS or confidence on the quoted test set. I verified end-to-end 24 FPS — decode, infer, NMS, I/O, not notebook forward-ms only — and then replicated across 20+ containerized camera feeds. Runtime drops stale frames rather than queue delayed alerts. OpenCV decodes and resizes. YOLOv9 one-stage produces boxes, objectness, and PPE classes. Confidence filter, then NMS. Structured event: camera, class, confidence, timestamp, box. Postgres persists the event. Bulk video stays out of the relational table. Alerts read persisted events. Site process: humans act.

Result. 73% to 89% mAP on 15,000+ images. 24 FPS. Then 20+ cameras. After alerts existed, violations were down 50% and compliance 2×. Those last two are operational outcomes, not mAP. I will not invent a split ratio, a causal study, or a manager quote. Then I stop.

Data flow — quality gate (before scale)

Measure the honest starting detector: 73% mAP. Treat as not ready to page the floor.
Inspect error classes (lighting, PPE variation, rare no-helmet). Train and eval on 15,000+ images. Split ratios are not on the resume. I do not tune NMS or confidence on the quoted test set.
Iterate data and config while preserving the evaluation gate until 89% mAP.
Verify end-to-end 24 FPS (decode + infer + NMS + I/O, not notebook forward-ms only).
Then replicate across 20+ containerized feeds.

Data flow — runtime (events, not JPEGs)

Ingest worker receives a frame. Drop stale frames rather than queue delayed alerts.
OpenCV decode and resize. That is preprocessing, not a cascade origin story.
YOLOv9 one-stage: boxes, objectness, PPE classes, multi-scale features.
Confidence filter; NMS. Over-aggressive NMS can merge two nearby workers.
Structured event: camera, class, confidence, timestamp, box.
Postgres persists the event for attendance and audit. Bulk video stays out of the relational table.
Alert path reads the persisted event. Operators query by camera and time.
Site process: humans act on alerts. Ops metrics are a later family.

What I did not own

Plant-floor behavior after alerts. −50% violations and 2× compliance involve the site. I owned train and eval, the mAP plus FPS gate, NMS, and the event log.
A GPU name, Kubernetes-as-Argus, retention days, or an image count beyond 15,000+.
API routes. The public README is unavailable, so I do not invent them.
Haar, HOG, YOLOv8, or ByteTrack as a shipped Argus attempt. Haar and HOG are Standard CS alternatives — brittle on pose, occlusion, vest color, helmet versus hair. Resume detector is YOLOv9.

They might ask next

If they ask	You answer
Why a data gate instead of a bigger backbone?	The error classes I saw were coverage, not “the backbone is too small.” A heavier backbone per stream breaks 24 FPS. Shipping the 73% demo, hiding behind a confidence tweak, or calling 73% good enough while wiring alerts would scale alarm fatigue. One-stage YOLO already served the throughput constraint.
Why not a two-stage detector?	Two-stage proposal-then-classify leans accuracy and risks the 24 FPS multi-camera budget. I do not claim a full Detectron bake-off on 20 cameras.
Why Postgres events instead of JPEG blobs or files only?	Files without event rows cannot answer which detection fired on camera 7 at a given time. JPEG blobs make every backup carry media. Object storage is the usual conceptual place for bulk media. I do not invent a bucket, retention days, or Kafka topics. The shipped fact is Postgres logging.
How does mAP relate to −50% violations?	It does not equal them. mAP is held-out detector quality. −50% and 2× are operational after alerts existed. Loop is detect, persist, notify humans, behavior. I will not invent a causal study, sample size, or manager quote tying mAP to 2×.
Is 73% “progress”?	No. 73% is a fail for alerting: misses plus junk boxes. The only past-tense line if they want a mistake is: I wrongly treated a rising notebook score as launch-ready. One judgment: not shippable for floor alerts. Then 89% mAP and 24 FPS, then 20+ cameras.
10× honesty?	I did not shard Postgres. Keep the 89% mAP and 24 FPS gates. Workers or batching only if latency holds. Drop stale frames. Store events, not JPEG blobs. Refuse to multiply a 73% system. Ten times cameras at 73% mAP is ten times ignored alarms. A held-out camera is a would-do. I will not claim 10× FPS. I will not invent a GPU name.
What must GenAI not do on this path?	Generate PPE boxes or replace YOLOv9. Relabel 73% as acceptable because a caption looks compliant. Be the official event record or invent a missing detection. Authorize alerts or expose unauthenticated camera streams. Auto-label all 15k images as a resume claim (not stated). Bounding boxes plus mAP plus FPS are the source of truth. Grounded LLMs belong on IQVIA and on Ylogx SQL RAG — not on PPE boxes.
How do you know the metric?	73→89 mAP is held-out detector quality. 24 FPS is the live budget. 15,000+ is dataset size. 20+ is feeds after the gate. −50% and 2× are ops after alerts. Separate families. No invented split ratios.
Was this a Ylogx downtime story?	No. This is a quality-gate story. 99.9% is a Ylogx serving number. I do not invent a missed SLA to create a calendar failure.

Keep straight

73% mAP is a fail for floor alerts. 89% mAP plus 24 FPS is the ship gate. Then 20+ cameras.
mAP is not −50% violations and is not 2× compliance.
24 FPS is this detector budget. Horizon 60 FPS is a rover camera pipeline. StratifyLabs −30% is iteration time.
Postgres events are not JPEG blobs.
Argus primaries: Are Right, Highest Standards, Success and Scale. Success and Scale is 20+ cameras after 89% and 24 FPS, not 73% multiplied.
TensorFlow is a skill, not an Argus serving story. TensorRT and INT8 are not claims.

Tighten

Stop after gate, then cameras, then ops as a later family. If this project already appeared: Are Right backup is Ylogx measured bot-DB −35%. Highest Standards backup is Ylogx 99.9% / sub-210 ms dashboards. Success and Scale backup is Ylogx ALB/ECS with RLS already on. Do not spend a fourth Argus primary in the same hour.

GiftedBooks — VR learning suite (giftedbooks.study)

Technical project. Students had 3D labs and avatars but still waited hours on doubts from their own material. Retrieve-then-generate over that student’s PDF. PYQ topic ranking is a separate deterministic pass over past papers. sub-300 ms is this API. 99.5% is this hosting. Doubts hours → 3–10 min is the customer-facing time. Resume wins if GitHub currently describes AegisAI. Disclose that README only if they open GitHub.

What they might ask

Walk me through GiftedBooks. / Extra for customers. / Earn Trust.
How does the PDF Q&A work? Why not a generic tutor?

Resume-derived product. Customer Obsession and Earn Trust spoken STARs also live in chapter 3.

What you say

Situation. GiftedBooks is a VR learning suite with 3D labs and AI avatars. Students still waited hours on doubts from their own material. A generic tutor hallucinates a syllabus or uses a formula that is not in the uploaded PDF. Stuffing a textbook every question blows latency and grounding. Mixing users’ PDFs is a trust failure even if latency looks good. An LLM “predicting” the exam presents speculation as analysis.

Task. I needed answers from that student’s file, quickly enough to keep the learning flow, without inventing syllabus and without mixing notes.

Action. Authenticate the student at the API. Secrets stay off the client. Accept that student’s PDF. Chunk with enough context for a table or derivation — too small drops caption and units; too large hurts retrieve and sub-300 ms. Embed once at ingest. Store vectors with user and document metadata. At question time, retrieve a small user-scoped top-k. Never another student’s notes. Generate a concise answer from retained spans, or abstain. PYQ topic ranking is a separate deterministic pass over past papers, not the generator guessing the exam. VR labs and avatars are the client experience around this path. I do not claim every avatar asset.

Result. Doubts moved from hours to 3–10 minutes. Reading efficiency +35%, engagement +50%, comprehension 2.5×. API path sub-300 ms. Hosting 99.5% uptime. Those learning percentages have no student headcount or study protocol on the PDF. Then I stop. I do not volunteer the GitHub README unless they open the repo.

Data flow — student PDF retrieve-then-generate

Authenticate the student at the API. Secrets stay off the client.
Accept that student’s PDF.
Chunk with enough context for a table or derivation.
Embed once at ingest. Store vectors with user and document metadata.
Question time: user-scoped small top-k. Never another student’s notes.
Generate a concise answer from retained spans, or abstain.
Return on the sub-300 ms API path. 99.5% is hosting, not model intelligence.
PYQ topic ranking is a separate deterministic pass over past papers.

What I did not own

Every 3D lab or avatar asset.
LangSmith here. Citation eval is a would-add, not a did. LangSmith is IQVIA.
A student headcount. The resume does not give one.
AegisAI features. If they open GitHub, I label the mismatch in the first sentence, then speak GiftedBooks from the Aug 2026 resume.

They might ask next

If they ask	You answer
Why retrieve-then-generate instead of a generic tutor or whole-PDF context?	A generic tutor answers from a corpus that is not the uploaded PDF and sounds helpful. Dumping the textbook every question blows tokens, latency, and the trust boundary. Retrieval keeps a small evidence set from that student’s file. Abstain when no span exists.
Why is PYQ not the LLM?	Exam-topic ranking is frequency over past papers. Letting the model “predict” the exam presents speculation as analysis.
Did this use Azure, GraphDB, or LangSmith?	No. Azure Hybrid + GraphDB + LangSmith is IQVIA. FAISS is a skills line. This is the vector plus user/document metadata lane. I do not invent a cluster topology. Qdrant was not shipped.
Is fast the same as faithful?	No. Sub-300 ms is the API path. Faithfulness is the span gate.
10× honesty?	I did not shard the index. The resume gives no student headcount. Ingest each PDF once, cache safe retrieval, keep top-k and generation bounded, preserve user and document metadata on every lookup, never re-embed a book per question. Ten times PDFs without metadata isolation is a trust failure, not a latency win.
What must GenAI not do on this path?	Guess PYQ or exam trends. Bypass per-user document isolation. Treat latency as proof of faithfulness. Answer from a generic tutor corpus when the student’s PDF is the source of truth. Inherit IQVIA Azure/GraphDB/LangSmith or AegisAI README behavior.
How do you know the metric?	Sub-300 ms is this API. 99.5% is this hosting. +35% reading, +50% engagement, 2.5× comprehension, and hours → 3–10 min are resume outcomes. I will not invent student n or a study protocol.
They opened GitHub and the README says AegisAI.	First sentence: the current README describes AegisAI; that is a mismatch; the product I will defend is GiftedBooks from the Aug 2026 resume. Then the PDF RAG path above. I would fix the README. I do not mix AegisAI features or metrics. Earn Trust can carry that one honest sentence. Customer Obsession stays hours → 3–10 min on grounded Q&A, not the README.

Keep straight

sub-300 ms is GiftedBooks. sub-210 ms is Ylogx dashboards. IQVIA has no latency percent.
99.5% uptime is GiftedBooks hosting. 99.9% is Ylogx.
This product is not the AegisAI README. Resume wins.
PYQ analytics is not RAG generation.
Customer Obsession primary is hours → 3–10 min. Earn Trust primary is grounded RAG plus 99.5%, and the README sentence only if they open GitHub.

Tighten

Stop after retrieve-then-generate, PYQ separate, and the 3–10 min result. Do not volunteer AegisAI. If this project already appeared: Customer backup is Ylogx SQL RAG +65% still behind three-tier RLS. Earn Trust backup is Ylogx three-tier RLS and the JOIN-leak class named out loud.

StratifyLabs — Computer Vision SaaS (stratifylabs.design)

Technical project. Browser 3D simulation lab. −30% is ML iteration time through a shorter edit-infer-inspect loop in the tab. It is not FPS. Marketplace 50+ is a catalog of pretrained models and datasets, not 50 GPUs. URDF editor with WebGL. Gemini RAG voice bots receive current scene context. Default Next.js GitHub README does not replace resume facts. Resume wins.

What they might ask

Walk me through StratifyLabs. / Idea for a major project. / Think Big.
How did you cut iteration time 30%? What is the marketplace?

Resume-derived product. Think Big primary. Invent backup only — IQVIA Hybrid RAG remains Invent primary.

What you say

Situation. StratifyLabs is a computer-vision training platform with a 3D simulation lab in the browser. A notebook or native simulator per person turns every small experiment into environment setup or GPU scheduling. A one-model demo disappears with its author. A generic chatbot cannot speak to the current simulated scene. A full native robotics workstation is the wrong entry cost for this SaaS.

Task. I needed a short edit-infer-inspect loop in the browser, a shared catalog so experiments reuse, and bots that see the current scene.

Action. The web client opens the shared lab. A URDF editor changes robot or scene structure. WebGL renders the current scene. Small supported models run browser inference where the user is iterating. Large training stays off the interactive request path. A marketplace exposes 50+ pretrained models and datasets as reusable catalog items, with community profiles. Gemini RAG voice characters receive current scene and URDF context. Three.js is a skill. The resume claim I defend is URDF plus WebGL and the 3D lab.

Result. −30% ML iteration time through that shorter loop. 50+ is catalog size, not GPUs. I will not invent sample size, user count, or cluster capacity. Then I stop.

Data flow — edit, infer, catalog, scene bot

Web client opens the shared 3D simulation lab.
URDF editor changes robot or scene structure.
WebGL renders the current scene in the browser.
Small supported models run browser inference where the user is iterating.
Large training stays off the interactive request path.
Marketplace exposes 50+ pretrained models and datasets; community profiles make experiments shareable.
Gemini RAG voice characters receive current scene and URDF context.
User edits, infers, inspects. The short loop is the product.

What I did not own

A training cluster, GPU name, or user count.
LangSmith. A current-scene eval for bots is a future improvement, not a shipped claim.
Three-tier RLS evidence. User and dataset isolation is required here; the deep three-tier internship story stays on Ylogx.
karyanode. That GitHub module can optionally spawn ports. It does not inherit −30% or marketplace 50+.

They might ask next

If they ask	You answer
Why browser inference instead of a full training box per user?	Iteration was the product. Browser inference removes setup for small experiments. Big training remains off the click path so tab memory does not kill the loop the −30% is about.
Why a marketplace instead of one demo model?	A one-model demo disappears with its author. Fifty-plus catalog items are reusable pretrained models and datasets, plus community profiles. 50+ is not 50 GPUs and is not Argus 20+ cameras.
Is −30% an FPS improvement?	No. It is ML iteration time. Horizon owns 60 FPS. Argus owns 24 FPS.
Did you use Three.js? Is this the rover Gazebo stack?	Three.js is a skill. I defend URDF plus WebGL. Horizon is a field rover. This is a browser CV lab.
They opened GitHub and the README is create-next-app.	First sentence: the README is the Next.js default; the product I will defend is stratifylabs.design from the resume. Frontend on GitHub is the client. I do not improvise features because a scaffold README is empty.
10× honesty?	I did not shard. Grow the catalog. Keep only suitable small inference in the tab. Move heavy training off the synchronous path. Add a current-scene eval for bots as a future improvement. I do not invent cluster capacity, GPU name, LangSmith, or user count.
What must GenAI not do on this path?	Mutate the scene graph or URDF integrity. Execute models or access another user’s dataset. Hallucinate objects that are not in the current scene — stale last-week context is the failure. Sit on the heavy training path as if it were a click. Gemini may explain current scene context after deterministic scene state is fixed.
How do you know the metric?	−30% is resume iteration-time outcome. Mechanism; I will not invent sample size. 50+ is marketplace catalog. Isolation for users and datasets is required; I do not steal Ylogx three-tier RLS into this SaaS as the evidence.
Stale scene / heavy model on the click path?	A voice bot answering from last week’s URDF describes objects that are not there. A large model on the interactive path exhausts browser memory and kills the iteration loop. Defense: pass current scene and URDF into the bot; keep heavy training off the click path; keep marketplace items as catalog.

Keep straight

−30% is ML iteration time, not FPS, not Argus 24 FPS, not Horizon 60 FPS.
50+ is catalog of models and datasets, not GPUs, not Argus 20+ cameras.
Gemini scene bots are not Argus YOLOv9 and not IQVIA LangGraph Deep Research.
GitHub README is default Next.js. Resume features win.
Think Big primary is this product. Invent primary stays IQVIA Hybrid RAG. This is Invent backup only.

Tighten

Stop after the short loop, catalog 50+, and −30% as iteration time. If this project already appeared: Think Big backup is IQVIA ranking across 200+ sites — backup only, not a fourth IQVIA primary.

IEDC CUSAT Tech Team and hackathons — Oct 2022–May 2026

Not a sixth product architecture. B.Tech CSE at CUSAT, CGPA 8.42. IEDC Tech Team member, not manager, not recruiter, not owner of a mentee headcount. Eight national and regional hackathons: CodeRecet 1st, MLH Best Project, Magnathon 2.0 runner-up. Club and hackathon stacks were not shared. Success is another person can run the launch without my laptop.

What they might ask

Tell me about leadership / helping teammates. / Hire and Develop the Best.
Eight hackathons — what did you actually do?

Resume-derived membership, CGPA, three named placements, eight events. Hire and Develop primary. Horizon remains Earth’s Best Employer primary — two different beats.

What you say

Situation. I studied Computer Science and Engineering at CUSAT, October 2022 to May 2026, CGPA 8.42. I served on the Tech Team at IEDC CUSAT — a team member. Club and hackathon stacks were not shared. If only one laptop could run the build, or only one person knew a launch order, the next event stopped when that person moved.

Task. Transfer the risky module so another person can execute it without my machine. Not a mentee count. Not a hiring loop.

Action. I shared environment setup — the actual commands and dependencies, not a slide. I reviewed the risky path, exposed failures we had already hit, and paired until the other person could run it. Across eight events the resume names rapid software and production-ready deployment. Named placements: CodeRecet first, MLH Best Project, Magnathon 2.0 runner-up.

Result. Membership, eight events, three named placements. No mentee count, ratings, or retention percent. Then I stop. If they want depth, I offer how pairing worked on a named event — not a tour of five unnamed hackathons.

Data flow — pairing until someone else can launch

Share environment setup — the actual commands and dependencies, not a slide.
Person A starts the risky module.
Person B confirms expected output.
Bring up the next stage and inspect it.
Connect the following boundary only after that stage is healthy.
Review failures already hit — a build that only worked on one laptop, a missing dependency — so the next person is not surprised.
Success is the other person reproduces the launch without my machine.
Rotate who executes it so knowledge does not sit in one head.

What I did not own

Manager, recruiter, or hire/fire authority. Headcount. A mentee number — none is on the resume.
The remaining five hackathon names or invented architectures for those events.
Sole credit for team prizes or for ERC 17th.
CGPA 8.42 as a coaching metric. That number is education.

They might ask next

If they ask	You answer
Why share instead of hoarding the working laptop?	Hoarding looks fast until the person with the laptop is elsewhere. I rejected skip-levels, fake mentee counts, and hero ownership of the only working environment. The constraint was capability transfer on a student team, under event dates.
Hire and Develop versus Earth’s Best Employer?	IEDC is coaching a person until they can perform — Hire and Develop. Horizon is the environment: launch knowledge is not trapped in one head — Earth’s Best Employer. Two beats. I do not collapse them into one speech.
I versus we?	I paired and reviewed. Hackathon awards and ERC placement are we.
10× honesty?	There is no shard story and no GPU name. I would standardize setup and checks so more teammates can reproduce launches. I did not manage ten times the people. A generated README is not proof another person can launch.
What must GenAI not do on this path?	Replace pairing on the module that actually broke.
How do you know the metric?	Membership, eight events, CodeRecet 1st, MLH Best Project, Magnathon 2.0 runner-up, CUSAT 8.42. No mentee count. Hackathon placements are event outcomes, not Argus mAP, not Ylogx 99.9%, not a second ERC medal. ERC 17th of 80+ stays on Horizon unless they explicitly combine leadership scope.
Bias for Action backup?	Eight named hackathons can support Bias as backup. Horizon remains Bias primary.

Keep straight

IEDC Tech Team member. No mentee count.
Eight hackathons. Three named placements: CodeRecet 1st, MLH Best Project, Magnathon 2.0 runner-up.
CGPA 8.42 is education, not Earth’s Best evidence.
Hire and Develop primary is IEDC. Earth’s Best primary is Horizon knowledge sharing.
InstaRecon and PhiSiFi are off-resume security demos. Ethics one-liner only if they found them: security-awareness demo, consent, no production attacks. Then redirect to StratifyLabs, Argus, Ylogx, or IQVIA. Not an LP. No exploit steps.

Tighten

Stop after member, pairing until someone else can launch, and the three named events. Do not dump every intern metric as a prize system. If this already appeared: Hire and Develop backup is Horizon pairing until someone else can launch GStreamer or costmap.

If they open GitHub — adarshx01

Resume wins when a README disagrees. Label GitHub in the first sentence. valAgent, karyanode, and warpflow are adjacent, not intern bullets. Forks are not internships. Do not volunteer InstaRecon. Login Tracker is unverified — do not volunteer it as this Job ID.

What they might ask

I opened this repo — walk me through it.
Is this the IQVIA / Ylogx / GiftedBooks product?

Standard CS / GitHub-adjacent. Not Job 10454435 evidence. Not Aug 2026 intern metrics.

What you say

Situation. They opened a repo. I label it GitHub in the first sentence so it cannot steal intern numbers.

Task. Tell what the artifact is, what it is not, then offer the matching resume product if they still want production depth.

Action. I match the repo they opened. GiftedBooks README currently describes AegisAI: mismatch, resume GiftedBooks wins. StratifyLabs README is default Next.js: resume stratifylabs.design wins. valAgent is an ETL validator on GitHub, adjacent to verify-don’t-trust habits, not the IQVIA 200+ bullets. warpflow is a Ylogx-adjacent UI canvas; run is a demo timeout, not the intern BI engine. karyanode is a local-first agent on GitHub; no invented user counts. Gstreamer-UDP is a webcam analogue for Horizon 60 FPS pipeline shape, not a second intern. Conv-BI is Ylogx-adjacent GitHub, not a second bullet.

Result. One repo, then stop. If they want the intern story, I switch to the matching resume product. I do not merge metrics.

Data flow — only if they opened valAgent

QA writes a natural-language business rule.
Schema service reads source and target Postgres catalogs.
LLM service emits SQL tests from the rule plus real column names.
Executor runs those tests (worker pool, timeout). Proof is pass/fail plus the SQL that ran.
Orchestrator sequences the run. Policy is fail-closed: the model does not DROP, migrate, or hold superuser credentials.

That flow is GitHub. It does not inherit 200+ websites, 200+ page BRDs, or LangSmith as an intern claim.

What I did not own — on these repos as intern claims

IQVIA 200+ families on valAgent or karyanode.
Ylogx 99.9%, −35%, or +65% on warpflow.
StratifyLabs −30% or marketplace 50+ on karyanode ports.
Citizen-user counts, government contracts, n8n-scale QPS, Kafka, or EKS on these artifacts.

They might ask next

Repo	What it is today	What you speak
`giftedbooks-ai` / giftedbooks	README currently describes AegisAI	Mismatch first. GiftedBooks VR + PDF RAG from the resume. Would fix the README.
`StratifyLabs`	Default Next.js README	stratifylabs.design: browser inference −30%, marketplace 50+, URDF/WebGL, Gemini scene bots.
`valAgent`	GitHub ETL validator: NL rule → schema → SQL tests → execute with proof	Adjacent to IQVIA verify-don’t-trust habits. Not an IQVIA resume bullet. No 200+ merge. Model proposes read-only tests. It does not DROP.
`warpflow`	UI workflow canvas; demo timeout	Ylogx-adjacent experiment. Not the intern BI story. If they want production, Ylogx SQL RAG + RLS + Redis.
`karyanode`	Local-first agent; optional Stratify/ValETL ports	GitHub only. No invented user counts. Modules stay separate products.
`Gstreamer-UDP`	Webcam analogue	Supports Horizon 60 FPS pipeline shape. Not a second internship. Not rover metrics.
Conv-BI	Ylogx-adjacent GitHub	Not a second intern bullet. Prefer Ylogx reports and SQL RAG.
InstaRecon / PhiSiFi	Off-resume security demo	Ethics one-liner: security-awareness demo, consent, no production attacks. Then redirect. Not an LP. No internals, no exploit steps.
argus-stream-api-server	README 404	No invented routes. Speak Argus from the resume: YOLOv9, events in Postgres.

If they ask	You answer
Why NL→SQL on valAgent instead of hand-written tests?	QA owns the invariant. Hand tests rot when columns move. Generated tests still must run. Wrong grain is the dangerous bug. I execute; I do not trust fluent SQL. This is GitHub, not IQVIA LangSmith.
10× honesty on these repos?	I did not shard them. I will not invent deployment counts, QPS, or intern metrics. Forks (firecrawl, care-fe, litestar, and similar) are not internships.
What must GenAI not do here?	valAgent: DROP, migrate, or hold credentials. karyanode: un-allowlisted actuators; skip the verifier. warpflow: pretend a canvas timeout is a production orchestrator. InstaRecon: no production attacks.
How do you know there is no intern metric?	The Aug 2026 resume does not name these repos as work rows. Intern numbers stay on IQVIA, Ylogx, and Horizon. Project numbers stay on Argus, GiftedBooks, and StratifyLabs as printed.
Live Code?	Still Java. A TypeScript canvas is not permission to write TypeScript in the editor.

Keep straight

Resume wins on GiftedBooks versus AegisAI and on StratifyLabs versus the Next.js scaffold.
valAgent / karyanode / warpflow = GitHub-adjacent, not intern bullets.
InstaRecon: ethics one-liner only, then redirect.
Login Tracker (new_login / get_oldest_login) is unverified. Rate Limiter independent SDE I live-round count is 1, not a UTA-default leftover design you shipped.

Tighten

One repo, label GitHub, then the matching resume product if they still want depth. Do not volunteer InstaRecon or Login Tracker. R3 is done; this booklet does not guess what it contained. Job 10454435 still has no named live question.

GenAI may / must not — one line each

Same gates as the cards above. The model plans and synthesizes where the resume already has a grounded path. It does not own safety, isolation, occupancy, or boxes.

What they might ask

Where should you use GenAI? Where should you not?

Resume-derived from the mechanisms on this page. A Fluency label in another loop can still be a tree problem — write Java first (chapter 6 and 7).

What you say

I use GenAI where the work is high volume, pattern-based, and cheaply verifiable: Deep Research across 200+ sites, Hybrid RAG on 200+ page BRDs with a span gate, Ylogx SQL RAG behind RLS, GiftedBooks Q&A from that student’s PDF. I do not use it for Ylogx row security, Argus boxes, Horizon costmap, unpaid totals without SQL, or authZ. If they paste a tree, I write the tree in Java first.

They might ask next

Path	GenAI may	GenAI must not
IQVIA Deep Research	Plan, fan-out tools, rank, cite or abstain	Invent page contents; unbounded loops; count mirrors as extra votes
IQVIA Hybrid RAG	Synthesize from hybrid + semantic + hop evidence	Invent GraphDB edges or clauses; skip the LangSmith span gate
Ylogx SQL RAG	Constrained NL → SQL after walls	RLS, roles, KPI tiles, cache identity, writes, table-owner credentials
Horizon costmap	—	Occupancy, actuation, packet recovery, stale video as current map
Argus PPE	—	Boxes, alerts-as-prose, relabel 73% as shippable
GiftedBooks	Grounded Q&A from that PDF	PYQ guessing; cross-user retrieve; AegisAI mix
StratifyLabs	Scene-conditioned explanation after scene state is fixed	Scene graph; other users’ datasets; FPS claims
IEDC / pairing	—	Replace pairing on the module that broke

Keep straight

Fluency can still be DSA. Distance K showed up in another loop under a Fluency label. Write the Java tree, then one Fluency sentence if they still ask.
This table is not a Job 10454435 question list.

Tighten

Name the path they asked about. One may / must-not pair. Stop. Full CS and Fluency rehearsal is chapter 7.

Companion: older 25-chapter notebook · chapter 9 projects · research bible · study book.