17. Resume mock — the interviewer has the PDF and laptop open

I first name the mechanism I actually shipped, then the exact resume number, then the evidence boundary. If the PDF does not show the collection method, I say: “I do not have the study protocol on the resume.” I do not turn a percentage into a sample size, causal study, percentile, or monitoring vendor.

I am currently a Software Developer Intern at IQVIA in Kochi, where I work on Deep Research across 200+ websites and Hybrid RAG on 200+ page BRDs. Before that, at Ylogx I shipped full-stack AI BI with reports, SQL RAG behind three-tier RLS/RBAC, dashboards, and an ECS serving path. Earlier, Team Horizon gave me real-time ROS2 rover work and a 17th-of-80+ ERC team result. My technical projects are StratifyLabs, GiftedBooks, and Argus. I studied CSE at CUSAT with an 8.42/10 CGPA. I can go deepest on IQVIA retrieval, Ylogx isolation and Redis, or Horizon’s live costmap.

At IQVIA I built a FastAPI-backed LangGraph Deep Research path. A planner fans work to Firecrawl, Bing, DuckDuckGo, and Playwright; graph state retains surviving evidence; a ranker compares quality, recency, and agreement; and the writer uses the ranked evidence. The resume result is research across 200+ websites.

The second IQVIA system handles 200+ page BRDs and PDFs. Azure AI Search combines hybrid retrieval with semantic ranking, GraphDB handles requirement dependencies, LangGraph chooses the retrieval route, and LangSmith traces evals and generated test cases. The writer needs supporting evidence; the PDF gives no extra percentage.

At Ylogx I shipped a full-stack AI business-intelligence report path using Python FastAPI, TypeScript NestJS, REST, and PostgreSQL. The custom report builder made report generation 40% faster, and the resume records 99.9% uptime for the serving path.

I shipped a LangChain SQL-RAG chatbot so non-SQL users could ask warehouse questions. Generated reads stayed behind Postgres RLS and API RBAC for three organizational tiers, and Redis cached repeat bot work without removing tier context. The resume says analysis productivity rose 65% and bot database latency fell 35%.

I designed 30 real-time KPI dashboards with React and Recharts. The serving path used CloudFront, ALB, ECS, Docker, and automated CI/CD; GoDaddy delegated DNS into Route 53. The resume records 60% better operations efficiency and sub-210 ms response times. Dashboard requests did not need an LLM.

I was core software on Team Horizon’s semi-autonomous ROS2 Mars rover. I worked on the GStreamer camera path at 60 FPS and the software path behind 40% better obstacle detection. We placed 17th globally among 80+ teams at ERC 2024.

I connected ZED 2 mapping at 2M+ data points per second to ROS2, RViz, and Gazebo, then used a fused costmap as the planner-facing representation. That pipeline reduced collision risk 55%. The hard class was stale occupancy despite a live camera feed.

I studied Computer Science and Engineering at Cochin University of Science and Technology from October 2022 to May 2026, with a CGPA of 8.42 out of 10. My strongest applied depth came through internships, Horizon, IEDC, and eight hackathons.

I participated in exactly eight national and regional hackathons. The named results are CodeRecet first place, MLH Best Project, and Magnathon 2.0 runner-up. The resume connects them to rapid development and production-ready deployment.

I was a software team member on Team Horizon and a Tech Team member at IEDC CUSAT. My honest leadership mechanism is sharing setup, reviewing risky boundaries, and pairing until another teammate can run the path. I was not a people manager.

StratifyLabs is a browser-first CV experimentation platform. I built a 3D simulation lab, browser-based inference, a WebGL URDF editor, and scene-oriented Gemini RAG characters. Browser inference reduced ML iteration time 30%, and the marketplace contains 50+ pretrained models and datasets.

GiftedBooks is a VR learning suite with 3D labs, AI avatars, and contextual Q&A over the student’s uploaded PDF. The API was sub-300 ms at 99.5% uptime, with separate PYQ-based topic suggestions. The resume records reading +35%, engagement +50%, comprehension 2.5×, and doubts moving from hours to 3–10 minutes.

Argus is an industrial PPE and attendance vision system. I trained YOLOv9 on 15,000+ images, improving 73% to 89% mAP while holding 24 FPS. The containerized path supported 20+ camera feeds with PostgreSQL logging. Violations fell 50% and compliance doubled.

It means the system did not treat the first search result as truth. It collected through Firecrawl, Bing, DuckDuckGo, and selective Playwright, rejected empty or boilerplate results, and compared quality, recency, and agreement. Real disagreement stayed visible instead of becoming a fluent average. The resume number is 200+ websites. I do not have a labeled ranking protocol on the resume.

The comparison is the same BI product before the custom report-builder path, not a second product. I shipped FastAPI and NestJS application work over PostgreSQL so report requests no longer depended on the previous path. The exact resume outcome is 40% faster report generation. I do not have the study protocol on the resume, including the before/after query set or window.

The resume states 99.9% uptime for the Ylogx serving path. The mechanism I can defend is repeatable Docker tasks on ECS, an ECS service maintaining desired task count, ALB health checks removing unhealthy targets, CloudFront serving static/dashboard assets, and CI/CD replacing tasks rather than patching one host. I do not have the study protocol on the resume, including the SLO window or incident CSV.

The mechanism is that non-SQL users could ask a warehouse question instead of waiting for an analyst or engineer to write each query. The model proposed constrained SQL, Postgres executed under the caller’s permitted role, and RLS protected rows. The resume outcome is 65% higher analysis productivity. I do not have the study protocol on the resume.

Every natural-language turn was repeating database work. I put Redis cache-aside on repeated bot questions and schema work, kept tier or role context in the lookup, and filled only after Postgres executed under RLS. If Redis was unavailable, the safe fallback was Postgres under the same role. The resume result is 35% lower bot database latency. I do not have the study protocol on the resume, and I will not invent a percentile or expiry.

The mechanism was 30 live KPI dashboards replacing repeated ad-hoc reporting waits for known metrics. React and Recharts presented deterministic KPI responses; the chatbot remained a separate path. The resume number is 60% higher operational efficiency. I do not have the study protocol on the resume: not the survey, participants, or measurement window.

Sub-210 ms belongs to the Ylogx dashboard response path: CloudFront for static assets, ALB to healthy ECS tasks, and deterministic KPI APIs over the data layer. It is not the SQL-RAG end-to-end response, not an LLM round trip, and not GiftedBooks’ separate sub-300 ms API result. I do not have the study protocol on the resume, and the PDF does not label it p95.

The mechanism was a live camera path, dense ZED 2 depth feeding a planner-facing costmap, and sensor fusion on the hardware already integrated. The resume outcomes are 40% better obstacle detection and 55% lower collision risk. I do not have the study protocol on the resume, including a labeled bag count or baseline definition.

Browser-based inference shortened the edit-to-infer loop compared with repeating a local environment path. The exact resume outcome is 30% lower ML iteration time. The marketplace contains 50+ pretrained models and datasets. I do not have the study protocol on the resume, and 50+ is catalog inventory, not adoption.

The product mechanism was contextual Q&A from the student’s own PDF, separate PYQ-based topic prioritization, and a responsive VR learning surface. The exact resume outcomes are reading efficiency +35%, engagement +50%, comprehension 2.5×, and doubts moving from hours to 3–10 minutes. I do not have the study protocol on the resume.

Sub-300 ms is the API response result for contextual PDF Q&A, and 99.5% is the GiftedBooks availability result. The mechanism is ingest the PDF, retrieve a bounded evidence set, and generate from that set rather than rereading the whole file. I do not have the percentile label, hosting vendor, availability window, or study protocol on the resume.

The resume says YOLOv9 improved from 73% to 89% mAP after training on 15,000+ images. mAP summarizes precision-recall behavior across detector classes after box matching by IoU. It is not pixel accuracy and not the share of workers wearing PPE. I do not have the study protocol on the resume, including the split or class-level precision and recall.

No. 73%→89% mAP is detector evaluation. 50% fewer safety violations and 2× compliance are operational outcomes after automated alerts, containerized support for 20+ feeds, and PostgreSQL event logging. I do not have the study protocol on the resume, including a plant, shift window, or causal design.

The resume result is 24 FPS. The engineering reason is actionability: decode, inference, NMS, event I/O, and alerting must not build a stale queue. A one-stage detector fits that live-throughput goal better than multiplying a heavier two-stage path across 20+ feeds. I prefer dropping an obsolete frame to issuing a late “live” alert. I do not have the FPS benchmark protocol on the resume.

Intern was my title. I use “I” only for the bounded mechanism I designed or shipped. At IQVIA that is LangGraph orchestration, retrieval composition, ranking, and LangSmith evaluation. At Ylogx it is the report path, SQL RAG with RLS/RBAC, Redis on the bot path, dashboards, and the serving path I can explain. At Horizon it is core software around camera, mapping, costmap, and fusion. I do not convert that into ownership of the whole company, cloud account, or rover.

I say “I” for the mechanism I can trace: the graph edge, retrieval route, RLS execution boundary, cache path, dashboard, media path, costmap, model gate, or event log. I say “we” for team outcomes, especially Horizon’s 17th among 80+, and for hardware or product work outside my module. A resume percentage can remain a product outcome even when I personally shipped a mechanism behind it.

I did not build Azure AI Search, Firecrawl, LangGraph, or YOLOv9 themselves. I did not own IQVIA’s corporate infrastructure, Ylogx’s entire AWS account, Horizon’s mechanical design, PCB, or competition logistics, or a people-management function. I integrated those technologies into the resume systems and own only the application, retrieval, data, evaluation, or software mechanisms I name.

Python is production evidence in FastAPI, LangGraph/LangChain work, and Argus YOLOv9/OpenCV. TypeScript is evidenced through Ylogx NestJS/React and the Next.js product lane. JavaScript is listed and naturally adjacent to those web clients. Java is my Zoom Live Code language and DSA language. I did not ship IQVIA or Ylogx as Spring services.

I can defend Docker images, ECS tasks and services, ALB health routing, CloudFront, Route 53, and automated CI/CD on Ylogx. Kubernetes is listed knowledge; I was not a production cluster owner. GitHub Actions is listed, while the resume proves automated pipelines, not a specific workflow filename or job graph.

HTML and CSS are baseline web skills. Node.js is evidenced through NestJS and Next.js. React is directly evidenced by Ylogx’s 30 dashboards; Next.js is tied to the StratifyLabs web lane. Tailwind, ShadCN, Redux, and Three.js are listed UI skills. The resume names React/Recharts and URDF/WebGL, so I do not attribute a metric to Redux, ShadCN, or Three.js.

Ylogx’s production API evidence is REST and JSON. GraphQL is listed knowledge for nested client-driven reads, but I do not claim it was the BI gateway. ProtoBuf is listed knowledge for compact typed messages, not a shipped gRPC mesh. WebSockets are listed; the resume says real-time dashboards, but it does not prove a socket bus, so I describe REST/polling and compare sockets only as Standard CS.

Nginx is a listed reverse-proxy skill. The Ylogx edge I can defend is CloudFront for edge/static delivery, ALB for regional layer-7 routing and health checks, and ECS for container tasks. I can compare Nginx conceptually, but I will not insert it into the production path or claim it terminated Ylogx TLS.

OAuth 2.0, JWT, Auth0, and web security are listed identity/security skills. My strongest production evidence is Ylogx: API identity maps to route-level RBAC, then to a non-owner database role, and Postgres RLS controls visible rows for three organizational tiers. Auth0 is not named in that bullet, so I do not claim provider administration. Web security means deterministic validation and least privilege, not token vocabulary.

FastAPI is evidenced in IQVIA and Ylogx. NestJS is evidenced in Ylogx’s typed business/API path. LangChain is the Ylogx SQL-RAG chain. LangGraph is the IQVIA stateful multi-tool and adaptive-retrieval path. Flask is listed, but it is not the named runtime for those bullets. I keep chain and graph evidence separate.

YOLOv9 is the Argus detector and OpenCV handles image/video preparation around that path. Pandas and NumPy are honest Python data and evaluation tools, but not named standalone services. TensorFlow is listed knowledge. I will not say TensorFlow produced the quoted 73→89% YOLOv9 result unless a source explicitly says so.

Generative AI and RAG are evidenced through IQVIA research/BRDs, Ylogx SQL RAG, GiftedBooks PDF Q&A, and StratifyLabs scene bots. LangSmith is specifically IQVIA tracing and evaluation. Gemini is specifically named for StratifyLabs. OpenAI API and Local LLMs are listed skills; the PDF does not assign a foundation-model vendor to every product.

PostgreSQL is the strongest shipped evidence: Ylogx BI facts, joins, aggregates, and RLS; Argus structured event logging. MySQL, MongoDB, Firebase, and Supabase are listed database skills. I will not move them into the Ylogx warehouse or claim Firebase as GiftedBooks hosting because the PDF does not say that.

Redis is shipped evidence: it reduced Ylogx bot database latency by 35% through tier-aware caching. Prisma is a listed ORM skill. The resume names PostgreSQL as the Ylogx database, but it does not name Prisma as the production data-access layer. Redis remained cache, not source of truth.

FAISS is listed vector-search knowledge. IQVIA’s production retrieval evidence is Azure AI Search Hybrid + Semantic, not FAISS. GiftedBooks is the smaller PDF-RAG lane, but the resume does not name its vector-store vendor. I can explain embedding search conceptually without manufacturing a FAISS production topology.

The internship claim I defend is GraphDB for requirement dependency hops beside Azure AI Search. Neo4j is a named graph-database skill. If the interviewer points at the skills line, I can discuss nodes, directed edges, visited sets, and bounded hops. I do not turn that into operation of a named Neo4j production cluster.

Git, GitHub, and Linux are everyday development tools. Postman and OpenAPI are how I reason about and inspect REST contracts. Jupyter is appropriate for data/model exploration, not the always-on production service. Those are credible tool skills, but I do not attach a resume percentage to a tool or claim OpenAPI generated the architecture.

Vercel, Render, and Railway are listed deployment tools. Ylogx production evidence is CloudFront, ALB, ECS, Docker, Route 53, and CI/CD. GiftedBooks has 99.5% uptime and sub-300 ms on the PDF, but its hosting vendor is not named. I will not fill that gap with a tools-line vendor.

Web scraping is evidenced through authorized IQVIA research using search, Firecrawl, and selective Playwright. Web security is evidenced most deeply through deterministic authorization boundaries at Ylogx: RBAC at the API and RLS in Postgres. Scraping does not mean bypassing access controls, and security does not mean inventing a penetration-test story.

That is a mismatch, and I would fix the README. GiftedBooks on my August 2026 resume is the VR learning suite: 3D labs, avatars, PDF RAG, PYQ suggestions, sub-300 ms, 99.5% uptime, +35% reading, +50% engagement, 2.5× comprehension, and doubts from hours to 3–10 minutes. AegisAI is not this story.

The default README is a documentation weakness, not evidence for extra features. The product I defend is the resume: browser 3D simulation, browser inference with 30% lower iteration time, 50+ models and datasets, profiles, URDF/WebGL, and Gemini scene bots. I would replace the scaffold README with the actual architecture and evidence.

I will not invent routes from a 404. The resume evidence is YOLOv9 from 73% to 89% mAP on 15,000+ images, 24 FPS, PPE and attendance, containerized support for 20+ cameras, PostgreSQL logs, 50% fewer violations, and 2× compliance. I can draw frame → detect → persist → alert without guessing endpoint names.

It is a supporting public webcam-stream artifact that demonstrates the GStreamer/UDP-family pipeline shape. It supports the explanation of Horizon’s 60 FPS camera path. It is not the rover, not another internship, not a second ERC result, and not evidence for any extra metric.

It is a security-awareness demo used with consent, not a production attack system. I will not walk phishing, credential capture, or exploit steps. If you want shipped depth, I can show Ylogx RLS, Argus safety events, StratifyLabs, or IQVIA retrieval and evaluation.

I label them “GitHub” in the first sentence. Conv-BI and Warpflow are Ylogx-adjacent artifacts, not extra internship products. valAgent and karyanode are separate repository work, not IQVIA resume bullets. Horizon-Website-old, Team-CUSAT, and visionlabServer also do not inherit resume metrics. If the interviewer wants resume evidence, I redirect to the named PDF system.

Login Tracker is unverified, so I do not volunteer it as a resume or Job 10454435 question. I did not ship a rate limiter at Ylogx. Redis there was cache-aside for the bot database path. A rate limiter is a Standard CS design I can discuss if asked, but the evidence count is one independent SDE I report, not a UTA default and not a prediction.

They share retrieve-then-generate, but the source of truth differs. Ylogx is SQL RAG: natural language becomes constrained SQL, and Postgres RLS controls rows. IQVIA Deep Research collects and ranks open-web evidence. IQVIA Hybrid RAG retrieves exact BRD clauses, semantic matches, and dependency hops with LangSmith traces. GiftedBooks retrieves from one student’s uploaded PDF with a sub-300 ms product goal. StratifyLabs conditions Gemini bots on simulated scene context.

Open-web research has no single gold page. It needs multi-tool discovery, partial-failure handling, source ranking, deduplication, and explicit disagreement. A BRD has an authoritative document, but contains exact IDs, tables, paraphrases, and dependencies. It needs Azure hybrid/semantic retrieval, GraphDB hops, and citation/test tracing. One orchestration style can be shared; one index cannot solve both failures honestly.

I use GenAI where output can be grounded and checked: cited research, cited BRD answers/tests, or constrained SQL proposals. I do not use it to assign a database role, write final RLS policy, calculate a known KPI, approve a deployment, create PPE boxes, update rover occupancy, or emit actuator commands. The model is an interface or synthesis step; deterministic systems remain the source of truth.

BRD means business requirements document. It is long, structured, and confidential, with headings, tables, clause or requirement identifiers, and relationships among requirements. “200+ page” is the exact resume scale. The system ingested and retrieved from those documents; I did not author the BRDs or put the whole document into every prompt.

Hybrid retrieval combines lexical matching with vector retrieval in one candidate search. Lexical search protects exact IDs and table names; vector retrieval handles paraphrases. Azure Semantic is a reranking layer over candidates to improve meaning-aware ordering. GraphDB remains separate for explicit dependencies. I did not invent an embedding model or operate a different vector database.

A vector database retrieves semantically similar items. A graph database stores nodes and explicit relationships. Similarity can find a paragraph about retention; it cannot prove that REQ-A DEPENDS_ON REQ-B. The graph hop finds the connected requirement, then the search index supplies text for citation. I call the internship component GraphDB and reserve Neo4j for the skills discussion.

Firecrawl is a crawl/extraction service for obtaining page content without owning every DOM. Playwright is browser automation: it renders JavaScript and interacts with pages when a static extraction is empty. Browser rendering is heavier, so it should be selective. Bing and DuckDuckGo provide independent indexed discovery. LangGraph keeps failures branch-local.

A task definition is the runtime recipe: image, ports, resources, and configuration. A task is one running copy. A service maintains a desired number of tasks, replaces unhealthy copies, and connects them to an ALB target group. A cluster is the capacity pool where tasks run. Scaling a service changes desired count; it does not resize my laptop.

CloudFront is the edge/CDN layer for static or intentionally cacheable content. ALB is regional layer-7 routing with host/path rules, target groups, and health checks. Redis is application cache on the tier-aware bot path. Client → CloudFront → ALB → ECS is serving; ECS → Redis/Postgres is application data access. Private tenant JSON is not automatically an edge-cache object.

GoDaddy is the registrar in this path. Nameserver delegation makes Route 53 authoritative for the hosted zone. A Route 53 alias points to the public serving layer, with CloudFront handling edge/static traffic and ALB routing dynamic HTTP to healthy ECS tasks. DNS gets the client to the service; it does not fix RLS, application code, or database latency.

IoU is intersection over union between a predicted and ground-truth box. Precision asks how many predicted detections are correct; recall asks how many real objects were found. Average precision summarizes a class’s precision-recall curve, and mAP averages AP across the evaluated classes/settings. NMS removes overlapping duplicate boxes. Simple classification accuracy is not the correct summary for localization.

It is the exact academic record: B.Tech CSE, October 2022 to May 2026, 8.42/10. I do not present CGPA as a production metric. The applied evidence is IQVIA and Ylogx software, Horizon’s 17th/80+ team result, IEDC Tech Team, and exactly eight hackathons.

Yes. I intern in Kochi and studied at CUSAT. This SDE I AUTA APJ role is with ADCI Karnataka, and I will relocate. I am not asking for a Kochi or remote exception in this process.

I started the IQVIA internship in Kochi during the final part of my CSE graduation window. The PDF records the role from April 2026 and graduation through May 2026. The overlap is visible, and I will not invent a day-by-day calendar or alter either date. The work is the two FastAPI/LangGraph retrieval systems on the resume.

They repeatedly exercised short-cycle integration: identify the critical path, get it deployable, pair on the risky boundary, and cut optional polish before cutting correctness. The evidence is exactly eight events, CodeRecet first, MLH Best Project, and Magnathon 2.0 runner-up. For technical depth I switch to a named resume system rather than inventing an event architecture.

I was a Tech Team member, not a manager. The leadership mechanism I can defend is technical: share setup, expose prior failure modes, review the risky path, and pair until another teammate can execute independently. I did not hire, performance-manage, or count mentees.

I have learned to own a bounded software slice end to end: interface, retrieval or data path, correctness boundary, evaluation, and deployment. IQVIA taught me that fluent research needs evidence. Ylogx taught me that SQL RAG is not done until rows are isolated. Horizon taught me that live video is not delivery if the costmap is stale. I want SDE I scope where that production judgment, customer impact, and operational ownership are the job, while I continue growing under Amazon’s engineering bar.

The three work experiences do not overlap. Horizon was February to June 2024. Ylogx was November 2024 to October 2025. IQVIA began April 2026. The education window overlaps the internships, but the jobs themselves are sequential. I do not fill the November 2025–March 2026 gap with off-resume stories unless specifically asked and verified.

Each role gave me a different production constraint. Horizon was real-time robotics: a current feed could coexist with stale occupancy. Ylogx was data trust and serving: a chatbot could return rows while isolation and database latency were still wrong. IQVIA is retrieval and evaluation: first-hit web ranking and vector-only BRD retrieval can look fluent and still be unsupported. I can go deep on any one mechanism, not just list technologies.

They are two systems with shared technologies, not one duplicated bullet. Deep Research solves discovery, partial failure, source ranking, and disagreement across 200+ websites. Hybrid RAG solves exact IDs, semantic retrieval, dependency hops, and traced test generation on 200+ page BRDs. Shared FastAPI, LangGraph, and LangSmith do not make the retrieval problem identical.

R1 was 13 August 2026 and R2 was 18 August 2026. Both are done. The online assessment was not a round. I am preparing for R3 and a possible R4. I do not predict whether either will be DSA, HM, Bar Raiser, GenAI Fluency, LLD, or another technical format. Job 10454435 still has no verified named live question.

RBAC answers which action the authenticated caller may perform: view dashboard, build report, or use analysis. RLS answers which Postgres rows that permitted action may return. The application maps the caller to a non-owner database role, and generated SQL executes under that role. A missed app WHERE or broad JOIN still encounters row policy. Cache identity retains tier or role context. The resume states three tiers but not their literal names.

NestJS fit typed business modules: identity, RBAC, report CRUD, and deterministic dashboard REST. FastAPI fit the Python LangChain SQL-RAG path. PostgreSQL remained relational truth and enforcement, and React/Recharts consumed the APIs. The choice was not “microservices are always better.” It kept model-specific code separate from ordinary business routes while sharing the same data and authorization contract.

The defensible flow is: run checks, build a repeatable Docker image, publish the deployment artifact, update an ECS task definition/service, start replacement tasks, and let ALB health gate traffic. That avoids manually patching a snowflake host and supports repeatable rollback to a known artifact. I do not claim exact workflow names or rollout thresholds.

In Argus, OpenCV handles frame decode, resize, and surrounding image operations. YOLOv9 is the object detector producing PPE boxes and classes. NMS removes duplicate boxes. TensorFlow is on my skills line, but I do not claim it was the runtime responsible for the 73→89% mAP improvement. The detector system is Python, while Live Code remains Java.

Ylogx needed relational joins, aggregations, transactions, and database row-level security. PostgreSQL fit those requirements. Argus needed structured, queryable event logs, which also fit Postgres. The other databases are listed skills, but the PDF does not place them in these systems. I choose based on data semantics, not because one database appears on the skills line.

Not necessarily. “Real-time” is a product freshness description, not proof of a specific transport. The shipped API evidence is REST. Polling is simpler when update frequency and connection count allow it. WebSockets are useful for server-push and frequent changes, but they add connection lifecycle, fan-out, authorization, and backpressure concerns. I can compare them without inventing which one carried the 30 dashboards.

I can build and reason about component structure, styling, state, and browser 3D rendering with those tools. The strongest resume evidence is: Ylogx React/Recharts dashboards, StratifyLabs’ URDF/WebGL browser lab, and GiftedBooks’ VR learning surface. Tailwind, ShadCN, Redux, and Three.js remain listed skills unless a specific artifact proves their use. I do not manufacture design-system ownership.

For Ylogx I can trace the deployed request: DNS through Route 53, static delivery at CloudFront, dynamic routing through ALB, Docker tasks maintained by ECS, and automated CI/CD. For other projects, I use only the availability and latency numbers printed and do not guess Vercel, Render, or Railway. A logo is not an ownership answer; the request and failure path is.

I would choose Argus, GiftedBooks, or StratifyLabs, not rewrite an internship as solo work. For Argus: the problem is trustworthy PPE alerts; the path is OpenCV → YOLOv9 → NMS → Postgres event; the hard gate is 73→89% mAP while holding 24 FPS; and the result includes 20+ feeds, 50% fewer violations, and 2× compliance. I still avoid claiming every external asset or deployment platform.

GiftedBooks/AegisAI: mismatch, PDF GiftedBooks only. Stratify default README: documentation weakness, resume product. Argus 404: no routes, use detector/event architecture. Gstreamer-UDP: supporting Horizon artifact only. InstaRecon: consent-based awareness demo, no attack steps. Conv-BI/Warpflow: Ylogx-adjacent, not extra jobs. valAgent/karyanode: GitHub only. Login Tracker: unverified.