11. Leadership Principles

Situation (15s): product + who hurt + constraint.
Task (10s): what I owned, in one job-shaped sentence.
Action (40s): three steps I took, with a mechanism.
Result (15s): resume metric, then stop talking.
Then wait. They will ask why.

Situation

At Ylogx I was a software intern from November 2024 to October 2025 on a full-stack AI business-intelligence product: FastAPI and NestJS over Postgres, React dashboards, and a LangChain SQL RAG chatbot that turned natural language into SQL. On a demo the chatbot looked finished. It returned rows. That was the anecdote: “it works.” Users who were not SQL experts could ask a question in English. The metrics disagreed. The product still had two problems you could not see in that demo. Every natural-language turn was hitting the database, so the bot path was slow in a way that felt like “the model is thinking” when the database was the cost. And if isolation lived only in the application, a JOIN or a generated query could outrun a UI filter and return another organization’s rows.

Task

My job was not to add another prompt. My job was to find whether slowness was query shape, missing cache, or security checks done in the wrong layer, and to make correctness and isolation real for three organizational tiers on the same data path the bot and the reports already shared.

Action

I measured bot database latency instead of celebrating that SQL came back. That is a different question from “does the LLM write syntactically valid SQL.” I put row-level security and RBAC in Postgres for those three tiers so a generated query ran as the user’s database role, not as a service superuser. A JOIN could not outrun the app because the database refused the row. Then I put Redis on the hot bot path so repeat questions and schema lookups were not a round trip every time. The cache did not skip RLS. A cached answer still had to belong to the right tier. I kept the BI app on CloudFront, ECS, Docker, and an ALB behind Route 53 so the same discipline applied to the serving path: one routing story, not a snowflake host.

Result

Bot database latency dropped 35 percent. Data-analysis productivity for people who were not writing SQL went up 65 percent. Report generation got 40 percent faster. We held 99.9 percent uptime, and the dashboards stayed in the sub-210 millisecond number on the resume. Thirty KPI dashboards later showed a 60 percent ops-efficiency move. The deep dive was latency plus isolation, not a search-console ticket.

Example. A user in one org asked a dashboard-style question that, without RLS, would have joined a shared fact table and returned another org’s KPIs. The generated SQL was syntactically fine. The database role with RLS is what made it fail closed. Redis then stopped us from paying for that same allowed query on every follow-up turn.

Situation

From February to June 2024 I was on the core software team for Team Horizon at CUSAT, building a semi-autonomous Mars rover for the European Rover Challenge 2024. More than eighty teams were competing. The event date does not move because your Gazebo world is still ugly. Perception, mapping, and planning had to run on the hardware we had, in dirt and lighting that the simulator did not fully copy.

Task

I owned the software path that had to actually run on challenge day: a live camera feed, a dense map, and a costmap the planner could trust. A lab video was not a result. A rover that maps in bags and still collides is not a result either.

Action

I shipped a real-time camera pipeline at 60 FPS with GStreamer instead of a naive web stream that would have dropped the operator feed. The supporting public repo Gstreamer-UDP is a webcam-stream artifact in the same family, not a second project. I took ZED 2 mapping at more than two million points per second into RViz and Gazebo so we had occupancy, not a pretty point cloud on a laptop. I put costmap planning and sensor fusion in front of the actuators so we were not waiting on extra sensors as the default spend. When the costmap lagged, the rover planned on stale occupancy; that was the ship-blocker, and I treated it as one, not as someone else’s camera ticket.

Result

We placed 17th globally out of more than eighty teams. Obstacle detection accuracy improved 40 percent on the resume’s pipeline work. Collision risk dropped 55 percent after costmap fusion, not after buying another sensor. The date was met because 60 FPS and a live costmap were sequenced first.

Example. In the field the simulator’s lighting was a lie. Frames were fine in Gazebo and late on dirt. The debug was pipeline latency versus the ROS2 callback versus the ZED rate, not “train a bigger vision model.” We downsampled for visualization and kept the dense cloud for the local costmap so two million points per second did not all try to leave the rover.

Situation

GiftedBooks is a VR learning suite: 3D labs, AI avatars, and a study path for students who already have PDFs and still lose hours on doubts. A pretty lab that cannot answer a question from the student’s own material is decoration. A generic chatbot that sounds like a textbook is also the wrong customer. The student is trying to pass an exam with their notes, not with a model’s prior.

Task

I needed to cut time-to-answer without inventing content. Answers had to come from the upload. The assistant had to be fast enough and up enough to use during real study, not only in a demo.

Action

I shipped RAG over uploaded PDFs so question-and-answer was contextual. Sub-300 millisecond API responses and 99.5 percent uptime were product constraints, not vanity. I added prioritized topic suggestions from previous-year-question analysis so students studied what exams actually ask, instead of reading the whole PDF in order. I did not replace the VR labs; I made the labs answerable. GitHub currently shows an AegisAI README on the GiftedBooks repo. I will not mix that product into this story. The resume is the source.

Result

Reading efficiency improved 35 percent. Engagement improved 50 percent. Content comprehension moved 2.5 times faster. Average doubt resolution went from hours to three to ten minutes.

Example. A student uploads a unit PDF and asks a definition that appears in a table on page forty. Dumping the whole PDF into a long context would miss the latency budget and invent citations. Retrieval plus a small generation step is how sub-300 milliseconds is even plausible. PYQ ranking then says “this topic is asked,” which is analytics, not an LLM guessing the syllabus.

VR client → API (auth)
  → PDF ingest → chunk/embed → retrieve + generate (sub-300 ms)
  → PYQ topic ranker (separate from the LLM)

Situation

Ylogx was a full-stack AI BI intern role. The chatbot and the report builder would have been wrong and a leak if organizational boundaries were only an application check. I was not the named security team. I was the intern shipping the data path. That is exactly when people say “filter in the UI and ship.”

Task

I owned correctness and isolation for three org tiers, not “chatbot works on my user.” That is long-term value: a demo that leaks is a short-term result. Uptime and report speed were part of the same ownership: a secure system that is down is not owned.

Action

I put RLS and RBAC for three organizational tiers in the data path the bot and the reports share. Generated SQL ran as the user’s database role. I kept the BI app at 99.9 percent uptime while report generation went 40 percent faster, which meant query and deploy work, not a slogan. I added Redis on the bot path for a 35 percent drop in database latency so security did not mean “add a check and ignore load.” CloudFront, ECS, Docker CI/CD, GoDaddy DNS into Route 53 and an ALB were the serving story I will defend as on the resume.

Result

Forty percent faster reports, 99.9 percent uptime, plus 65 percent analysis productivity, minus 35 percent bot database latency, thirty KPI dashboards, plus 60 percent ops efficiency, sub-210 milliseconds.

Example. App-only WHERE org_id = ? fails the moment someone writes a JOIN or the model asks for a table the UI never showed. RLS on the row is the control that still runs when the intern is not watching the handler. I would not ship the bot on a service-role connection string.

-- generated SQL runs as the user role; RLS must still apply
SET ROLE tenant_user;
SELECT kpi, value FROM facts;  -- other orgs' rows do not appear

Situation

I am a software developer intern at IQVIA in Kochi, April 2026 to present. Research requests and BRDs were not a single Wikipedia page. Analysts faced more than two hundred websites on one side and more than two-hundred-page BRDs and PDFs on the other. Manual synthesis does not scale. Hand-written test cases from a two-hundred-page requirements document also do not scale. Stuffing the PDF into a context window blows tokens and invents citations.

Task

I needed one retrieval and orchestration path that ranks sources and turns BRDs into test cases with traces, not a pile of prompts and a vector index named “RAG.”

Action

I architected a LangGraph multi-agent Deep Research system: Firecrawl, Bing, DuckDuckGo, and Google Playwright in parallel, then a ranker across more than two hundred sites. That is externally aware, not “not invented here” — I did not insist on one in-house scraper. I built Hybrid RAG on Azure AI Search with hybrid and semantic retrieval, plus a GraphDB, plus LangGraph for adaptive retrieval on those long BRDs. Lexical search catches clause IDs and table names. Semantic search catches “what is the policy.” Graph hops catch “what depends on this requirement.” LangSmith tracing, evals, and test-case generation made the invention checkable. A citation-gated writer is the simplify: fewer fluent sentences, more exact coverage. I did not use Qdrant; the resume is Azure AI Search and GraphDB. Being misunderstood for a while is the vector-only demo looking faster; hybrid plus graph looks slower until the evals land.

Result

More than two hundred websites ranked. More than two-hundred-page BRDs processed with stateful agents, evals, and generated test cases. No extra percentage is on the resume, so I will not add one.

Example. A BRD cites requirement R-141 and three sections that depend on it. Vector-only retrieval returns similar-looking paragraphs about “retention” and misses the ID. Hybrid keyword plus a graph hop is the simple system: fewer LLM calls, more exact coverage. Test-case generation is itself a traced job, so a bad retrieval path is visible instead of a fluent wrong test.

planner → [Firecrawl | Bing | DDG | Playwright]
       → rank (quality, recency, agreement)
       → writer
BRD → chunk → Azure hybrid+semantic + GraphDB hop → cite or abstain
LangSmith: query → chunks → answer (fail if no overlapping span)

Situation

Argus is industrial computer vision for PPE compliance and attendance on camera. A detector that looks fine in a notebook is not right on a floor. At 73 percent mAP, you miss helmets and you also fire junk boxes. Either failure trains people to ignore the alarm.

Task

Move from a weak eval number to a number I would actually alert on, at a frame rate the stream can live with, with a log of what fired. That meant disconfirming the belief that 73 percent mAP was “progress.” Instinct said the notebook looked fine. The metric said it was not right on a floor.

Action

I treated 73 percent mAP as a fail, not a starting blog metric. I trained and evaluated on more than 15,000 images and iterated YOLOv9 until 89 percent mAP. I ran the detector at 24 FPS so the “right” model was also the one that kept up with the stream. I wrote events to Postgres so compliance was an audit trail, not a GIF. I did not replace boxes with an LLM looking at frames. Fluency is not mAP.

Result

Seventy-three to 89 percent mAP, 24 FPS, safety violations down 50 percent, more than twenty camera feeds, compliance doubled. GitHub argus-stream-api-server exists as a supporting artifact; the README is 404, so I will not invent routes.

Example. A no-helmet frame in odd lighting is a rare miss at 73 percent. Shipping that to twenty cameras scales wrong alerts. The work was more data and a held-out eval, not a heavier two-stage detector that dies at 24 FPS. I will not invent a train/test split the resume does not name.

if (mAP < 0.89) do not scale to 20 cameras;
if (fps < 24) the model is not "right" on a live stream;
log every alert to Postgres;  // audit, not a demo

Situation

Ylogx had been FastAPI, NestJS, Postgres, and SQL RAG. IQVIA’s work was multi-agent research, hybrid retrieval, GraphDB hops, and tracing. LangGraph, LangSmith, and Azure AI Search hybrid were not the previous day job. Tutorial-complete is not architecture.

Task

Learn enough to design the graphs: what is a node, what is state, what is a tool, and how we know a run failed, on more than two hundred sites and on two-hundred-page BRDs.

Action

I used LangGraph for stateful multi-agent Deep Research so a failed scrape did not restart the whole run. I used hybrid plus semantic search plus GraphDB because a long BRD is not a single embedding query. I used LangSmith tracing and evals so curiosity had a pass/fail, including generated test cases. I discarded the idea that “RAG” means one vector index. I discarded a linear chain for Deep Research because retries and parallel tools are a graph.

Result

The platform as on the resume: more than two hundred sites ranked, more than two-hundred-page BRDs, evals and test-case generation. Production path is Python FastAPI. Live Code is still Java.

Example. The first time two high-ranked pages contradicted each other, a first-hit writer looked confident. Learning the stack meant learning to rank by agreement and source type, and to refuse an answer without a retrieved span. That is curiosity with a stop condition, not another tool node.

Situation

I was on the Tech Team at IEDC CUSAT while doing CSE at CUSAT with a CGPA of 8.42 out of 10. New people joining club and hackathon work did not share one stack. If only one person could run the build, the next event failed when that person was on another laptop. I was a team member, not a manager. I did not hire anyone. I do not have a mentee count.

Task

Raise the floor so a teammate could ship. That meant shared setup and the path we had already burned, not a “mentor” title on a slide.

Action

On the Tech Team I shared environment setup, reviews, and “here is the failure we already hit” on tools we actually used. At eight national and regional hackathons I paired on the risky module instead of hoarding it. On Horizon I made ROS2, camera, and costmap knowledge usable by the rest of the rover team, because a solo notebook does not place 17th.

Result

Honest outcomes: IEDC Tech Team on the resume; Horizon 17th of more than eighty as core software; first at CodeRecet, MLH Best Project, Magnathon 2.0 runner-up. CGPA is education, not this LP’s metric.

Example. If only I understood the GStreamer launch order, the rover failed when I was on mapping. Sharing topic names and launch order is developing the team. Writing a ten-line runbook earlier is what I would do next; the resume does not claim a wiki, so I will not say we had one.

Situation

Argus sits on industrial safety. 73 percent mAP is a model card. It is not a standard you page a supervisor on. Alarm fatigue is the cost of a low bar. A model that is accurate in a notebook and slow on the stream is also a low bar, because the floor does not pause for your batch size.

Task

Make the standard three things together: the eval number, live FPS, and logged alerts. Missing any one of them is not “almost production.”

Action

I used more than 15,000 images, not a toy set. I moved YOLOv9 from 73 to 89 percent mAP. I required 24 FPS on the stream. I logged to Postgres and containerized a path that could support more than twenty cameras. I did not scale the 73 percent model to those cameras to look busy. That is defects not sent down the line. The problem stays fixed because the gate is mAP plus FPS plus logs, not a one-time notebook win.

Result

Safety violations down 50 percent. Compliance doubled. The standard was the gate, not a paragraph in a README.

Example. Lighting and vest color were not a one-line OpenCV threshold. They were dataset work. Haar cascades do not take PPE from 73 to 89 mAP at 24 FPS. I kept OpenCV for decode and resize, and I kept YOLO for the boxes we alert on.

Situation

Computer-vision work gets stuck in a local loop: one GPU, one notebook, one model, one person. StratifyLabs is a CV SaaS with a 3D simulation lab at stratifylabs.design. It is not a one-model demo. The GitHub README is default Next.js; I will not invent features from it. The resume is the product.

Task

Make experiment, share, and reuse the default, instead of a Colab per person and a training box per tweak. Thinking small would have been one model on my laptop. Looking around the corner for customers is CV people who are not ROS experts still being able to prototype in the browser.

Action

I built a 3D simulation lab for real-time experimentation and prototyping. I put inference in the browser so ML iteration dropped 30 percent. I shipped a marketplace of more than fifty pretrained models and datasets, community profiles, and a URDF editor with WebGL. Gemini RAG bots sit in the simulated environment as 3D characters, conditioned on the scene, not as a generic chatbot beside a canvas.

Result

Iteration time down 30 percent. More than fifty marketplace items. I will not add a go-to-market number.

Example. A CV intern who is not a ROS expert should still load a URDF in the browser and try a pretrained model without waiting on a lab machine. That is Think Big relative to “train on my laptop.” It is not Horizon’s field rover, and I will not merge the stacks.

Situation

Team Horizon, February to June 2024. ERC 2024’s date is fixed. We were building a semi-autonomous Mars rover on ROS2 with student hardware. Waiting for a perfect lab stack after the event is not a decision. Waiting for extra sensors as the first move is also not a decision; it is delay dressed as prudence.

Task

Ship perception and planning that can run. Action without fusion is just a fast video. I needed both in the window.

Action

I shipped the 60 FPS GStreamer camera feed instead of a slow MJPEG experiment. I got ZED 2 mapping at more than two million points per second into RViz and Gazebo. I put costmap planning and predictive fusion on the sensors we had, rather than parking the software until another unit arrived. Field time was part of the action: Gazebo lighting was not dirt.

Result

17th globally of more than eighty teams. Obstacle detection up 40 percent. Collision risk down 55 percent.

Example. A rover that maps in bags but has no costmap still collides. The action that mattered was planning on a live occupancy grid, not recording a prettier bag. Downsampling for viz and keeping density for the local costmap was a same-week choice, not a research paper.

Situation

Ylogx ran BI and SQL RAG on Postgres. Every natural-language question hitting the database is both latency and money. The obvious spend is a larger instance. The intern’s temptation is to call that “scale.”

Task

Cut load without buying a bigger database as the first move, and without dropping isolation.

Action

I put Redis on the bot path and cut database latency 35 percent. I deployed CloudFront plus ECS plus Docker CI/CD instead of over-provisioning a snowflake host. I used one routing path — GoDaddy DNS into Route 53 into an ALB — and held sub-210 milliseconds. Cached answers still had to be tier-correct under RLS. There are no extra points for a larger instance class. I will not invent an AWS bill or a TTL.

Result

Minus 35 percent bot database latency, sub-210 milliseconds, 99.9 percent uptime, 40 percent faster reports. Thirty dashboards and plus 60 percent ops efficiency are the broader serving result, not a second spend story.

Example. Repeat NL questions and schema metadata are cache-shaped. A dashboard KPI that must be sub-210 milliseconds does not go through an LLM at all. Frugality is also “do not put a foundation model on the hot path.”

NL question
  → Redis (hot schema / repeat answer, still tier-scoped)
  → FastAPI SQL RAG → Postgres as user role (RLS)
Dashboard KPIs: API + cache, no LLM on the sub-210 ms path

Situation

GiftedBooks is a VR learning suite: 3D labs, AI avatars, and PDFs. The awkward sentence I had to say out loud is that a pretty lab that cannot answer a question from the student’s own material is decoration, and a generic chatbot that sounds like a textbook is not a teaching assistant. That is vocally self-critical. I will not pretend the VR surface was enough. GitHub currently shows an AegisAI README on the GiftedBooks repo. I will not mix that product into this story. The resume is the source.

Task

Benchmark against a real TA, not against a demo that “feels smart.” Ground answers in the upload. Keep the suite up. Be honest about what exams actually ask.

Action

I said the failure mode before we dressed it up: hallucinated citations and downtime both burn trust, and they would be on the product I shipped. I shipped contextual PDF Q&A, not a general LLM with a textbook voice. I held sub-300 millisecond API responses and 99.5 percent uptime. I used PYQ-prioritized topics so the product is honest about exams. Per-user PDFs must not retrieve another student’s notes. I did not claim the suite was already a substitute for a teacher.

Result

Doubt time from hours to three to ten minutes. Reading efficiency up 35 percent, engagement up 50 percent, comprehension 2.5 times. I will not claim zero incidents. I will not say the body of work smelled of perfume because the VR looked expensive.

Example. If the model answers a definition that is not in the student’s PDF, the student will memorize a fluent lie. Saying that in a review is Earn Trust. Citation from the chunk is the mechanism. PYQ is the honesty mechanism for what to study. Backup if they want a teammate-facing version: Ylogx — I said I would not ship the bot on app-only filters, which is candid when the demo already “worked.”

Situation

The Ylogx SQL RAG chatbot was “working” while bot database latency and cross-tier risk were the real product. On a happy-path account the model wrote SQL, Postgres returned rows, and a non-technical user nodded. That is the anecdote. The metrics disagreed: every natural-language turn was hitting Postgres, and a JOIN could outrun an app filter. Users who are not SQL experts would have trusted wrong grain or leaked rows with the same confidence they trusted a correct KPI. I was an intern on FastAPI, NestJS, and Postgres, not a named DBA team. Measuring the query path myself was not beneath the intern ticket.

Task

I had to separate three hypotheses: bad query shape, missing cache, and security checks in the wrong layer. Isolation for three organizational tiers had to live where SQL actually runs. If I only sped the bot up, I might have cached a leak. If I only added a UI filter, a JOIN would still outrun me.

Action

I measured bot database latency instead of celebrating that SQL came back. I put row-level security and RBAC in Postgres for those three tiers so generated SQL ran as the user’s database role. A JOIN could not outrun the app because the database refused the row. I then put Redis on the hot bot path so repeat questions and schema lookups were not a round trip every time, without skipping RLS. A cached answer still had to belong to the right tier. I kept the serving path on CloudFront, ECS, Docker, and an ALB so the same discipline applied to how the app was reached.

Result

Bot database latency dropped 35 percent. Analysis productivity for people who were not writing SQL went up 65 percent. Report generation got 40 percent faster. We held 99.9 percent uptime, and dashboards stayed in the sub-210 millisecond number on the resume. Thirty KPI dashboards later showed a 60 percent ops-efficiency move. The deep dive was latency plus isolation. It was not a search-console ticket, and I will not lead with 403 or noindex.

Example. A user in one org asked a dashboard-style question that, without RLS, would have joined a shared fact table and returned another org’s KPIs. The generated SQL was syntactically fine. The database role is what made it fail closed. Redis then stopped us from paying for that same allowed query on every follow-up turn. Showing the SQL to the user is how you catch wrong grain even when the tenant is correct.

Situation

The default for “RAG on PDFs” is a vector index and a demo. IQVIA BRDs are more than two hundred pages. Test-case generation from the wrong section is expensive for whoever consumes the BRD. A teammate or stakeholder who wants vector-only is not being foolish; they are optimizing for a ship date. I still had to say the failure mode out loud.

Task

Argue for Hybrid plus Semantic Azure AI Search plus GraphDB plus traces. Do not ship the demo index as the system. After the path is chosen, stop debating tools and instrument the path.

Action

I stated the failure mode: similar embeddings are not requirement coverage. Clause IDs and dependency graphs do not fall out of cosine. I proposed hybrid plus semantic plus GraphDB plus LangGraph adaptive retrieval. That is conviction, not social cohesion around the faster vector demo. I committed via LangSmith evals and test-case generation. Once we chose the path, I traced it rather than reopening the tool debate every week. Commit wholly means instrument the chosen path, not keep a quiet side project on FAISS.

Result

Hybrid RAG as on the resume. Two-hundred-page BRDs. Evals and test-case generation. Disagree on retrieval; commit on evals. There is no named interpersonal incident on the resume, and I will not invent one.

Example. “Retention policy” as a semantic query versus “R-141” as a lexical query is the disagreement in one sentence. Vector-only answers the first and misses the second. The commit is an eval that fails if the generated test case has no overlapping span with the retrieved section.

Situation

ERC 2024 had more than eighty international teams. I was Horizon software from February to June 2024. Activity would have been more bags, more slides, more Gazebo screenshots. The result the judges score is a rover that runs the challenge on the day. The date does not move because your lighting in simulation still looks clean. Dirt and dust were not in the Gazebo world we trained our eyes on.

Task

I needed a field-capable perception and planning stack by that date. A lab video was not a result. A rover that maps in bags and still collides is not a result either. The setback was time-sync: the operator feed could look live while occupancy was already old, and Gazebo lighting was not dirt. Rising to the occasion meant debugging that path, not settling for a prettier bag.

Action

I shipped GStreamer at 60 FPS instead of a naive web stream that would have dropped the operator feed. I took ZED 2 mapping at more than two million points per second into RViz and Gazebo so we had occupancy, not a pretty cloud on a laptop. I put costmap planning and sensor fusion in front of the actuators so we were not waiting on extra hardware as the default spend. When the costmap lagged, the rover planned on stale occupancy. That was the ship-blocker, and I treated it as one. We downsampled for visualization and kept density for the local costmap.

Result

We placed 17th globally of more than eighty teams. Obstacle detection accuracy improved 40 percent on the resume’s pipeline. Collision risk dropped 55 percent after fusion, not after a purchase order. The run happened. The resume does not state a miss, and I will not invent one to sound humble.

Example. If 60 FPS slipped, the operator was blind. If the costmap was stale, the planner was lying. Delivering results meant those two were not optional in the last week. A new architecture in that week would have been motion, not a result.

Situation

Horizon rover software is unusable if camera and mapping knowledge lives in one head. ERC is a team score. I was a software team member, not a people manager, not HR, and not a hiring bar raiser.

Task

Make the software path teachable under a fixed date so the rest of the rover team could integrate, not watch me type. Growing means they can launch perception without me. Empowered means they are not blocked on my laptop. Ready for what’s next means a teammate can run the build at the next event or the next subsystem, including after I am on another node.

Action

I worked as a software team member, not a hero module. I shared GStreamer, ZED, and costmap constraints so others could integrate. I used the same habit at IEDC and at hackathons: the person next to you can run the build. That is an environment, not a program name I will invent.

Result

17th of more than eighty is a team result. IEDC Tech Team and eight hackathons are on the resume. I will not claim a happiness score.

Example. Siloed ROS nodes meant one person could run perception and nobody else could launch planning. Pairing on launch files is the Earth-Best-Employer-sized version of this LP for a student team. I would pair earlier. I did not run a mentoring program with a name.

Situation

One camera demo does not create industrial safety. Wrong alerts at more than twenty cameras scale harm as well as good. Alarm fatigue is the downstream effect. Argus is that product.

Task

Scale only a detector that passed mAP. Log what you alert. Do not multiply a 73 percent model across a site to look like coverage.

Action

I did not scale 73 percent mAP. I got to 89 percent mAP at 24 FPS on more than 15,000 images. Then I containerized more than twenty feeds, wrote Postgres logs, and shipped alerts that cut violations 50 percent and doubled compliance. Video stays off the database; events go in. That is create more than you consume: an audit trail, not twenty copies of a miss. I will not invent EKS because Ylogx is the ECS story. I will not claim a climate or community program.

Result

More than twenty cameras, minus 50 percent violations, 2 times compliance, after the eval gate, not before it.

Example. Twenty copies of a model that misses helmets is twenty times the ignored alarm. Responsibility is the gate. A heavier model that cannot hold 24 FPS is also irresponsible at that camera count.

I am a software developer intern at IQVIA in Kochi, from April 2026 to the present. I work on two research systems, not on “we called an LLM.” The first is a LangGraph Deep Research platform: a stateful agent graph that fans out Firecrawl plus Bing, DuckDuckGo, and Google Playwright, ranks sources across more than two hundred websites, and writes a result. The second is Hybrid RAG: Azure AI Search with hybrid and semantic retrieval, a GraphDB, and LangGraph choosing retrieval mode on more than two-hundred-page BRDs and PDFs, with LangSmith tracing for evals and generated test cases. Production is Python FastAPI. Live Code for this loop is Java.

Before IQVIA I interned at Ylogx from November 2024 to October 2025 on full-stack AI BI: FastAPI, NestJS, Postgres, SQL RAG, three-tier RLS, Redis, and AWS CloudFront/ECS, with 99.9 percent uptime and 40 percent faster reports. Before that I was core software on Team Horizon for ERC 2024, 17th of more than eighty teams. If they want one number after the IQVIA minute, I give 200+ sites and 200+ page BRDs and stop. If they want Prince’s three one-liners: IQVIA 200+; Ylogx 99.9 percent; Horizon 17th — then I go deep on one.

Example of stopping. I do not list StratifyLabs, GiftedBooks, Argus, and eight hackathons in the current-role answer. Those wait for “tell me about a project.”

The last deep dive I will defend on the resume is Ylogx, not a search-console 403. The chatbot returned SQL and rows, so it looked healthy in a demo. That was the anecdote. The metrics disagreed. Every natural-language turn was hitting Postgres, so latency felt like “the model is thinking” when the database was the cost. And if isolation lived only in the application, a JOIN or a generated query could outrun a UI filter and return another organization’s rows. My task was to find whether slowness was query shape, missing cache, or security in the wrong layer, and to make three organizational tiers real on the path the bot and the reports already shared. Measuring that path was not beneath the intern ticket.

I measured bot database latency instead of blaming the generator. I put RLS and RBAC in Postgres so generated SQL ran as the user’s database role. I put Redis on the hot path for a 35 percent drop in database latency without skipping RLS. A cached answer still had to be the right tier. Uptime stayed 99.9 percent. Analysis productivity for non-SQL users moved 65 percent because the bot was both faster and safe to trust. Report generation on the same product got 40 percent faster. Dashboards stayed in the sub-210 millisecond number. I will not lead this answer with www versus non-www indexing. That is prep-only.

Example. A JOIN that is legal SQL and illegal for the tenant is the bug class. The SQL can look perfect in my account and still be a leak. The database role is the fix. Cache is the follow-up so we do not pay for the allowed query every turn. Showing the SQL to the user is how wrong grain shows up even when the tenant is correct.

I do not have a named interpersonal blow-up on the resume, and I will not invent a manager quote or a raised-voice scene. The conflict I will speak is technical, because that is what I actually had. At IQVIA the fast path for “RAG on PDFs” is a vector index and a demo. A teammate or stakeholder who wants that path is not being foolish. They are optimizing for a ship date. I still had to say the failure mode out loud. Two-hundred-page BRDs have clause IDs and requirement graphs that cosine search misses. Test-case generation from the wrong section is expensive for whoever consumes the BRD. Similar embeddings are not coverage.

I argued for Hybrid plus Semantic Azure AI Search plus a GraphDB plus LangGraph adaptive retrieval, with LangSmith traces so we could see a bad path. Lexical search catches “R-141.” Semantic search catches “what is the retention policy.” Graph hops catch dependencies. Once we chose that path, I committed by instrumenting evals and test-case generation instead of reopening the tool debate every week. Disagree on retrieval. Commit on evals.

If they already heard IQVIA, I use Ylogx. The conflict is RLS in the database versus app-only filters. I would not ship the bot on app-only checks because a JOIN leaks. The commit was three-tier RLS and RBAC as a platform rule, not a UI hide. Optional Horizon: software costmap versus “buy another sensor.” We committed to fusion. Collision risk dropped 55 percent.

Example. “Ship the vector demo by Friday” versus “R-141 must be retrievable on Monday.” The disagreement is coverage, not personality. The commit is an eval that fails if a generated test case has no overlapping span with the retrieved section. I did not overrule a named manager. I will not perform a fight.

The honest on-resume version is Argus, and I will say that out loud if they want a person’s name I do not have. 73 percent mAP was the feedback. It was not production quality for PPE on a floor. At that number you miss helmets and you also fire junk boxes. Either failure trains people to ignore the alarm. I did not treat 73 percent as a starting blog metric. I did not ship that detector as the standard for alerts. I trained and evaluated on more than 15,000 images, iterated YOLOv9 to 89 percent mAP, and required 24 FPS so the model we called “right” could keep up with the stream. Then I logged events to Postgres and containerized a path that could support more than twenty cameras. Safety violations later dropped 50 percent and compliance doubled, after the gate, not before it.

I do not have a confirmed manager quote, and I will not invent one. If they insist on person-feedback and I have no review story, I say so and stay on this metric. Backup if they already heard Argus: the system’s own feedback on Ylogx was bot database latency before Redis, which we cut 35 percent.

Example. A missed helmet in odd lighting is a silent fail. A false box is a loud fail. Both live inside 73 percent mAP. Haar cascades and a one-line color threshold do not take PPE from 73 to 89 at 24 FPS. An LLM describing the frame is not the feedback response either. The response is data, a held-out eval, and a frame-rate gate.

LangGraph, LangSmith, and Azure hybrid search were not required to “call an LLM from FastAPI.” That call was already a skill from Ylogx SQL RAG. They were required to rank more than two hundred websites and to retrieve from two-hundred-page BRDs without inventing citations. Tutorial-complete is not architecture. I learned enough to draw a planner, parallel tools, a ranker, a writer, and a fail-if-no-span eval. I learned stateful graphs so a failed scrape does not restart the whole run. I learned adaptive retrieval: lexical for clause IDs, semantic for policy language, graph hops for dependencies. I learned LangSmith as a stop condition, including generated test cases, so curiosity had a pass or fail.

The result is the IQVIA platform on the resume: more than two hundred sites ranked, more than two-hundred-page BRDs, evals and test-case generation. Production is Python. Live Code is Java. If they want a different stack, Horizon ROS2, GStreamer at 60 FPS, and ZED 2 at more than two million points per second were not the web intern job either. That learning showed up as 17th of more than eighty teams, plus 40 percent obstacle detection, minus 55 percent collision risk.

Example. I discarded “one vector index named RAG.” Long BRDs needed lexical plus semantic plus graph. I also discarded a linear chain for Deep Research, because retries and parallel tools are a graph. Those discards are the learning, not a course certificate.

On paper my Ylogx ticket was a chatbot and a report builder. Isolation and bot database latency were not “just SQL generation.” They were still the product, because a chatbot that leaks a tier or waits on Postgres is not a chatbot you can give to a non-technical user. I found that while delivering the feature I was asked for. I put three-tier RLS and RBAC in the database so generated SQL could not outrun the app. I measured bot database latency instead of assuming the model was slow. I shipped Redis for a 35 percent drop without skipping RLS. 99.9 percent uptime held. Analysis productivity moved 65 percent. That is an issue that was not the demo ticket and still had to close.

If they already heard Ylogx, GiftedBooks is the backup. Doubt hours were the product issue even if the named work was VR labs and avatars. Students were the customers. I shipped contextual RAG, sub-300 milliseconds, 99.5 percent uptime, and PYQ topics. Doubts went to three to ten minutes.

Example. The SQL looked right in my user account. A JOIN across orgs would not have looked right in production. Finding that while building the bot is the “not my task” part: platform isolation was not the chatbot demo. The UI filter was the tempting ticket-sized fix. It was the wrong layer.

Horizon’s ERC date was the urgent requirement. More than eighty teams show up whether or not your Gazebo world is pretty. Extra hardware would have been the comfortable trade: wait for another sensor, hope the field gets easier. I traded for software on the sensors we had. I shipped a 60 FPS GStreamer feed so we were not blind. I put costmap planning and fusion on the ZED 2 at more than two million points per second. Collision risk dropped 55 percent. Obstacle detection improved 40 percent. We placed 17th of more than eighty. The thing I refused to trade away was a live costmap. A fast camera with no planning is not a trade. It is a miss that still looks like motion.

IQVIA backup if they already heard the rover: hybrid retrieval versus ship-vector-only under document pressure. What I cut was extra Playwright renders and extra tools. What I did not cut was citations and traces.

Example. The field did not match Gazebo lighting. Frames that were fine in sim arrived late in dirt. The urgent work was pipeline latency versus a stale occupancy grid, in the weeks we had, not a purchase order. Downsampling for viz and keeping density for the local costmap was the same-week trade.

On Horizon I was software team, not “the camera person” on an org chart that did not exist. GStreamer and mapping were still ship-blockers for ERC 2024, so I owned them. A webcam-quality demo stream was the designated work for a lab video. Sixty frames per second on the operator and autonomy path was outside that demo and inside the challenge. ZED 2 mapping at more than two million points per second into a costmap was the same expansion. Outcome: the operator could see, the planner had occupancy, we placed 17th of more than eighty, obstacle detection up 40 percent, collision risk down 55 percent.

If they already heard the rover, Ylogx RLS was outside a narrow chatbot ticket. Three-tier isolation as platform, 99.9 percent held, minus 35 percent bot latency, plus 65 percent analysis productivity. If they want IQVIA: test-case generation from BRDs expanded RAG into something a human could audit, with LangSmith traces, on more than two-hundred-page documents.

Example. A Flask MJPEG stream was in scope for a screenshot. GStreamer at 60 FPS was outside that screenshot. The outcome is not a prettier README. The outcome is a feed the challenge can use. Public Gstreamer-UDP is a supporting webcam artifact in the same family, not a second project I will pad this answer with.

ERC 2024 is a calendar date. It mattered because more than eighty teams show up whether or not your costmap converged. I sequenced 60 FPS and a live costmap first. The compromise was software planning versus more hardware, not “skip safety.” We fused the ZED 2 we had instead of waiting on another unit. Collision risk down 55 percent is what that compromise bought. Obstacle detection up 40 percent sits on the same pipeline. We placed 17th of more than eighty. I did not cut isolation on a later job to make a date, and I will not invent a cut on Ylogx 99.9 percent. A lab video as the deadline artifact would have been the wrong compromise. Gazebo-only would have been the wrong compromise because dirt lighting is real.

If they want a shorter clock, eight hackathons with first at CodeRecet, MLH Best Project, and Magnathon 2.0 runner-up is the backup. Resume wording is rapid software development and production-ready deployment. I will not invent hours-to-prize or a hackathon architecture the resume does not name. If they pick a named product after that, I walk StratifyLabs, GiftedBooks, or Argus.

Example. A new architecture in the last week would have been motion. A stable feed plus costmap was the deadline. Why it mattered: the challenge does not accept a rain check. What I refused to cut was a live occupancy grid.

Yes. From February to June 2024 I was on Team Horizon for ERC 2024. The date is fixed. Waiting for a perfect lab stack after the event is not a decision. Waiting for extra sensors as the first move is delay dressed as prudence. I shipped a real-time camera pipeline at 60 FPS with GStreamer. I got ZED 2 mapping at more than two million points per second into RViz and Gazebo. I put costmap planning and predictive fusion on the sensors we had. Field time was part of the action, because Gazebo lighting was not dirt. We placed 17th of more than eighty teams. Obstacle detection improved 40 percent. Collision risk dropped 55 percent.

Action without fusion would have been a fast video that still hits rocks. Reckless action would have been skipping the costmap to look busy. I did neither. If they already heard the rover, the intern version is Ylogx: measure bot database latency, ship Redis, minus 35 percent, do not wait for a rewrite. Eight hackathons, first at CodeRecet, is the shortest clock.

Example. A rover that maps in bags but has no costmap still collides. The action that mattered was planning on a live occupancy grid the same week, not recording a prettier bag. Downsampling for viz and keeping density for the local costmap was a same-week choice, not a paper.

The task I am proud of is the Horizon software stack that actually ran at ERC 2024. I am proud of it because the date was real, the field was not Gazebo, and the score is 17th of more than eighty teams. I was core software from February to June 2024 on a semi-autonomous Mars rover. The hard part was not a model card. It was a 60 FPS GStreamer feed plus ZED 2 mapping at more than two million points per second plus a costmap the planner could trust when lighting and dust disagreed with simulation. Stale occupancy was the bug class: the rover plans on yesterday’s world and looks autonomous while it collides. I treated that as a ship-blocker. We fused sensors and planned on a live grid. We downsampled for visualization and kept density for the local costmap so two million points per second did not all try to leave the rover. Obstacle detection improved 40 percent. Collision risk dropped 55 percent. I would pick this when they want Deliver Results or Bias for Action sitting under “proud.”

Example. Operator sees 60 FPS. Planner sees last second’s rocks. Those can diverge. The proud work is noticing that split and closing it before challenge day, not a prettier bag file.

The task I am proud of is GiftedBooks RAG question-and-answer that took student doubts from hours to three to ten minutes. I am proud of it because the customer is a student with their own PDF, not an internal dashboard. VR labs without answers are decoration. A generic bot that sounds like a textbook is the wrong customer. Students were losing hours even with the notes in front of them. I grounded Q&A in the upload so answers came from their material. I held sub-300 millisecond API responses and 99.5 percent uptime so the assistant was usable during study, not only in a demo. I added PYQ topic suggestions so people studied what exams actually ask, which is analytics, not an LLM guessing the syllabus. Reading efficiency went up 35 percent. Engagement went up 50 percent. Comprehension moved 2.5 times. GitHub currently mismatches AegisAI on that repo. I am proud of the resume product, not the wrong README. I would pick this when they want Customer Obsession or Earn Trust under “proud.”

Example. A definition that lives in a table on page forty must come from that table, inside the latency budget. Dumping the whole PDF into a long context misses both grounding and sub-300 milliseconds. That retrieve-plus-small-generate path is the proud mechanism.

IQVIA LangGraph was the fast learn. Ylogx had been FastAPI, NestJS, Postgres, and SQL RAG. Multi-agent research, hybrid retrieval, GraphDB hops, and tracing were not that day job. I did not become tutorial-complete. I learned enough to draw a planner, parallel tools, a ranker, a writer, and a fail-if-no-span eval. I used LangGraph so a failed scrape does not restart the run. I used Azure AI Search hybrid plus semantic plus GraphDB because two-hundred-page BRDs are not one embedding query. I used LangSmith as the stop condition, including generated test cases. The result is more than two hundred sites ranked and more than two-hundred-page BRDs processed with traces.

Horizon ROS2 is the other fast learn if they want a non-LLM stack. GStreamer at 60 FPS, ZED 2 at more than two million points per second, costmap fusion, 17th of more than eighty, plus 40 percent obstacle detection, minus 55 percent collision risk. Eight hackathons are the shortest clock, with first at CodeRecet, MLH Best Project, and Magnathon 2.0 runner-up. I will not invent a hackathon stack because the resume does not name it. If they want a named product after a hackathon prompt, I walk StratifyLabs, GiftedBooks, or Argus.

Example. What I discarded quickly: a linear LangChain chain for Deep Research. Parallel scrape plus retry is a graph. That discard saved the week. What I also discarded: stuffing the BRD into one prompt. Token limits and invented citations show up immediately.

The mistake I will own is treating 73 percent mAP on Argus as progress. It looked like a training curve going the right way. It was not a standard I should alert humans on. At 73 percent you miss helmets and you fire junk boxes. Either one trains people to ignore PPE alarms. I almost treated a notebook number as a ship bar. I learned to put an mAP gate and a 24 FPS gate in front of scale. I went to more than 15,000 images and 89 percent mAP before more than twenty cameras. I logged alerts to Postgres so compliance was an audit trail. Violations down 50 percent and compliance doubled are what happened after I stopped calling 73 percent a win. I will not invent a missed 99.9 percent or a missed ERC to sound more humble. Those misses are not on the resume.

Backup mistake if they already heard Argus: SQL RAG at Ylogx without a cache. The chatbot “worked.” The database paid for every turn. I learned to measure bot database latency and ship Redis for minus 35 percent, still behind RLS.

Example. Shipping 73 percent to one webcam is a notebook. Shipping it to twenty cameras is alarm fatigue. The mistake was the scale decision, not the first training run. Haar or a color threshold would have been a second mistake on the same product. An LLM looking at frames would have been a third.

IQVIA Hybrid RAG on more than two-hundred-page BRDs was the significant technical challenge, and I will go deep on this one unless they already heard it. The constraint was confidential long documents plus a need to rank and cite. Stuffing the PDF into a context window blows tokens and invents citations. Vector-only retrieval returns similar paragraphs and misses clause IDs. A linear chain cannot retry a scrape or hop a requirement graph. Test cases generated from the wrong section waste whoever consumes the BRD. I built hybrid plus semantic Azure AI Search, GraphDB hops, LangGraph adaptive retrieval, and LangSmith traces. Lexical for IDs, semantic for policy language, graph for dependencies, cite or abstain. More than two hundred sites on the Deep Research side, more than two-hundred-page documents on the RAG side. No extra percentage on the resume.

If they want physics instead of retrieval, Horizon is the challenge: ZED 2 at more than two million points per second plus a costmap that must not go stale, 60 FPS, 17th of more than eighty. If they want eval, Argus is 73 to 89 percent mAP at 24 FPS on more than 15,000 images. I pick one and go deep. I do not list all three.

Example. Two pages disagree; the writer still sounds sure. Ranking by agreement and refusing a span-less sentence is the challenge, not GPU count. Empty scrape still feeding the writer is the LangSmith-visible version of the same bug.

Deep Research at IQVIA has no single gold page. You rank more than two hundred websites without knowing which one is right. Limited information is the job, not an excuse. I used parallel scrape and search — Firecrawl, Bing, DuckDuckGo, Playwright — because one source family fails on different sites. I ranked on quality, recency, and agreement instead of first-hit confidence. I used LangSmith so a fluent paragraph without a source is a fail. I refused to answer without a retrieved span. Two high-ranked pages that contradict each other is the limited-information case in one picture: you do not get to pretend you know.

Backup: Horizon field sensors versus lab. Gazebo did not tell us the dust or the lighting. We still had to plan. Fusion on ZED 2 plus a live costmap, collision risk down 55 percent, 17th of more than eighty, was how we acted without a perfect world model. 60 FPS was how the operator saw the same incomplete world in time.

Example. Two high-ranked URLs contradict. First-hit retrieval is false certainty. Agreement plus source type is the information we actually had. I will not invent a labeled gold-set size the resume does not state.

I will give two stories on two products, because Bhavya asked both. Customers first. On GiftedBooks, students were losing hours on doubts even with VR labs and PDFs in front of them. A pretty lab that cannot answer from their material is decoration. I shipped contextual RAG over the upload, held sub-300 milliseconds and 99.5 percent uptime, and added PYQ topics so people studied what exams ask. Doubts went to three to ten minutes. Reading efficiency went up 35 percent. Engagement went up 50 percent. Comprehension moved 2.5 times. That is above and beyond a VR lab that only looks like school. If they already heard GiftedBooks, Ylogx SQL RAG plus 65 percent analysis productivity is the employer-customer version: non-technical users stopped waiting on an analyst for every slice, behind three-tier RLS.

Teammates second. I was on the Tech Team at IEDC CUSAT and on Horizon software. I am not a manager and I do not have a junior headcount or ratings. I shared environment setup, reviews, and “here is the path we already burned.” On Horizon I made GStreamer, ZED, and costmap knowledge usable by the rest of the rover team, because a solo notebook does not place 17th of more than eighty. At eight hackathons, including first at CodeRecet, I paired on the risky module instead of hoarding it. CGPA 8.42 is education, not this answer’s metric.

Example. Customer story ends on three to ten minutes. Teammate story ends on someone else launching the GStreamer node. If I use one metric for both, they will think I have one story. I will not mash GiftedBooks into IEDC.

Ownership — Ylogx

I owned three-tier RLS and RBAC in Postgres on the path the bot and reports share. I was an intern, not a manager, and app-only filters were still not ownership. Generated SQL ran as the user’s database role so a JOIN could not outrun the UI. I kept 99.9 percent uptime while report generation went 40 percent faster. I put Redis on the bot path for minus 35 percent database latency so isolation was not an excuse for load. Analysis productivity moved 65 percent. Thirty dashboards and plus 60 percent ops efficiency sit on the same serving path, sub-210 milliseconds. I still owned the data path.

Working under pressure — Horizon

ERC 2024 does not slip. More than eighty teams show up. I shipped 60 FPS and a live costmap on the hardware we had instead of waiting on extra sensors. Stale occupancy was the pressure bug: the rover looks autonomous while it collides. We fused ZED 2 at more than two million points per second and planned on a live grid. 17th of more than eighty, collision risk down 55 percent, obstacle detection up 40 percent. Pressure without a costmap is just stress. Backup pressure: eight hackathons, first at CodeRecet, production-ready deploy in the window.

Learning and adapting — IQVIA

LangGraph, hybrid Azure search, GraphDB, and LangSmith were new relative to Ylogx FastAPI and NestJS. I adapted by making traces the stop condition on more than two hundred sites and two-hundred-page BRDs. I learned adaptive retrieval instead of one vector index. I did not adapt by adding tools without evals. Test-case generation is itself a traced job. Production is Python. Live Code is Java.

Example of the trio in one breath if they rush: Ylogx RLS and 99.9 percent; Horizon 17th of more than eighty; IQVIA LangGraph on 200+ page BRDs. Then they pick one to probe. I do not volunteer sixteen LP names.

IQVIA Deep Research and Hybrid RAG were the POC series, and I will walk what I tried and what I discarded. One scraper is not enough. Firecrawl, Bing, DuckDuckGo, and Playwright each fail on different sites, so the graph fans out and checkpoints state. Vector-only is not enough on two-hundred-page BRDs, so the POC was hybrid plus semantic Azure AI Search plus GraphDB versus a single index. A linear LangChain chain cannot retry or hop a requirement graph, so that POC died. Stuffing the PDF into one prompt dies on tokens and invented citations. Evals in LangSmith were the stop condition: if a generated test case has no overlapping span, the path is not done. I discarded Qdrant as a story because the resume is Azure AI Search, not a prep synonym. The result is more than two hundred sites ranked and more than two-hundred-page BRDs processed with traces and test-case generation. No extra percentage.

Backup: Ylogx was FastAPI plus NestJS plus Postgres plus Redis plus RLS versus “just LangChain.” The discarded path was a service-role LLM writing SQL. App-only filters were another discarded POC. Three-tier RLS, minus 35 percent bot latency, 99.9 percent uptime is what shipped.

Example. Playwright on every URL is a POC that loses on cost. Bing snippets first, full render only when the snippet is thin — that is a discarded-versus-kept pair I can draw. LC 7981646’s Innovate and Frugality architecture slot uses this same drawing: adaptive retrieval plus GraphDB to invent; cache and fewer renders to be frugal.

I do not have a missed ERC or a missed 99.9 percent on the resume, and I will not invent one to sound humble. Amazon asks this because they want to hear how you flag risk, not a fictional failure. What I will say is how the immovable date was met and how I would communicate if a ship-blocker were late. ERC 2024 was fixed. More than eighty teams show up. I sequenced 60 FPS and the costmap so the run happened. We placed 17th of more than eighty. Collision risk dropped 55 percent. Obstacle detection improved 40 percent. Communication, if a ship-blocker is late, is early and specific: the feed is late, or the costmap is stale, or RLS is not in the database yet. Then we cut extra hardware or extra features. We do not cut isolation. We do not scale a 73 percent safety model. We do not skip the occupancy grid to look busy. If I later confirm a real miss off-resume, I will not use it until it is on the record.

Example. “We might miss ERC” is useless in week twelve. “Costmap is planning on stale occupancy; fusion is the path; extra sensor is the cut” is communication. The run happened because 60 FPS and planning were sequenced first, not because I pretend we missed.

I answer on whichever STAR they are already in. For IQVIA: I chose hybrid plus graph because vector-only misses IDs and dependencies; I would freeze an eval slice earlier. For Ylogx: I chose RLS in the database because app-only fails on JOINs; I would test denied cross-tier cases from day one; I measured success as minus 35 percent bot latency, 99.9 percent uptime, and three tiers, not a feeling. For Argus: I chose not to scale 73 percent mAP; I would hold out a camera earlier; success is 89 percent mAP, 24 FPS, minus 50 percent violations. For Horizon: I chose costmap fusion over extra hardware; I would time-box that choice against collision risk earlier; success is 17th of more than eighty and minus 55 percent collision risk. Disagreement is Backbone: hybrid versus vector-only, or RLS-in-DB versus app-only, then commit on evals or on the platform rule.

Example. “Why Redis not bigger RDS?” Repeat NL questions are cache-shaped. Success is minus 35 percent, not an instance class I will not invent a price for.

I use GenAI where the output is high-volume, pattern-based, and cheaply verifiable. At IQVIA that is Deep Research across more than two hundred ranked sites and Hybrid RAG on more than two-hundred-page BRDs, with LangSmith traces, cited spans, and generated test cases a human can spot-check. At Ylogx that is SQL RAG: natural language to SQL behind three-tier RLS, which is plus 65 percent analysis productivity. At GiftedBooks that is PDF Q&A grounded in the upload, sub-300 milliseconds, 99.5 percent uptime. I verify in three ways. Overlapping span with retrieved chunks, or the writer abstains. SQL executed as the user’s RLS role, not as a service superuser. Gold questions with expected citations or expected SQL shape. I keep dashboards off the model: Ylogx sub-210 milliseconds is not an LLM path. Redis minus 35 percent is efficiency on the bot path. I do not dump ninety days of rows into a prompt. I pre-aggregate in SQL, same shape as “highest KFC orders last three months”: warehouse facts, group by, order, limit, and the model returns SQL or explains the result.

I do not use GenAI for Ylogx RLS policy, for Horizon costmap or actuation, or for Argus PPE boxes. Those must be exact and auditable. An LLM that describes a helmet is not 89 percent mAP at 24 FPS. An LLM that describes a rock is not a costmap. Copilot for Live Code is draft-then-compile and bounds-check, not paste. Fluency is not correctness. If this slot is actually Distance K labeled Fluency, I write the tree algorithm and stop the essay.

Example. Should: “return SQL only” plus RLS, or “cite or abstain” on a BRD chunk. Should not: “look at this camera frame and tell me if PPE is fine.” Should not: “write the costmap.” Should not: “this JOIN is probably allowed.” Should not: the whole BRD in one prompt.

Should:   IQVIA cite-or-abstain; Ylogx NL→SQL as user role; GiftedBooks chunk Q&A
Should not: RLS policies; rover costmap / actuators; Argus bounding boxes
Never:    LLM on Ylogx sub-210 ms dashboards; whole BRD in one prompt

I am proud of Team Horizon’s rover software for ERC 2024. Why: it is the clearest Deliver Results story I have. More than eighty teams, a date that does not move, and a field that is not a simulator. I was core software from February to June 2024. We built a semi-autonomous Mars rover on ROS2. I shipped a GStreamer camera pipeline at 60 FPS so the operator and the autonomy stack could see. I took ZED 2 mapping at more than two million points per second into RViz and Gazebo. I put costmap planning and sensor fusion in front of the actuators so we were not waiting on extra hardware.

The hardest part was a stale costmap. The rover can look fine while it plans on occupancy that is already wrong. Gazebo lighting did not match dirt. The debug was pipeline latency versus the ROS2 callback versus the ZED rate, not “train a bigger vision model.” We downsampled for visualization and kept the dense cloud for the local costmap. OpenCV blob detectors were not the obstacle pipeline; the resume’s plus 40 percent obstacle detection sits on the real stack. The supporting repo Gstreamer-UDP is a webcam analogue, not a second product.

The metric I will end on: 17th globally of more than eighty teams, collision risk down 55 percent, obstacle detection up 40 percent. If they ask what I would do differently: time-box fusion versus extra sensors earlier, and pair on launch files so the knowledge is not in one head.

Example you can gesture. Camera to GStreamer to operator; ZED to point cloud to costmap to planner to actuators; all ROS2 nodes; Gazebo for sim; field for truth.

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

I am proud of GiftedBooks, a VR learning suite with 3D labs, AI avatars, and RAG over student PDFs. Why: the customer is the student, not an internal chart. Doubts that take hours kill study even when the PDF is sitting there. I grounded answers in the upload, held a sub-300 millisecond API, kept 99.5 percent uptime, and added PYQ topic suggestions so people studied what exams actually ask. Reading efficiency up 35 percent, engagement up 50 percent, comprehension 2.5 times, doubts from hours to three to ten minutes.

The hardest part was RAG latency versus quality. Chunks that are too large blow the latency budget. Chunks that are too small miss the table on page forty. Uptime is hosting, not a model trick. I will not invent a named outage or a student headcount. I will not mix the AegisAI README that currently sits on the GiftedBooks GitHub. The resume is the product: VR labs, avatars, PDF RAG, PYQ, those metrics.

If they ask what I would do differently: a small wrong-citation versus grounded eval, the IQVIA habit, which GiftedBooks does not claim. Keep PYQ as deterministic analytics, not an LLM guess of the syllabus. Embed once per PDF; do not re-embed on every question. That is how sub-300 milliseconds stays plausible.

Example. Student asks a definition. Retrieve the span. Generate small. Show the PDF context. PYQ says the topic is asked. That is the two-minute product, not the avatar’s voice.

This is Dive Deep and Ownership, not SEO. The chatbot generated SQL and returned rows. Two bugs hid under that success. First, every natural-language turn hit Postgres, so latency looked like model thought. Second, isolation in the application would fail on a JOIN. Non-technical users would have trusted both failure modes. I measured bot database latency instead of celebrating that SQL came back. I put RLS and RBAC for three tiers in Postgres so the bot and reports shared one data path and generated SQL ran as the user role. I put Redis on the hot path for minus 35 percent latency without skipping RLS. A cached answer still had to be the right tier. 99.9 percent uptime held. Plus 65 percent analysis productivity is what users felt when the bot was both fast and correctly scoped. Forty percent faster reports sit on the same product. Sub-210 milliseconds is the serving path, not an LLM in the dashboard. I will not lead with 403 or noindex.

Example. Syntactically fine SQL, wrong grain or wrong tenant. Show the SQL. Run as the user role. Deny the row. Cache the allowed result. App-only WHERE org_id = ? is the bug you cannot see in a demo of your own account.

This is Are Right, Highest Standards, and the mistake prompt. 73 percent mAP is misses and junk boxes. Either one trains people to ignore PPE alerts. I treated it as a fail, not a starting blog metric. I used more than 15,000 images, iterated YOLOv9 to 89 percent mAP, and required 24 FPS so the “right” model kept up with the stream. Then I scaled to more than twenty cameras with Postgres logs. Video stays out of the database; events go in. Violations down 50 percent, compliance doubled. The bug was not “YOLO is bad.” The bug was calling an unshippable eval a model card and almost scaling it. Haar cascades and color thresholds do not take PPE across that gap. An LLM looking at frames is not the fix either. Fluency is not mAP.

Example. Odd lighting, no helmet, rare frame. Dataset work, not a one-line OpenCV threshold. Twenty copies of a 73 percent model is twenty times the ignored alarm. GitHub argus-stream-api-server README is 404; I will not invent routes while telling this bug.

This is Dive Deep backup and Invent/Backbone depth. There was no named IQVIA outage and no extra percentage on the resume. The bug class is ranking. Two high-ranked pages contradict. First-hit retrieval looks confident. The writer will narrate a fluent compromise that neither page said. I ranked by agreement and source type. I refused to answer without a retrieved span. LangSmith showed wrong tool order and empty scrapes still feeding the writer. Hybrid plus semantic plus GraphDB is how long BRDs avoid the cousin of this bug: similar paragraphs, missed clause IDs. Test-case generation from the wrong section is the same bug in a different coat. I did not use Qdrant. The resume is Azure AI Search and GraphDB.

Example. Page A says a retention window. Page B says another. A first-hit answer cites A and ignores B. Agreement ranking plus cite-or-abstain is the fix. A generated test case with no overlapping span is a fail in LangSmith, not a fluent paragraph we ship.

This is Dive Deep optional, Bias for Action, and Deliver Results depth. The rover mapped. The planner still lied when occupancy was old. Field lighting was not Gazebo. Frames that were fine in sim arrived late in dirt. I debugged GStreamer pipeline latency versus ROS2 callbacks versus ZED point-cloud rate. Those are three clocks, and any one of them can make the costmap stale while the operator feed still looks healthy. We kept dense cloud for the local costmap and downsampled for viz because more than two million points per second cannot all go to a laptop. Fusion and a live costmap dropped collision risk 55 percent. Obstacle detection improved 40 percent. 17th of more than eighty is the result of that bug dying in time, not of a last-week architecture rewrite. The resume does not state a missed ERC. I will not invent one.

Example. Operator sees 60 FPS. Planner sees last second’s rocks. Those are different bugs. The feed can be healthy while the costmap is stale. Measure both. Extra hardware was not the first fix. Software fusion on the ZED 2 we had was.