LP Q&A · Earn Trust through Success and Scale

I take the stem they just asked. I tell one story from one product. I stop on the resume family that belongs on that product. If they already heard that product, I name the backup on the card and tell it as a full second STAR.

Situation. Argus is PPE computer vision for a factory floor. A detector can look promising in a notebook and still be wrong on people. At 73% mAP the model misses helmets and also fires junk boxes. Either one trains people to ignore PPE alarms. I treated a rising notebook score as launch-ready. That judgment was the mistake. 73% was not a number I would page the floor on. The evaluation metric was the critical feedback. I do not attach that number to a person shouting.

Task. Treat 73% as a failed safety-alert gate. “Ready” meant a held-out mAP I could alert a person on, at a frame rate the live stream could support, with events that could be audited.

Action. I trained and evaluated YOLOv9 on more than 15,000 images and iterated to 89% mAP. I required 24 FPS end-to-end — decode, infer, NMS, I/O — not notebook forward-milliseconds. I wrote detection events to Postgres (camera, class, confidence, time, box), not video blobs. Only after both gates did I containerize more than twenty camera feeds.

Result. 73% to 89% mAP at 24 FPS on 15,000+ images, then 20+ cameras. After alerts existed, site violations fell 50% and compliance doubled. Those ops numbers are we, after the gate. mAP was the gate.

Situation. GiftedBooks on the Aug 2026 resume is VR learning plus grounded PDF question-answering. The current GitHub README for that repo describes AegisAI. That is a mismatch. Leaving it unspoken would be dressing the surface.

Task. Name the mismatch in the first sentence, then defend the resume product, and say I would fix the README.

Action. I say the README currently describes AegisAI; that is not the product I will defend. GiftedBooks is user-scoped RAG over that student’s PDF, generate-or-abstain when no source span exists, bounded generate for sub-300 ms. I would update the README to match the resume. I do not mix AegisAI features into the spoken answer.

Result. Doubts from hours to 3–10 minutes. 99.5% uptime on GiftedBooks. Vocal self-criticism is the README sentence, then the PDF product.

Situation. Live Code in this process is Java. My internships and shipped projects were Python FastAPI and LangGraph, YOLOv9, TypeScript NestJS and React, and ROS2. I have fewer production Java hours than those stacks. That gap is real.

Task. Name it without converting it into a fake strength, and close it in the editor rather than by claiming a JVM internship I did not have.

Action. I write the solution in Java — collections, heap, maps, careful long where sums overflow. Internship bullets used Python FastAPI, TypeScript NestJS, and ROS2. Those internships are not Spring or Kafka services. I close the gap by producing working Java in this loop’s editor.

Result. The honest intern-level answer is the hours split. I close it in the room, not with a story that I work too hard, and not with “I have no failures.” Argus 73% mAP was a real failed bar when they want a product shortcoming.

Situation. GiftedBooks had VR labs, avatars, and PDFs. A polished lab that could not answer from the student’s own material was decoration. A generic chatbot with a confident textbook voice was not a teaching assistant. The current GitHub README describes AegisAI. That is not the resume product.

Task. Name those trust failures, ship grounded isolated Q&A, hold availability, and be honest if someone opened the repo.

Action. I shipped contextual Q&A over that user’s PDF, with per-user document metadata so another student’s notes never retrieve. I abstain when no source span exists, keep generation bounded for sub-300 ms, and hold 99.5% uptime as hosting, not as model intelligence. I disclose that the current README describes AegisAI, and that GiftedBooks on the Aug 2026 resume is the product I speak. I would fix the README.

Result. Doubt time moved from hours to 3–10 minutes, with +35% reading, +50% engagement, 2.5× comprehension, and 99.5% uptime.

Situation. The StratifyLabs GitHub README is a default Next.js scaffold. That is not the product on the resume.

Task. Label the mismatch, then speak stratifylabs.design from the Aug 2026 PDF.

Action. I say the README is the scaffold. The product is a browser CV lab plus marketplace: in-browser inference, URDF/WebGL, Gemini in-scene. Resume numbers on that product are −30% ML iteration (not FPS) and marketplace 50+.

Result. Resume wins. I do not narrate a merge timeline the PDF does not have.

Situation. At Ylogx, November 2024 to October 2025, the SQL RAG chatbot returned SQL and rows, so a happy-path demo said the product worked. The anecdote was “the model is slow.” Two facts disagreed. Every natural-language turn still hit Postgres, so latency felt like the model thinking. And if isolation lived only in the application, a generated JOIN could return another organization’s rows. The same confident response could be slow, wrong-grained, or leaked.

Task. Separate query shape, missing cache, and security in the wrong layer. Measuring the database path was not beneath the intern ticket.

Action. I measured bot database latency around the query, rather than rewriting the prompt first. I put RLS and RBAC into Postgres so generated SQL ran as the caller’s database role — a syntactically valid JOIN still lost unauthorized rows. I added Redis cache-aside for repeat questions and schema lookups with tier and role in the key, and I cached only the allowed payload. Redis down meant Postgres as that role, never fail-open RLS. Showing the generated SQL made wrong grain visible even when the tenant was correct.

Result. Bot database latency fell 35%. Three-tier isolation sat in Postgres. Uptime held at 99.9%. The deep dive was latency plus isolation on the same path.

Situation. On two-hundred-page BRDs, a vector demo returned a similar paragraph and looked successful. At the detail level, clause IDs were missed. Two high-ranked sources could disagree. An empty scrape could still reach a fluent writer. First-hit retrieval is false certainty.

Task. Inspect chunks, traces, and agreement instead of trusting the sentence. The answer had to be supported by an exact span, or it had to stop.

Action. Azure hybrid and semantic retrieval so an identifier and a paraphrase could both be found, then a bounded GraphDB hop when the question was depends-on. Rank on quality, recency, and agreement — mirrored copies are not independent confirmation. Refuse to average two contradictory requirements. LangSmith made empty-tool results visible. Cite-or-abstain was the stop.

Result. More-than-two-hundred-page BRDs processed with traces and generated tests. More than two hundred sites ranked on the research side. No extra IQVIA percentage.

Situation. At Ylogx the intern ticket could have ended when the chatbot returned rows and the report builder drew a table. The bug class hid under that demo. A generated JOIN can be syntactically valid and still expose another organization’s facts through a mapping table. App-only WHERE dies on the first missed handler or skipped helper. HTTP still says 200. The KPI looks right and belongs to the wrong org.

Task. Make three organizational tiers real where SQL actually ran, not only where the React UI hid a column. Find whether the leak was query shape, missing predicate, or security in the wrong layer.

Action. I named the failure mode in the working path: generated JOIN, mapping table, HTTP 200, wrong tenant. I put RLS and RBAC for three tiers in Postgres and ran generated SQL as the caller’s database role so the denied row is a fixture, not a speech. I kept cache keys tier-scoped so a later Redis hit could not launder a wrong-org answer into a latency win.

Result. Isolation sat in the database. Uptime held at 99.9%. The bug class is the JOIN leak, not a ticket ID on the resume.

Situation. IQVIA needed grounded answers on 200+ page BRDs. Each wrong architecture failed in a different way. A vector-only demo looked successful on similar paragraphs and still missed clause IDs. Stuffing the BRD failed on tokens and citation honesty. A linear chain could not retry a hop.

Task. Run a short series of proofs: which retrieve and which orchestration actually fail closed. Intern: I owned the POCs and the eval stop, not a research org.

Action. Vector-only missed identifiers — the BRD POC became Azure hybrid plus semantic plus a bounded GraphDB hop for depends-on. Stuffing the document was discarded. LangSmith made the stop visible: a generated test without an overlapping span fails. LangGraph is the workflow. GraphDB is the requirement-dependency store. Those are two different graphs.

Result. 200+ page BRDs with traces and generated tests. 200+ websites ranked on the research side. No extra IQVIA percentage.

Situation. At Ylogx the anecdote was that the model was slow. The POCs were a bigger RDS versus measuring the query path versus cache-aside. A larger database does not fix a JOIN leak, and it does not fix every natural-language turn repeating schema lookups.

Task. Prove which layer was actually slow, without skipping isolation.

Action. I timed bot database latency. Repeat questions and schema lookups are cache-shaped, so Redis cache-aside with tier in the key beat “buy a bigger RDS” as the first fix. RLS stayed on the caller role. Redis down still ran as that role.

Result. Bot database latency fell 35%. 99.9% held. This is Dive Deep (metric versus anecdote), not a second Ownership speech.

Situation. At IQVIA I did not initially know the next retrieve mode for long BRDs. Several architectures all looked plausible on a whiteboard. A fluent paragraph is not a diagnosis.

Task. List options, pick with a stop condition, learn the unknown from traces rather than from another tutorial.

Action. Options I considered: vector-only versus Azure hybrid plus semantic plus a bounded GraphDB hop; stuffing the BRD versus retrieve-and-cite; averaging two contradictory clauses versus cite-or-abstain. I learned the unknowns by failing closed: empty retrieval must not become a fact; a generated test with no overlapping span fails. LangSmith traces showed which node was wrong.

Result. 200+ page BRDs with traces. 200+ sites ranked on the research side. The outcome of not-knowing was a stop condition, not a larger prompt. No extra IQVIA percentage.

Situation. An AI app the team used to test the platform failed in a stakeholder demo. The tempting anecdote was “the model is dumb.” The agent clicked the last zoom on the last chart instead of the intended chart’s zoom, and it could not compare two charts on the fly.

Task. Learn from logs, AI audit logs, reports, and screenshots instead of rewriting the prompt first.

Action. I found DOM truncation: the agent could not see the right control, assumed the last match, and clicked wrong. Prompt/reasoning was also too thin (low did not work). I raised DOM max chars, moved max DOM elements 50 → 80, and set reasoning to med.

Result. The path worked; we demoed to stakeholders. IQVIA has no percent or latency on the resume. Full STAR: DOM card.

Situation. At IQVIA the team had to demo to stakeholders. An AI application they used to test the platform failed in that run. Two errors showed up. First, the agent could not click the intended chart’s zoom — it clicked the last zoom on the last chart. I was confused; the intended control was on screen for a human. Second, it could not compare two charts’ data on the fly during the test.

Task. Identify from logs, AI audit logs, reports, and screenshots the run took why the agent missed the control, without starting from “the model is dumb.”

Action. The DOM the agent saw was truncated, so it could not see the right control, assumed the last matching element, and clicked wrong. That is prompt/reasoning plus UI clipping, not a missing library. I increased DOM max characters in config. I moved max DOM elements from 50 to 80. Reasoning at low did not work; I set reasoning to med. I stop at that config change. IQVIA has no percent on the resume.

Result. The path worked. We demoed to stakeholders. Stop there. IQVIA has no uptime or latency percent on the resume. 50 → 80 is the config change I can defend, not a metric family.

Situation. The fastest demo for RAG on PDFs is a vector index. At IQVIA, BRDs were more than two hundred pages, with clause IDs, tables, and requirement dependencies. A vector-only path optimizes for ship date. Similar embeddings are not requirement coverage. A clause identifier can cosine-miss while a fluent retention paragraph comes back looking right. That is a real disagreement, not a personality fight. I have no shouting match on the resume.

Task. Challenge the retrieval choice through its failure mode, propose a testable alternative, then stop reopening the tool debate once the path was chosen. I am a software developer intern, not a skip-level.

Action. I contrasted three failure modes: lexical retrieval for an exact ID, semantic retrieval for policy language, graph hops for dependents. I stated that a nearest neighbor can miss the identifier entirely. I proposed Azure AI Search hybrid plus semantic ranker, plus a bounded GraphDB hop, plus LangGraph adaptive routing so the writer saw a small evidence set. Once that path was selected, I committed by instrumenting LangSmith: no overlapping source span, the case fails.

Result. Hybrid RAG processed 200+ page BRDs with traces and generated tests. Disagree on retrieval. Commit on evals. No extra percentage.

Situation. IQVIA stakeholders could ship a vector-only RAG demo faster. I needed them to accept hybrid retrieval plus GraphDB hops for 200+ page BRDs. I was an intern. I do not win by talking longer.

Task. Convince on a failure mode they can reproduce, then commit wholly once the path is chosen.

Action. I showed the miss: a clause ID is a lexical problem; “retention policy” is a semantic problem; “what depends on this requirement” is a GraphDB hop. I proposed Azure hybrid plus semantic plus a bounded hop, with LangSmith as the decision record: a generated test with no overlapping span fails. After the path was selected, I stopped the library debate and instrumented that path.

Result. Hybrid RAG on 200+ page BRDs with traces and generated tests. Convince on coverage. Commit on evals. No extra percentage.

Situation. I preferred hybrid retrieval plus a bounded GraphDB hop for 200+ page BRDs. Vector-only was faster to demo. The disagreement was coverage versus ship date.

Task. Once the path was determined, commit wholly. Preference is not a quiet fork.

Action. The path selected was hybrid plus semantic plus GraphDB plus traces. I still preferred that coverage model; commit meant I instrumented LangSmith evals and test-case generation on that path and stopped relitigating libraries every week. I did not keep a quiet vector-only side project. If the room had picked a thinner retrieve, commit would have meant the same span-fail evals on that path — not sabotage, and not a hidden hybrid service.

Result. 200+ page BRDs with traces and generated tests. Disagree on retrieval. Commit on evals. No extra percentage.

Situation. At Ylogx an app-level organization filter looked enough for a quick release. I preferred RLS in Postgres. Generated SQL can take a path the UI never represented.

Task. Once database policy was the platform rule, commit — no exception path “just for the bot.”

Action. I put RLS and RBAC for three tiers into Postgres and ran generated SQL as the caller’s non-owner role. After that decision I did not leave an app-only bypass. Redis keys carried tier so speed could not become a side door.

Result. Isolation sat in the database. Uptime held at 99.9%. Bot database latency later fell 35% with tier-safe cache. The commit was policy in Postgres, not a stand-up argument.

Situation. ERC 2024 does not move. More than eighty teams. I was Horizon core software from February to June 2024. The commitment at risk was not “we might skip the contest.” It was a rover that mapped while planning on stale occupancy: a healthy-looking camera with a planner map that lagged the world. Dirt and lighting did not match Gazebo.

Task. Flag that ship-blocker early and specifically, then close feed and costmap on the sensors we had. Extra hardware near the date adds drivers and calibration while time alignment is still unsolved.

Action. I shipped GStreamer at 60 FPS so the operator saw the newest frame. I moved ZED 2 mapping at more than two million points per second into the rover frame with timestamps. Fusion wrote occupied / free / uncertain costmap cells. When occupancy lagged a healthy feed, I named that split out loud: the costmap is stale; fusion is the path; extra hardware is the cut.

Result. We placed 17th of more than eighty. Obstacle detection up 40%. Collision risk down 55%. The date was met. The resume states that placement, not a missed ERC.

Situation. ERC 2024 had more than eighty international teams and a fixed date. I was on Horizon software from February to June 2024. More bag files and Gazebo screenshots would have looked active. Judges scored a rover that ran on the day.

Task. Sequence the key inputs: a live operator feed, and a costmap the planner could trust. A lab video was not a result.

Action. I shipped GStreamer at 60 FPS so operators saw current video. I moved ZED 2 mapping at more than two million points per second into the local costmap, with visualization downsampled so the pretty cloud did not starve occupancy. I put fusion and predictive planning on latest occupancy. I discarded more simulation polish, a late architecture rewrite, and extra hardware first.

Result. We placed 17th globally of more than eighty teams. Obstacle detection improved 40%. Collision risk fell 55% after fusion. The date was met.

Situation. On Argus I expected a rising notebook mAP to be enough to alert a factory floor. At 73% mAP that expectation failed. The model misses helmets and fires junk boxes. Either one trains people to ignore PPE alarms. 73% is not a number I would page the floor on.

Task. Replace the comfortable expectation with a ship bar: held-out mAP plus live FPS, then width.

Action. I treated 73% as a failed quality gate. I trained YOLOv9 on more than 15,000 images to 89% mAP, required 24 FPS end-to-end, wrote events to Postgres, and only then containerized more than twenty feeds.

Result. 73% to 89% mAP at 24 FPS, then 20+ cameras. After alerts existed, violations down 50% and compliance doubled (we). The expected-to-work notebook score was not the result. The gated detector was.

Situation. At Ylogx a chatbot that merely produced SQL looked like a result. Operators needed custom reports, and no organization could read another tier’s rows. A fast leak is not delivered.

Task. Faster reporting at held availability, with isolation on the path those features already shared.

Action. FastAPI and NestJS on shared Postgres; three-tier RLS so reports and the bot inherited the same role mapping; Redis with tier in the key; thirty dashboard KPIs off the model; CloudFront, ALB, ECS, Docker.

Result. Reports 40% faster at 99.9% uptime. Analysis +65%. Bot-DB −35%. Thirty KPI dashboards +60% at sub-210 ms. Still no SLA miss on the resume.

Situation. On IQVIA Hybrid RAG, an empty scrape or a missing span can still feed a fluent writer. That looks like a delivered answer. It is an unknown dressed as a sentence. Two high-ranked sources can also disagree.

Task. Deliver a result the analyst can trust: a citation, or an abstain. Empty retrieval is not a fluent clause.

Action. Parallel tools bring independent indexes. The ranker scores quality, recency, and agreement. The writer synthesizes only from retained evidence. If no span remains, or spans conflict, the system abstains rather than smoothing the contradiction. LangSmith shows whether an empty body reached the writer.

Result. Research ranked across 200+ websites. 200+ page BRDs with traces. I do not add an accuracy percentage. When retrieval is empty, cite-or-abstain is the product you deliver.

Situation. Near ERC, extra hardware was unknown-to-arrive. We already had cameras and a ZED 2. Field lighting and dust were not in Gazebo.

Task. Deliver occupancy the planner could trust on sensors we had, without waiting on a purchase that would not land in time.

Action. I fused onboard sensing into occupied, free, and uncertain costmap cells with timestamps. Dense points for local planning; downsampled visualization. Predictive planning on that fused grid. Extra rover hardware was the cut.

Result. Collision risk fell 55%. Obstacle detection improved 40%. We placed 17th of more than eighty.

Situation. From February to June 2024 I was core software on Team Horizon’s ROS2 rover for ERC 2024. More than eighty international teams. The date does not move. Judges scored a rover that ran on the day, not bag files.

Task. A live operator feed and a costmap the planner could trust. I owned camera, mapping, and costmap software. I was not team lead.

Action. I shipped GStreamer at 60 FPS. I moved ZED 2 mapping at more than two million points per second into RViz and Gazebo for the node graph, and into the local costmap for planning. I fused occupancy and put predictive planning on latest cells, treating stale occupancy as the ship-blocker in the field, not only in sim.

Result. We placed 17th of more than eighty. Obstacle detection improved 40%. Collision risk fell 55% after fusion.

Situation. Horizon rover software was fragile if camera, mapping, and launch knowledge lived in one head. ERC placement was a team score. I was a software team member, not a people manager and not a hiring loop.

Task. Teammates needed to launch perception without my laptop, integrate the costmap, and carry that into the next subsystem. Empowerment meant executable knowledge, not a slide deck.

Action. I paired on launch files until someone else could start the GStreamer camera node and confirm topics. I shared ZED rate versus visualization so a dense cloud for RViz was not mistaken for planner input, and I shared costmap expectations and node order. I stayed until the other person could run the path, including the failure we had already hit in the field, then I moved to the next module.

Result. We placed 17th of more than eighty as a team. The Earth’s Best result I can defend is that launch order was not trapped in one head. I claim no happiness score or mentee count.

Situation. At IEDC CUSAT, people joining club and hackathon projects did not share one stack. If only one laptop ran the build, the next event failed when that person worked elsewhere. I was a Tech Team member, not a manager.

Task. The next person needed to run the build and own the risky module.

Action. I shared environment setup and the failures already hit, in review, not as a slogan. I paired on the risky module until another laptop reproduced it. Across eight hackathons I treated a deploy someone else could repeat as the bar, not a hero demo.

Result. Tech Team membership, eight events, CodeRecet first, MLH Best Project, Magnathon 2.0 runner-up. No mentee count. CGPA 8.42 is not this metric.

Situation. One-camera detection is not industrial safety. At more than twenty cameras, wrong alerts scale harm as well as benefit. A detector at 73% mAP would multiply misses and false alarms until people learned to ignore PPE warnings.

Task. Make the detector ready before multiplying it, hold real-time throughput, and leave an audit trail. Secondary effect was alarm fatigue, not a planet metric.

Action. I did not scale at 73%. I moved YOLOv9 to 89% mAP at 24 FPS on more than 15,000 images, with NMS on the boxes. Only then I containerized ingest workers for more than twenty feeds, dropping stale frames rather than queuing delayed alerts. I stored structured events in Postgres — camera, class, confidence, time, box — not JPEG blobs. Humans acted on alerts.

Result. More than twenty cameras after the gate. Violations down 50% and compliance doubled after alerts existed (we). Order matters: quality, then scale. mAP is not those operational numbers.

Situation. One-camera detection does not create industrial safety. At more than twenty cameras, wrong alerts scale harm as well as benefit. A detector at 73% mAP would multiply misses and junk boxes until people learned to ignore the system.

Task. Make the detector ready before multiplying it. Preserve 24 FPS. Leave an audit trail. I did not shard Postgres. I did not own the AWS bill or a named cluster.

Action. I did not scale at 73%. I moved YOLOv9 to 89% mAP at 24 FPS on more than 15,000 images, kept NMS, and only then containerized more than twenty feeds. Workers drop stale frames rather than queue delayed alerts. Postgres stores events, not JPEG blobs. Honest 10× from here is more workers or batching if latency holds, still behind the same gates. It is not 10× FPS, and it is not 73% on 200 cameras.

Result. After the gate: 20+ cameras. After alerts existed: −50% violations, 2× compliance (we). Quality, then scale.

Situation. Ylogx traffic sat on CloudFront, Route 53, ALB, ECS, and Docker. Adding desired count without isolation would have multiplied a leak. Adding cache without tier would have multiplied a wrong-org answer.

Task. Serving had to grow on a path that already knew the caller’s database role. I did not own the AWS bill or a named cluster. I did not shard.

Action. RLS and RBAC for three tiers were in Postgres before I treated ECS desired count as a scaling lever. ALB health checks and rolling image replacement bounded blast radius. Redis keys already carried tier. Dashboard GETs still had no LLM. Honest 10× is pool, fixtures, then more tasks — still behind RLS.

Result. 99.9% uptime held on that path. Bot database latency was 35% lower with a safe cache. Kafka and a Prime Video design are not on those bullets.