LP answers A — Customer Obsession through Frugality

Fifteen seconds of Situation. Ten of Task. Numbered mechanisms you owned. One resume family, then stop. Follow-ups unpack the same path: what you implemented, why that mechanism, what the number measures, what you did not own.

Situation. GiftedBooks already had VR labs and avatars. That was not extra for the student who still sat for hours on doubts from their own PDF. A lab that cannot answer from the upload is decoration. A generic tutor that sounds like a textbook is the wrong customer.

Task. I owned the RAG and previous-year-question path. Cut time-to-answer from that file, keep the assistant usable during study, and rank exam topics from past papers — not from a model guessing the test.

Action.

1. Retrieve-then-generate over that student’s PDF: chunk for a table or derivation, embed once at ingest, store vectors with user and document metadata, small user-scoped top-k at question time.
2. Keep generation small so the API stayed under 300 milliseconds. Abstain when no supporting span existed. Another student’s notes never retrieve.
3. Previous-year question topic ranking as a separate deterministic pass over past papers.

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

Result. Average doubt time moved from hours to three to ten minutes. Reading efficiency +35%, engagement +50%, comprehension 2.5×. API sub-300 ms with 99.5% uptime.

Situation. I had three attractive paths on GiftedBooks: polish the VR lab, ship a fluent generic tutor, or answer from the student’s own PDF. The student who already had notes still lost hours. Speed without a span would have been a confident wrong formula. A prettier lab would not have shortened those hours.

Task. Prioritize the customer who is studying from that file. Grounded time-to-answer first. Latency second, still under 300 milliseconds. Exam-topic help as a separate pass, not as the generator inventing the paper.

Action.

1. Made the upload the source of truth: user-scoped retrieve, generate only from retained spans.
2. Bounded generation so the API stayed sub-300 ms rather than dumping the textbook for “completeness.”
3. Put PYQ topic ranking on past papers, deterministic, so exam guidance did not compete with RAG for the same fluent paragraph.

I discarded ranking the VR surface first, and I discarded a generic tutor that ignored the file.

Result. Doubts hours → 3–10 min. +35% reading, +50% engagement, 2.5× comprehension. Sub-300 ms, 99.5% uptime.

Situation. Students asked GiftedBooks for answers from their PDF. They did not file a ticket for “rank what exams actually asked.” Leaving exam guidance to the generator would have presented a guess as analysis. Leaving it out would have left them searching past papers by hand after the doubt was closed.

Task. Keep RAG on the upload. Add previous-year question topic ranking as its own pass, so the unrequested piece could not contaminate the cited answer.

Action.

1. Shipped retrieve-then-generate on the student’s PDF with cite-or-abstain — that was the asked path.
2. Added a separate deterministic PYQ ranking over past papers: frequency of topics, not an LLM predicting the next exam.
3. Kept both on a sub-300 ms API with user-scoped documents so the extra pass did not mix another student’s notes.

I discarded letting the chatbot “also guess the paper” in the same paragraph as the PDF answer.

Result. Doubts hours → 3–10 min, with PYQ topics on the resume beside +35% reading, +50% engagement, 2.5× comprehension, 99.5% uptime.

Situation. On GiftedBooks a student still wants an answer when the uploaded PDF has no supporting span. A fluent off-PDF sentence is what they would memorize. Saying yes would have looked helpful and taught the wrong formula.

Task. Push back by abstaining. Keep the assistant useful when the span exists. Isolation so another student’s notes never fill the hole.

Action.

1. User-scoped retrieve from that PDF only. If top-k has no span, no sentence.
2. Bounded generation on the sub-300 ms path so “I will just dump more context” was not the way to dodge abstain.
3. PYQ stayed a separate pass so exam-topic ranking could not invent a syllabus inside the RAG answer.

I discarded answering from a generic tutor corpus to satisfy the request.

Result. Doubts that had spans moved hours → 3–10 min. +35% reading, +50% engagement, 2.5× comprehension. 99.5% uptime. Abstain is the no.

Situation. The intern ticket at Ylogx was a chatbot and a report builder over Postgres. 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.

Task. I was not a named security team. Beyond the ticket meant isolation for three organizational tiers on the path operators would keep using. Done was not “SQL appears.”

Action.

1. Row-level security and RBAC in Postgres. 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. Identity mapped to three organizational tiers — org, team, and user-shaped levels — on both the chatbot and the report builder.
3. Same role mapping on the CloudFront, ALB, ECS, Docker serving path, not only a local demo.

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

Result. Three-tier isolation in the database. 99.9% uptime. Report generation 40% faster on that same identity-to-role path.

Situation. I saw the problem on a Ylogx demo that already returned rows: a generated JOIN could still compile and cross a tier. There was no named security team waiting to own tenancy. “Not my job” would have been leaving that leak on an application filter.

Task. Act on behalf of every tier that shared the warehouse, not only the demo persona on my intern ticket. Isolation had to live where every query landed: Postgres.

Action.

1. Put RLS in the database so a missed app WHERE could not be the last line of defense.
2. Mapped caller identity to three organizational tiers on bot and reports, so “outside my UI” still hit the same role.
3. Kept that mapping through ALB and ECS so a production task did not run as table-owner “because deploy is ops.”

I discarded treating NestJS middleware as another team’s problem, and I discarded trusting the model to add the tenant predicate.

Result. Three-tier RLS in Postgres. 99.9% uptime. 40% faster reports on the same identity path.

Situation. The short-term win at Ylogx was a chatbot demo that returned rows. App-only filters would have been enough for a screenshot. Operators were going to keep asking English questions and building reports after that intern week. A JOIN that compiled was still a future leak.

Task. Choose the path that still held when someone copied a handler or the model skipped a predicate. Long-term meant three-tier isolation in Postgres and a serving path that stayed up, not a local happy path.

Action.

1. RLS and RBAC in the database; generated SQL as the caller’s non-owner role so isolation survived a missed JOIN.
2. Same identity mapping on reports and the bot, so the “done” screenshot and the weekday path were one system.
3. Held that mapping on ECS / ALB / CloudFront (static assets only — private tenant JSON was not an edge object) at 99.9% uptime.

I discarded shipping the demo on table-owner SQL, and I discarded hiding isolation in React.

Result. Three-tier isolation in Postgres. 99.9% uptime. 40% faster reports on the same long-lived identity path.

Situation. At Ylogx I took the dynamic-report path: aggregation and filters across chart types so operators could ask the AI for a report instead of waiting on a static export. I put aggregation on the client. When a large volume hit the browser, the UI crashed. That was my initiative, not a ticket I inherited already broken.

Task. Keep heavy aggregation off the client when the user asks for a large slice. The agent and the UI had to stay stable. Isolation on the warehouse path still had to hold — this was a crash class, not a reason to drop RLS.

Action.

1. Moved aggregation and preload to the server for the AI-requested report so the browser was not the calculator.
2. Required an explicit click to load full data instead of pulling the entire slice on first paint.
3. Cleanup so the agent and UI stayed stable after a heavy request. Multi-chart generation through the LLM path, not report-as-image.

I discarded leaving aggregation in the browser, and I discarded screenshotting a report as the multi-chart answer.

Result. UI rendered. Agent stayed stable. Resume family on this product: 40% faster reports and 99.9% uptime — those percents are not a crash study.

Situation. On Team Horizon, February to June 2024, 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. I did not fire anyone. I was core software, not team lead.

Task. Perception and planning had to be launchable by someone else before the event, not trapped in my shell history. Transfer was a working bring-up on another laptop.

Action.

1. Paired on launch files until another person could start the camera node and confirm the expected topics.
2. Shared ZED rate versus visualization constraints so a pretty cloud did not get mistaken for planner input.
3. Stayed on costmap integration until a teammate could connect occupancy to planning without copying a hidden environment from my machine.

I discarded hero ownership of the working rover bring-up.

Result. We placed 17th of more than eighty. The Ownership-shaped result is that launch order left one head. Placement remains we. Obstacle detection +40%, collision risk −55% on the software path I owned.

Situation. I am a software developer intern at IQVIA in Kochi, April 2026 to present. Analysts live inside more-than-two-hundred-page BRDs. Stuffing a PDF into a window spends tokens and cites the wrong annex. A vector-only demo is fast and still misses exact clause IDs. The simple rule I needed was: no supporting span, no sentence.

Task. Invent retrieval a human can audit: recover the exact requirement, hop dependents, generate tests that fail when the span is missing. Simplification was less untraceable work, not a thinner demo.

Action.

1. Ingest each BRD once, chunked by headings, requirement IDs, and table boundaries. Lexical fields and vectors in Azure AI Search. One hybrid query; Azure semantic ranker reorders for meaning.
2. Identifier / impact / depends-on: bounded GraphDB hop (one or two hops, visited set), then neighbor text from the search index. GraphDB answers structure. Azure answers citeable prose. That hop is not LangGraph.
3. LangGraph adaptive retrieval chooses lexical versus semantic versus hop. Cite-or-abstain. LangSmith gold items with expected citation IDs; test-case generation is a traced job.

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

Result. The path processed 200+ page BRDs with traces, evals, and generated tests. No extra IQVIA percentage.

Situation. The old process for a 200+ page BRD was live inside the PDF: search, scroll, paste a clause into a prompt, hope the annex number survived. Stuffing the document looks like one step. It is more untraceable work — wrong citation, no test that fails when the span is missing, “what breaks if this requirement changes” answered by cosine luck.

Task. Shorten the analyst path to: retrieve a small set, hop dependents when the question is structural, write only from spans, generate tests that hang off the right section. Fewer silent steps.

Action.

1. Ingest once, structure-aware chunks, Azure hybrid + semantic ranker so keyword IDs and paraphrases are one query, not two manual searches.
2. Bounded GraphDB hop instead of raising top-k until the prompt is a haystack.
3. Cite-or-abstain plus LangSmith-traced test-case generation so a fluent paragraph cannot hide a missing clause.

I discarded stuffing 200+ pages, vector-only, and a linear “paste the PDF” chain.

Result. Process 200+ page BRDs with traces and generated tests. No extra IQVIA percentage.

Situation. Vector-only retrieval on a BRD looks like the simple invention: embed, nearest neighbors, write. That demo is fast. Clause IDs such as a requirement identifier still miss. “What breaks if this requirement changes” is a dependency edge, not a cosine neighbor. The hybrid-plus-graph path looked like extra machinery.

Task. Hold the design that recovered exact IDs and dependents, and keep the simple user-facing rule: cite or abstain. Commit on evals, not on a prettier first-hit paragraph.

Action.

1. Ran hybrid (keyword plus vector) plus Azure semantic ranker so lexical IDs were not a special case someone had to remember.
2. Bounded GraphDB hop for depends-on questions instead of “just increase top-k.”
3. LangSmith gold items with expected citation IDs so a fluent vector-only paragraph could fail in the open.

I discarded treating the vector-only demo as done, and I discarded arguing taste without a missing-span test.

Result. 200+ page BRDs on hybrid + GraphDB + traces. No extra IQVIA percentage. The misunderstood part was that hybrid is simpler for the analyst than a confident wrong annex.

Situation. Argus is industrial computer vision for PPE. At 73% mAP the model missed helmets and also proposed junk boxes. I treated a rising training curve as close enough to alert a floor. That judgment was the mistake. Either miss trains people to ignore the alert.

Task. Disconfirm “the notebook looks good.” Right meant a held-out mAP I would page a human on, at a frame rate the live stream could support, with events that could be audited.

Action.

1. Treated 73% as unshippable. Inspected error classes — lighting, PPE variation, rare no-helmet — on 15,000+ images. Iterated YOLOv9 until held-out mAP reached 89%.
2. Kept NMS on the boxes. Measured end-to-end 24 FPS: decode, infer, NMS, I/O — not notebook forward-milliseconds only.
3. Wrote structured events — camera, class, confidence, time, box — to Postgres, not video blobs. Scaled to 20+ containerized feeds only after both bars held.

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

Result. 73→89% mAP at 24 FPS on 15k+ images, then 20+ cameras. After alerts existed, site violations were down 50% and compliance doubled. Those last two are operational outcomes after the gate. We for the site numbers. I for the detector and gate.

Situation. On Argus the anecdote was “training loss is falling, the GIF looks fine.” The measurement that mattered for a floor alert was held-out mAP. That number sat at 73%. Instinct said ship a confidence tweak. The data said missed helmets and junk boxes.

Task. Let held-out mAP and end-to-end FPS overrule the notebook. Seek the error classes, not a friendlier threshold on the quoted test set.

Action.

1. Measured honest starting detector at 73% mAP (IoU-thresholded boxes). Inspected lighting, PPE variation, rare no-helmet on 15k+ images.
2. Iterated data and config until 89% mAP. Verified 24 FPS end-to-end, not forward-pass milliseconds.
3. Refused to attach 20+ cameras to the 73% model to look like coverage. Events to Postgres after the gate.

I discarded tuning NMS on the quoted test set as the way to “fix” 73%.

Result. 73→89% mAP at 24 FPS, then 20+ cameras. Site −50% violations / 2× compliance after alerts existed — we for those ops numbers.

Situation. Argus did not start with every lighting condition, vest color, and rare no-helmet example already in the bag. The incomplete part was the world. The complete part was the held-out number: 73% mAP. Waiting for a perfect catalog would have been an excuse. Shipping alerts into that hole would have been worse.

Task. Decide with a gate, not with hope. Collect into the 15k+ set along the error classes I could see. Do not page the floor until 89% mAP and 24 FPS both held.

Action.

1. Used 73% as the decision: unshippable, even though more cameras and more GIFs were available.
2. Grew data on the failures I had — lighting, PPE variation, rare no-helmet — rather than inventing a split ratio the resume does not state.
3. Scaled to 20+ cameras only after 89% and 24 FPS. Events in Postgres so incomplete video memory was not the audit trail.

I discarded “we’ll catch it in production” at 73%, and I discarded a confidence slider as a substitute for labels.

Result. 73→89% mAP at 24 FPS on 15k+ images, then 20+ cameras. Site −50% / 2× after alerts existed (we).

Situation. Calling an LLM from FastAPI was already a skill. Stateful multi-agent research across the open web — ranking more than two hundred sites, a writer who must not treat an empty scrape as a fact — was not required to “make a chatbot compile.”

Task. Rank research across 200+ websites without inventing page contents. Curiosity needed a stop: traces that showed whether the ranker, an empty scrape, or the writer failed.

Action.

1. Learned LangGraph typed state, reducers that append surviving documents, checkpoints so a dead Playwright branch did not erase Bing.
2. Learned a planner plus parallel tools — Firecrawl, Bing, DuckDuckGo, Google Playwright — then a ranker on quality, recency, and agreement, including mirrors not counting as extra votes.
3. Learned LangSmith traces as the stop: node order visible, empty scrape reaching the writer visible, iteration cap on citation hops.

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

Result. Research ranked across 200+ websites, with traces. No extra IQVIA percentage. No hour count on the resume.

Situation. At IQVIA I needed LangGraph for Deep Research, not a tutorial badge. The failure mode of “I finished the docs” is a fluent writer fed by an empty scrape.

Task. Learn a new orchestration tool the way I would have to operate it: a stop condition. For this stack that stop was LangSmith traces on node order and citation hops, plus a ranker that can disagree with the first hit.

Action.

1. Put the smallest real job on typed state: planner writes a search plan, tools fan out, reducers append survivors, checkpoint a failed domain.
2. Compared options in the open: one scraper versus parallel indexes; linear chain versus graph; stuffing versus retrieve-and-cite.
3. Used traces to see whether the ranker, an empty body, or the writer failed — then capped citation hops so curiosity could not loop on plausible prose.

I discarded finishing a course as the definition of learned, and I discarded a mutable dictionary as “good enough graph.”

Result. Research ranked across 200+ websites with traces. No hour count. No IQVIA percent.

Situation. The shortcoming was treating a FastAPI LLM call as research architecture. At IQVIA an empty scrape could still become a professional paragraph. A linear plan-scrape-write chain felt like ordinary backend work. That was the gap: I could generate prose and still not know which node had failed.

Task. Close that gap with stateful tools and a stop I could see. Rank 200+ websites without laundering an empty body into a fact.

Action.

1. Replaced the one-shot habit with LangGraph typed state: planner, parallel Firecrawl / Bing / DuckDuckGo / Playwright, append reducers, checkpoints so a dead Playwright branch did not erase Bing.
2. Added an agreement ranker that rejects empty and boilerplate pages and does not count syndicated mirrors as extra votes.
3. Used LangSmith traces as the improved habit: node order visible, empty scrape reaching the writer visible, iteration cap on citation hops.

I discarded staying on a linear chain because it felt familiar, and I discarded a homegrown loop with one mutable dictionary.

Result. Research ranked across 200+ websites with traces. No IQVIA percent. The shortcoming that closed was “fluent is done.”

Situation. Comfort was a FastAPI handler that calls a model and returns prose. Outside that: typed multi-agent state, parallel web tools that fail independently, a ranker that uses agreement, a writer forbidden to launder an empty scrape. That was Deep Research at IQVIA, April 2026 to present.

Task. Leave the comfortable one-shot. Rank 200+ websites. Stop when traces show the failure, not when the paragraph sounds professional.

Action.

1. Built planner → parallel Firecrawl / Bing / DuckDuckGo / Playwright → append reducers → checkpoint.
2. Ranked on quality, recency, agreement; rejected boilerplate; did not count syndicated mirrors as extra votes.
3. Writer synthesizes only from ranked retained evidence, or abstains, with an iteration cap. LangSmith traces on the uncomfortable path.

I discarded staying on a linear chain because it felt like ordinary backend work.

Result. Research ranked across 200+ websites with traces. No extra IQVIA percentage.

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. The next person should run the build and own the risky module rather than depend on my machine. The bar was independent ability.

Action.

1. Shared environment setup, the failures we had already hit, and review on the module that actually broke — not a generic onboarding slide.
2. Paired on the risky path until another laptop could reproduce the build, then stepped back.
3. Across eight national and regional hackathons, 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. Argus sits on an industrial safety path. A model that is accurate in a notebook and too slow on live video is below the bar. A fast junk box is also below the bar. People may have treated 73% as progress. The standard I would use to notify a floor was higher.

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

Action.

1. Required both 89% mAP and 24 FPS. Either miss blocked scale.
2. Kept NMS on detections. Wrote accepted events to Postgres so “camera 7, Tuesday 18:04, no-helmet” was queryable. Bulk video stayed out of the table.
3. Refused to attach 20+ feeds to the 73% model to look like progress.

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

Result. After the gate, 20+ cameras. Site violations down 50% and compliance doubled after alerts existed (we). The standard was mAP plus FPS plus logs.

Situation. The defect was a 73% mAP detector on a path that would notify a floor. Sending it downstream meant more cameras, more missed helmets, more junk boxes, alarm fatigue. Scaling the defect would have looked like delivery.

Task. Do not send 73% down the line. Fix the detector and the live budget so the problem stayed fixed when feeds multiplied. Persist events, not hope.

Action.

1. Blocked scale until 89% mAP and 24 FPS both held on the 15k+ train/eval loop.
2. NMS on boxes. Postgres events (camera, class, confidence, time, box) so the record was not a GIF someone forgot.
3. Replicated to 20+ containerized feeds only after the gate. Dropped stale frames rather than queue delayed alerts.

I discarded wiring alerts to 73% “and patch later,” and I discarded MP4 blobs in Postgres as the audit.

Result. 20+ cameras after the gate. Site −50% violations / 2× compliance after alerts existed (we). The defect did not multiply.

Situation. At Ylogx, November 2024 to October 2025, I interned on full-stack AI BI. Dynamic reports needed aggregation and filters across chart types. Operators could ask the AI for a report instead of a static export. I aggregated on the client. When a large volume hit the browser, the UI crashed. The agent path was unstable after that heavy slice. That is a defect I sent downstream — into the operator’s tab — and then had to make stay fixed.

Task. Keep heavy aggregation off the client when the user asks for a large slice. The UI must render. The agent must stay stable. Warehouse isolation still sat in Postgres; this was not a reason to weaken RLS.

Action.

1. Preload / server path for the AI-requested report so the browser was not summing the large slice.
2. User explicitly clicks to load full data. First paint does not pull everything.
3. Cleanup so the agent and UI stay stable after a heavy request.
4. Multi-chart generation through the LLM path, not report-as-image.

I discarded leaving aggregation in the client, and I discarded screenshotting a chart grid as the “multi-chart” product.

Result. UI rendered. Agent stayed stable. Resume numbers on this product: 40% faster reports, 99.9% uptime. Those percents are the product family. They are not a study of this crash.

Situation. Computer-vision work often dies in one GPU, one notebook, one model, and one person. Every experiment becomes machine setup. A one-model demo disappears with its author. StratifyLabs needed to be a CV lab other people could enter in a browser, and a catalog they could reuse — not a Colab that vanished.

Task. Experiment, share, and reuse as the default. Someone who was not a ROS expert should still load a URDF and try a model in a tab. Look around the corner: the customer is the next experimenter, not only me this week.

Action.

1. Shared 3D lab: URDF edits change the scene, WebGL renders the current structure in the tab.
2. Suitable small-model inference in the browser so edit-infer-inspect did not wait on a lab machine. Large training stayed off that interactive request.
3. Marketplace of 50+ pretrained models and datasets with community profiles. Gemini voice characters grounded in the current scene and URDF, not last week’s chat.

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

Result. ML iteration time fell 30%. Marketplace held 50+ models and datasets. That 30% is iteration time, not frame rate.

Situation. From February to June 2024 I was core software on Team Horizon’s ERC 2024 rover. More than eighty teams. The date did not move. The expensive-looking move 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. Collision is not a reversible decision — skipping the costmap is not speed.

Task. Calculated risk: fuse onboard sensing we had, ship live video and a live occupancy grid, take field time. Do not wait on a purchase that would not land. Do not treat a healthy feed as occupancy.

Action.

1. GStreamer camera pipeline at 60 FPS — newest frame, UDP-family drop-over-stall — so the operator risked a dropped frame, not a stalled historical stream.
2. ZED 2 mapping at 2M+ points per second into the local costmap; downsampled visualization so a pretty cloud did not starve planning.
3. Fusion and predictive planning on that grid. Field time because Gazebo lighting is not dirt. Named stale occupancy while the feed looked live as the ship-blocker.

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

Result. We placed 17th of more than eighty. Obstacle detection +40%. Collision risk −55%. The date was met. I owned the software path, not mechanical or electrical work.

Situation. ERC 2024 was a date on the calendar, not a sprint I could extend. Horizon, February to June 2024. Waiting for a perfect lab or another sensor as the first response would have put useful software after the event. A live video feed is not a costmap.

Task. Perception, mapping, and planning on the hardware we had, in time. Speed without a live occupancy grid would have been reckless. Communicate a ship-blocker early: the feed is late, or the occupancy is stale — then cut extra hardware, not the grid.

Action.

1. Shipped GStreamer at 60 FPS so the operator saw the newest frame instead of a stalled MJPEG-style stream.
2. Moved ZED 2 at 2M+ pts/s into the local costmap; downsampled RViz.
3. Fusion and predictive planning in front of the actuators. Field time. When occupancy lagged a healthy feed, that was the blocker I named.

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

Result. We placed 17th of more than eighty. Obstacle detection +40%. Collision risk −55%. The date was met.

Situation. At Ylogx every natural-language turn that hit Postgres was latency and load. Repeat questions and schema lookups are not proof the instance is undersized. The obvious spend was a larger RDS. There is no AWS bill on the resume — the constraint was still “do not buy headroom first.”

Task. Cut hot-path database work without weakening three-tier isolation, and without moving dashboard tiles onto a model. More analysis per existing Postgres, less repeat work.

Action.

1. Measured bot database latency instead of buying a larger instance first.
2. Redis cache-aside on repeat answers and schema metadata. Key includes organizational tier and role 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. Redis 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%. Isolation stayed in Postgres. Uptime held at 99.9% on the existing ECS path rather than an oversized snowflake host.