3. Stories you speak — sixteen Leadership Principles

If they do not name a principle: Dive Deep first — Ylogx Redis and RLS together, bot database latency down 35 percent, three-tier isolation in Postgres. Then Deliver Results — Horizon 17th of more than eighty at ERC 2024. If the intro already used the rover, Deliver switches to Ylogx 40 percent faster reports at 99.9 percent uptime. Third if they want another: GiftedBooks, student doubts from hours to three to ten minutes.

Failure and feedback: Argus 73 percent mAP was not shippable for floor alerts. Deadline: Horizon sequencing to the ERC date; the resume has no missed ERC and no missed 99.9 percent. Conflict: IQVIA hybrid versus vector-only, then commit on evals.

Situation. GiftedBooks is a VR learning suite with 3D labs and avatars. The customer is a student who already has PDFs and still loses hours on doubts from that material. A lab that cannot answer from the upload is decoration. A generic tutor that sounds like a textbook is the wrong customer, because the student is studying from their notes, not from a model’s prior.

Task. I needed to cut time-to-answer without inventing syllabus, keep the assistant usable during study, and make the study path reflect what exams actually asked. I owned the RAG and PYQ path, not every 3D lab or avatar asset.

Action. Three mechanisms, then the option I discarded.

1. I shipped retrieve-then-generate over that student’s PDF: chunk with enough context for a table or derivation, embed once at ingest, store vectors with user and document metadata, and retrieve a small user-scoped top-k at question time.
2. I kept generation small so the API could stay under 300 milliseconds, and I abstained when no supporting span existed. Another student’s notes never retrieve.
3. I added previous-year question topic ranking as a separate deterministic pass over past papers, not as the generator guessing the exam.

I discarded stuffing the whole textbook into every prompt, and I discarded a generic chatbot disconnected from the upload.

Result. Average doubt time moved from hours to three to ten minutes. Reading efficiency improved 35 percent, engagement 50 percent, comprehension 2.5 times. The API stayed sub-300 milliseconds with 99.5 percent uptime.

Situation. At Ylogx I was a software developer intern, November 2024 to October 2025. Operators who were not SQL users still needed warehouse facts. Pasting rows into a prompt truncated data and invented totals. A chatbot that returned numbers without isolation would have served the wrong customer: another organization’s rows.

Task. I needed non-technical people to ask in English and get inspectable SQL and results, without one organizational tier reading another.

Action. Natural-language questions hit FastAPI LangChain SQL RAG with the caller’s identity and organizational tier, constrained to SQL only over allow-listed schema. The query executed read-only as the caller’s database role so row-level security still filtered a JOIN that was too broad, and I returned the SQL with the result so a human could see grain. Repeat schema and hot answers used Redis only with tier and role in the key, so a cache hit was still that customer’s answer. I discarded dumping ninety days of rows into the model, and I discarded generated SQL on a table-owner connection.

Result. SQL RAG improved analysis productivity 65 percent. Isolation stayed three-tier RLS in Postgres. That 65 percent is analysis productivity for those users, not model accuracy.

Situation. At Ylogx I interned on a full-stack AI BI product: FastAPI and NestJS over Postgres, React dashboards, and a LangChain SQL RAG chatbot. The bot returned rows in a demo. Application-only organization checks would still have allowed a generated JOIN to cross a tier. A green demo was incomplete and unsafe.

Task. I was not a named security team. I still owned correctness for three organizational tiers on the shared bot and reporting path. Done was not “SQL appears.” Done was rows that belong to the caller, on a path operators would keep using.

Action. Three mechanisms, then the option I discarded.

1. I put row-level security and RBAC into Postgres so generated SQL ran as the caller’s non-owner database role. A legal JOIN still lost the other organization’s rows at the database.
2. I mapped identity to three organizational tiers — org, team, and user-shaped levels — on both the chatbot path and the report builder, so isolation was not a React hide.
3. I kept that same role mapping in the CloudFront, ALB, ECS, Docker serving path rather than protecting only a local demo, and I held the product at 99.9 percent uptime on that path.

I discarded app-only WHERE org_id = ?, NestJS middleware alone, and trusting the model to remember the tenant predicate.

Result. Three-tier isolation sat in the database. The product held 99.9 percent uptime. Report generation was 40 percent faster on the same identity-to-role path.

Situation. On Horizon I was core software, February to June 2024, not a narrowly titled webcam owner. A lab stream could satisfy a camera demo. ERC required an operator feed and occupancy the planner could trust. A healthy video with a stale costmap is two systems, one of them failing.

Task. I needed to own the software ship-blockers even when they crossed a camera ticket: live video, dense mapping, and a costmap in front of the actuators.

Action. I shipped a GStreamer camera pipeline at 60 FPS so the operator saw the newest frame instead of a stalled historical stream. I moved ZED 2 mapping at more than two million points per second into the local costmap, and I downsampled a separate branch for RViz so visualization did not starve planning. I put fusion and predictive planning on that costmap, and I treated stale occupancy while the feed looked live as the blocker I had to close. I discarded stopping at a camera demo, and I discarded buying another sensor as the first fix near a date that did not move.

Result. We placed 17th of more than eighty teams. Obstacle detection improved 40 percent and collision risk fell 55 percent. I owned the software path, not mechanical or electrical work.

Situation. I am a software developer intern at IQVIA in Kochi, April 2026 to present. Analysts had to live inside more-than-two-hundred-page BRDs. Stuffing a PDF into a context window spends tokens and cites the wrong annex with a straight face. A vector-only demo is fast and still misses exact clause IDs. “What breaks if this requirement changes” is a dependency edge, not a cosine neighbor.

Task. I needed retrieval a human could audit: recover the exact requirement, hop dependents, generate test cases that fail when the span is missing. Simplification meant less untraceable work.

Action. Three mechanisms, then the option I discarded.

1. I ingested each BRD once, chunked by headings, requirement IDs, and table boundaries, and I indexed lexical fields and vectors in Azure AI Search. One hybrid query ran keyword alongside vector; Azure’s semantic ranker reordered for meaning.
2. When the question was identifier, impact, or depends-on, I took a bounded GraphDB hop — one or two hops with a visited set — then fetched neighbor text from the search index. GraphDB answered structure. Azure answered citeable prose. That hop is not LangGraph.
3. LangGraph adaptive retrieval chose lexical versus semantic versus hop so the writer saw a small evidence set. Cite-or-abstain: no supporting span, no sentence. LangSmith gold items carried expected citation IDs; test-case generation was itself a traced job.

I discarded vector-only, keyword-only, stuffing the 200+ pages, and raising vector top-k instead of a graph hop.

Result. The path processed more-than-two-hundred-page BRDs with traces, evals, and generated tests. No extra IQVIA percentage.

Situation. Computer-vision prototyping was trapped in one notebook, one GPU queue, and one person. Every small experiment became environment setup. A one-model demo disappeared with its author. StratifyLabs needed to be a reusable lab, not a Colab.

Task. I wanted edit, infer, and inspect to happen in the browser, and I wanted pretrained starting points to be catalog items other people could reuse.

Action. I built a shared 3D simulation lab with a URDF editor and WebGL so scene structure was visible in the tab. I ran suitable small models as browser inference on that interactive path, and I kept large training off the click. I shipped a marketplace of more than fifty pretrained models and datasets with community profiles, and I gave Gemini RAG voice characters the current scene and URDF context rather than last week’s chat. I discarded a full training box per user, and I discarded treating a field ROS2/Gazebo stack as this browser product.

Result. ML iteration time fell 30 percent. The marketplace held more than fifty models and datasets. That 30 percent is iteration time, not frame rate.

Situation. Argus is industrial computer vision for PPE and attendance. A detector can look promising in a notebook and be wrong on a floor. At 73 percent mAP the model missed helmets and also proposed junk boxes. Either one trains people to ignore the alert. That number is not a page-the-floor number.

Task. I had to drop the comfortable belief that a rising training curve was enough. Right meant a held-out mAP I could alert a human on, at a frame rate the live stream could support, with events that could be audited.

Action. Three mechanisms, then the option I discarded.

1. I treated 73 percent mAP as unshippable for alerts. I inspected error classes — lighting, PPE variation, rare no-helmet — on more than 15,000 images, and I iterated YOLOv9 until held-out mAP reached 89 percent.
2. I kept non-maximum suppression on the boxes and measured end-to-end 24 FPS: decode, infer, NMS, I/O, not notebook forward-milliseconds only.
3. I wrote structured events — camera, class, confidence, time, box — to Postgres, not video blobs, and I scaled to more than twenty containerized feeds only after both bars held.

I discarded shipping the 73 percent demo, hiding behind a confidence tweak, and putting a heavier backbone on the stream that would miss 24 FPS. An LLM caption is not an IoU-gated box.

Result. The detector moved from 73 to 89 percent mAP at 24 FPS on more than 15,000 images, then supported more than twenty cameras. After alerts existed, site violations were down 50 percent and compliance doubled. Those last two are operational outcomes after the gate, not another name for mAP.

Situation. At Ylogx the SQL RAG chatbot paused, so instinct said the generator was slow. The demo still returned rows. Every natural-language turn was reaching Postgres. Blaming the model was the anecdote. The database path was the measurement.

Task. I needed to disconfirm “the model is thinking” and find which layer owned latency.

Action. I measured bot database latency around the query path instead of rewriting the prompt first. I put Redis cache-aside on repeat questions and schema metadata, with organizational tier in the key, and I kept RLS on every miss. I returned inspectable SQL so wrong grain was visible even when tenant isolation was correct. I discarded prompt-tuning as the first fix, and I discarded a larger RDS as the first fix.

Result. Bot database latency fell 35 percent. The belief that changed was “the model is slow” versus a measured database path.

Situation. I am a software developer intern at IQVIA in Kochi, April 2026 to present. Analysts needed research across the open web, not a single scraper and a fluent paragraph. Calling an LLM from FastAPI was already a skill. Stateful multi-agent research, ranking across more than two hundred sites, and a writer who must not treat an empty scrape as a fact were not.

Task. I needed to rank research across more than two hundred websites without inventing page contents. Curiosity needed a stop: traces that showed whether the ranker, an empty scrape, or the writer failed.

Action. Three mechanisms, then the option I discarded.

1. I learned LangGraph typed state, reducers that append surviving documents, and checkpoints so a dead Playwright branch did not erase Bing and so one failed domain could resume.
2. I learned a planner plus parallel tools — Firecrawl, Bing, DuckDuckGo, Google Playwright — then a ranker on quality, recency, and agreement, including rejecting empty or boilerplate pages and not counting syndicated mirrors as extra votes.
3. I learned LangSmith traces as the stop: node order visible, empty scrape reaching the writer visible, writer synthesizing only from ranked retained evidence, iteration cap on citation hops.

I discarded a linear plan-scrape-write chain, a homegrown loop with one mutable dictionary, and one scraper or one search API as “research.”

Result. Research ranked across more than two hundred websites, with traces. No extra IQVIA percentage. No hour count on the resume.

Situation. From February to June 2024 I was core software on Team Horizon. ERC required ROS2, GStreamer timing, ZED 2 point clouds, RViz, Gazebo, and costmap planning. Gazebo lighting was not dirt.

Task. I needed to learn enough, before an immovable ERC date, for the operator to see 60 FPS and for the planner to trust current occupancy.

Action. I learned GStreamer source, convert, encode, and UDP-family send so live video preferred the current frame over perfect historical delivery. I learned ZED 2 mapping at more than two million points per second into the rover frame with timestamps, keeping density for the local costmap and downsampling visualization. I learned to compare pipeline, callback, and sensor clocks in the field, because a visually live feed can mask stale occupancy. I discarded MJPEG over TCP as the live operator path, and I discarded simulation-only sign-off.

Result. We placed 17th of more than eighty. The resume reports 60 FPS, 2M+ points per second, 40 percent better obstacle detection, and 55 percent lower collision risk. Learning stopped when the planner saw a live grid, not when Gazebo looked pretty.

Situation. I was on the Tech Team at IEDC CUSAT while studying CSE, CGPA 8.42. Club and hackathon stacks were not shared. If only one laptop could run the build, the next event stopped when that person moved. I did not hire anyone. I was a member.

Task. I wanted the next person to run the build and own the risky module rather than depend on my machine. The bar was independent ability.

Action. Three mechanisms, then the option I discarded.

1. I shared environment setup, the failures we had already hit, and review on the module that actually broke, not a generic onboarding slide.
2. I paired on the risky path until another laptop could reproduce the build, then I stepped back.
3. Across eight national and regional hackathons I used the same habit: rapid software and a deploy someone else could repeat, rather than a hero demo on my machine.

I discarded hoarding a working setup on one laptop.

Result. Tech Team membership, eight hackathons, first at CodeRecet, MLH Best Project, Magnathon 2.0 runner-up. CGPA 8.42 is education, not a coaching metric. I have no mentee count.

Situation. On Horizon, camera, mapping, and launch knowledge could live in one head. ERC placement was a team score. If only I knew GStreamer topic names and launch order, integration stopped when I moved to mapping.

Task. Perception and planning had to be launchable by someone else before the event, not trapped in my shell history.

Action. I paired on launch files until another person could start the camera node and confirm the expected topics. I shared ZED rate versus visualization constraints so a pretty cloud did not get mistaken for planner input. I stayed on the costmap integration until a teammate could connect occupancy to planning without copying a hidden environment from my laptop. I discarded hero ownership of the working rover bring-up.

Result. We placed 17th of more than eighty. The useful Hire-shaped result is that launch order left one head. Placement remains we.

Situation. Argus sits on an industrial safety path. Seventy-three percent mAP is not a standard I would use to notify a floor. Alarm fatigue is the cost of a low bar. A model that is accurate in a notebook and too slow on live video is also below the bar.

Task. I needed a gate that stayed fixed: held-out quality, live throughput, and an auditable event. Cameras after the gate, not instead of it.

Action. Three mechanisms, then the option I discarded.

1. I required both 89 percent mAP and 24 FPS. Either miss blocked scale.
2. I kept NMS on detections and wrote accepted events to Postgres so “camera 7, Tuesday 18:04, no-helmet” was queryable. Bulk video stayed out of the table.
3. I refused to attach more than twenty feeds to the 73 percent model to look like progress.

I discarded shipping at 73 percent, and I discarded treating notebook mAP as the production standard.

Result. After the gate, the path supported more than twenty cameras. Site violations were down 50 percent and compliance doubled after alerts existed. The standard was mAP plus FPS plus logs.

Situation. Ylogx had thirty KPI dashboards operators used during the day. Putting a generator on those GETs would have made every tile wait on a model, invent KPIs, and couple availability to a vendor. Sub-210 milliseconds would have died.

Task. I needed a serving standard: deterministic numbers, held uptime, no fluent lie on the hot path.

Action. Dashboard GETs went NestJS identity and RBAC, then pooled Postgres with RLS, returning numbers and labels — not generated prose. The browser loaded JS from CloudFront; private tenant JSON was not an edge-cache object. Ad-hoc English stayed on the separate SQL RAG path. The thirty tiles never called the model. I discarded one model call per KPI tile.

Result. Dashboards stayed sub-210 milliseconds. Uptime held at 99.9 percent. Thirty tiles improved operations 60 percent.

Situation. Computer-vision work often dies in one GPU, one notebook, one model, and one person. Every experiment becomes machine setup. StratifyLabs needed to be a CV SaaS and a 3D lab, not a one-off demo that vanished with its author.

Task. Experiment, share, and reuse had to become the default. Someone who was not a ROS expert should still load a URDF and try a model in a browser.

Action. Three mechanisms, then the option I discarded.

1. I built a shared 3D lab: URDF edits change the scene, WebGL renders the current structure in the tab.
2. I put suitable small-model inference in the browser so the edit-infer-inspect loop did not wait on a lab machine, and I kept large training off that interactive request.
3. I shipped a marketplace of more than fifty pretrained models and datasets with community profiles, and I grounded Gemini voice characters in the current scene and URDF rather than a disconnected chat panel.

I discarded a Colab-per-person default, and I discarded treating 50+ catalog items as 50 GPUs.

Result. ML iteration time fell 30 percent. The marketplace contained more than fifty models and datasets.

Situation. Analysts could not treat the first web result as truth. One scraper missed families of pages. First-hit ranking looked confident when two credible pages contradicted. Research needed coverage across a large web, not a single gold URL.

Task. I needed a research path that ranked more than two hundred websites with agreement, not a bigger prompt.

Action. A planner wrote a search plan into LangGraph state, then tools fanned out in parallel across independent indexes and a browser path. Reducers appended surviving documents so one dead branch did not wipe the run; a ranker scored quality, recency, and agreement and rejected boilerplate and mirrors. The writer synthesized only from ranked retained evidence, or abstained, with an iteration cap on citation hops. I discarded one Google path as research, and I discarded treating a fluent paragraph as confirmation.

Result. Research ranked across more than two hundred websites.

Situation. From February to June 2024 I worked core software for Team Horizon’s semi-autonomous Mars rover for ERC 2024. More than eighty teams. The event date did not move. Waiting for a perfect lab or another sensor as the first response would have put the useful software after the event. A live video feed is not a costmap.

Task. Perception, mapping, and planning had to run on the hardware we had. Speed without a live occupancy grid would have been reckless, because collision is not a reversible decision.

Action. Three mechanisms, then the option I discarded.

1. I shipped a GStreamer camera pipeline at 60 FPS — newest frame, UDP-family drop-over-stall — instead of a naive MJPEG stream that stalls later bytes.
2. I moved ZED 2 mapping at more than two million points per second into the local costmap, downsampled visualization, and kept density for planning.
3. I put fusion and predictive planning in front of the actuators, and I used field time because Gazebo lighting is not dirt. When occupancy lagged a healthy feed, that was the ship-blocker I named.

I discarded waiting for extra rover hardware as the first fix, and I discarded polishing simulation until the date passed.

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

Situation. Across eight national and regional hackathons the clock was the weekend, not a semester. Stacks were unfamiliar. Waiting for a perfect architecture would have meant no demo and no deploy.

Task. I needed working software on the event clock, and a deploy someone else could run, not a slide.

Action. I picked the smallest path that produced a real artifact — running software, not a deck — in the first hours. I paired on the risky module so the deploy was not trapped on one laptop. I shipped production-shaped deployment for the demo path we had, rather than rewriting the stack mid-event. I discarded over-planning the architecture until the submission window closed.

Result. First at CodeRecet, MLH Best Project, Magnathon 2.0 runner-up, across eight events. Those are event outcomes, not Argus mAP and not ERC 17th.

Situation. At Ylogx I interned on BI and SQL RAG over Postgres. Every natural-language turn that hit the database was latency and load. Repeat questions and schema lookups are not proof the instance is undersized. The obvious spend was a larger RDS.

Task. I needed to cut hot-path database work without weakening three-tier isolation, and without moving dashboard tiles onto a model.

Action. Three mechanisms, then the option I discarded.

1. I measured bot database latency instead of buying headroom first.
2. I put Redis cache-aside on repeat answers and schema metadata, with organizational tier and role in the key, so a cross-tier hit could not be celebrated as a latency win.
3. On a miss, SQL still ran as the caller role with RLS. If Redis was down, Postgres as that role, never table-owner, never fail-open isolation. CloudFront served static assets only — private tenant JSON was not an edge object.

I discarded a larger RDS as the first move, Redis keys from raw English only, and Redis as source of record.

Result. Bot database latency fell 35 percent. Isolation stayed in Postgres. Uptime held at 99.9 percent on the existing ECS path rather than an oversized snowflake host.

Situation. On Horizon, the expensive-looking answer near ERC was another sensor. Extra hardware meant drivers, calibration, and integration delay. Time alignment and planning would still have been unsolved. We already had cameras and a ZED 2.

Task. I needed occupancy the planner could trust without waiting on a purchase that would not land in time.

Action. I fused onboard sensing we already had into occupied, free, and uncertain costmap cells with timestamps in a shared frame. I kept dense points for local planning and downsampled visualization so we did not spend link and compute on a pretty cloud the planner did not use. I put predictive planning on that fused grid rather than on raw pixels or a hoped-for extra device. I discarded extra rover hardware as the first fix, and I discarded a giant vision model as a substitute for fusion.

Result. Collision risk fell 55 percent. Obstacle detection improved 40 percent. We placed 17th of more than eighty. The scarce resource was the calendar, not another device on order.

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. That was awkward to say because the visible surface looked impressive. The current GitHub README describes AegisAI. That is not the resume product.

Task. I needed to name those trust failures before dressing them up, then ship grounded, isolated, available help, and be honest if someone opened the repo.

Action. Three mechanisms, then the option I discarded.

1. I said the VR surface was not enough. I shipped contextual Q&A over that user’s PDF, with per-user document metadata so another student’s notes never retrieve.
2. I abstained when no source span existed, kept generation bounded for sub-300 milliseconds, and held 99.5 percent uptime as hosting, not as model intelligence.
3. I disclose that the current GitHub README describes AegisAI, and that GiftedBooks on the Aug 2026 resume is the product I speak. I would fix the README.

I discarded treating the VR surface or a generic model as sufficient, and I discarded answering off-PDF to satisfy the request.

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

Situation. At Ylogx the chatbot returned SQL and rows. Saying “it works” would have hidden a class of failure: a JOIN can be legal SQL and still return another organization’s rows if isolation lives only in the application.

Task. I needed to name that leak class out loud, including when the demo account looked clean, and put the control where every query actually ran.

Action. I stated 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. I discarded app-only filters and “the UI hides that org” as the control.

Result. Isolation sat in the database. Uptime held at 99.9 percent. The trust mechanism is the named JOIN-leak class plus RLS, not a dramatic conversation.

Situation. At Ylogx I was a software intern from November 2024 to October 2025. The SQL RAG chatbot returned SQL and rows, so a happy-path demo said the product worked. Two facts disagreed with that anecdote. 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. I had to separate query shape, missing cache, and security in the wrong layer, and make three organizational tiers real where SQL actually ran. Measuring the database path was not beneath the intern ticket.

Action. Three mechanisms, then the option I discarded.

1. I measured bot database latency around the query, rather than rewriting the prompt first.
2. 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.
3. 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.

I discarded prompt rewriting as the first fix, a larger database as the first fix, and app-only organization checks as the isolation story.

Result. Bot database latency fell 35 percent. Three-tier isolation sat in Postgres. Uptime held at 99.9 percent. 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. I needed to 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. I used 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. I ranked on quality, recency, and agreement, including not counting mirrored copies as independent confirmation, and I refused to average two contradictory requirements into vague prose. LangSmith made empty-tool results visible. A generated sentence or test case failed when no source span overlapped. Cite-or-abstain was the stop. I discarded first-hit writing, vector-only coverage, and treating a professional paragraph as evidence.

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. 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.

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

Action. Three mechanisms, then the option I discarded.

1. 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.
2. 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.
3. Once that path was selected, I committed by instrumenting LangSmith evals and test-case generation: no overlapping source span, the case fails. I did not keep a quiet vector-only side project. I did not reopen the library every week.

I discarded vector-only as done, and I discarded repeating the tool argument after commit.

Result. Hybrid RAG processed more-than-two-hundred-page BRDs with traces and generated tests. Disagree on retrieval. Commit on evals. No extra percentage.

Situation. The Ylogx chatbot returned rows. An app-level organization filter looked enough for a quick release. Generated SQL or a JOIN can take a path the UI never represented. “The UI hides that org” is not a control.

Task. I needed to challenge app-only isolation on the failure mode, then commit to database policy as a platform rule.

Action. I stated that syntactically legal SQL can be unauthorized: JOIN through a mapping table, HTTP 200, wrong tenant. I put RLS and RBAC for three tiers into Postgres and ran generated SQL as the caller’s non-owner role so the deny is observable in a fixture. I added Redis only after keys carried tier, so speed could not become a side door. After that decision I did not leave an app-only exception path “just for the bot.” I discarded NestJS middleware alone, views without row policy, and trusting the model to add the tenant predicate.

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

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. Dirt and lighting did not match simulation.

Task. I needed a live operator feed and a costmap the planner could trust. A lab video was not a result. A rover that mapped while planning on stale occupancy was not a result either.

Action. Three mechanisms, then the option I discarded.

1. I shipped GStreamer at 60 FPS so operators saw current video, not a stalled history.
2. 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, with visualization downsampled so the pretty cloud did not starve occupancy.
3. I put fusion and predictive planning on latest occupancy. When the costmap lagged a healthy feed, I treated stale occupancy as the ship-blocker and closed that split in the field, not only in sim.

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 percent. Collision risk fell 55 percent after fusion. The date was met.

Situation. At Ylogx, a chatbot that merely produced SQL was not the business result. Operators needed custom reports, non-technical users needed warehouse facts, and no organization could read another tier’s rows. A fast leak is not delivered.

Task. I needed faster reporting at held availability, useful natural-language analysis, and database-enforced isolation on the path those features already shared.

Action. I kept FastAPI and NestJS on a shared Postgres path and enforced three-tier RLS so reports and the bot inherited the same role mapping. I added Redis for repeat bot work with tier in the key, so latency work did not skip isolation. I kept the thirty dashboard KPIs off the model, and I served through CloudFront, ALB, ECS, and Docker so availability was a rolling image, not a patched box. If isolation is still only in the application, that is the blocker I name before calling the product done. I discarded app-only filtering as done, and I discarded calling a SQL demo the product outcome.

Result. Reports became 40 percent faster at 99.9 percent uptime. Analysis productivity rose 65 percent. Bot database latency fell 35 percent. Thirty KPI dashboards improved operations 60 percent at sub-210 milliseconds. Done includes isolation. Still no SLA miss on the resume.

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. Three mechanisms, then the option I discarded.

1. I paired on launch files until someone else could start the GStreamer camera node and confirm topics.
2. 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.
3. 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.

I discarded hero ownership of the working environment.

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. I discarded hoarding the working setup.

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 percent mAP would multiply misses and false alarms until people learned to ignore PPE warnings.

Task. I needed the detector ready before multiplying it, real-time throughput held, and an audit trail for the people operating the system. Secondary effect was alarm fatigue, not a planet metric.

Action. Three mechanisms, then the option I discarded.

1. I did not scale at 73 percent. I moved YOLOv9 to 89 percent mAP at 24 FPS on more than 15,000 images, with NMS on the boxes.
2. Only then I containerized ingest workers for more than twenty feeds, dropping stale frames rather than queuing delayed alerts.
3. I stored structured events in Postgres — camera, class, confidence, time, box — not JPEG blobs. Humans acted on alerts. Operational −50% violations and 2× compliance came after that loop existed.

I discarded attaching twenty cameras first and fine-tuning later, and I discarded putting video files in the relational table.

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

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. Scale without the wall is broad irresponsibility.

Task. Serving had to grow on a path that already knew the caller’s database role.

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; one mutable VM was not deploy, health, and routing in one domain. Redis keys already carried tier, and dashboard GETs still had no LLM, so extra load did not invent KPIs or skip isolation. I discarded scaling a table-owner connection, and I discarded Compose-on-one-box as production scale.

Result. 99.9 percent uptime held on that path. Bot database latency was 35 percent lower with a safe cache. I did not shard. Honest next step is pool, fixtures, then more tasks — not Kafka, not a multi-region claim.

I pick the locked primary for the stem they just asked. If that project already appeared, I name the backup on that card and tell it as a full second story. Failure and feedback stay Argus 73 percent. Deadline stays Horizon sequencing, with no invented miss. Conflict stays IQVIA hybrid versus vector-only. Current role is IQVIA intern, two systems, then stop — not an LP dump.