Building AI That Has to Survive Production
I'm an AI/ML engineer working on LLM and RAG applications, computer vision, and the backend and MLOps plumbing that keeps them running. My work has spanned document intelligence, distributed self-play, ROS2 robotics and automated ML pipelines.
I like the part most people skip: the ingestion that doesn't silently drop rows, the pipeline that can be re-run without fear, the model that still behaves when the data shifts underneath it. A demo is easy. Something that holds up is the interesting problem.
Education
B.Tech, Computer Science Engineering (AI & ML)
Manipal University Jaipur — December 2025
- Presented at IEEE and the American Control Conference (ACC'24)
- Paper published at ACROSET 2025, IEEE Xplore
- Winner — Codestellation CodeWar 4.0 Hackathon
- Finalist — international eYRC robotics competition, Next Big Thing Hackathon
Curriculum Vitae
Five roles across consulting, banking, industrial software and GenAI — plus the degree that ran alongside them.
TG
2026
Tata Group
Gen AI Data Analyst — Jan to Jul 2026
Most recentExploratory data analysis with GenAI tooling to judge data quality and surface risk indicators. Proposed a no-code predictive framework for scoring customer delinquency, and an AI-driven collections strategy built on agentic automation — with ethics, regulatory compliance and scale designed in rather than bolted on.
JP
2026
JPMorgan Chase & Co.
Quantitative Researcher — Feb to Apr 2026
Analysed a book of loans to estimate each customer's probability of default, using dynamic programming to turn raw FICO scores into categorical bands the model could actually use.
BCG
2025
BCG
Data Science Intern — Nov 2025 to Jan 2026
Customer churn analysis in Python, Pandas and NumPy. Built and tuned a Random Forest to 50% recall, then carried the findings up into an executive summary that fed a business decision.
D
2025
Deloitte
Data Analytics Trainee — Oct to Nov 2025
A data analysis and forensic technology simulation built around business investigation workflows. Classified and cleaned records in Excel, then built a Tableau dashboard to make the patterns visible and arguable.
MF
2024
Main Flow Services & Technologies
Software Intern, Remote — Jul to Nov 2024
Trained YOLO models for object detection and deployed Docker-based ROS2 systems integrating sensors and control modules. Automated the ROS2 data processing pipelines and configured PLC-controlled motor systems.
The full document
Every role, every date, in one page.
Projects
Things built end to end, all of them public. The three below are the ones worth reading the source of.
▣
Local Software Factory
An agentic coding assistant that never leaves the laptop — Python
LlamaIndex for retrieval, Qwen 3 8B through Ollama for generation, LangGraph holding the loop together, and no cloud model API anywhere in it. A change is retrieved, generated, validated, retried and only then offered for approval — AST parsing, Ruff and pytest all run before anything is written to disk. The constraint that shaped it was the machine: CPU only, 16 GB, which is what a laptop has rather than what a model wants.
Source∆
FinGuard
A quantitative execution platform in three languages — C++20, Go, Python
C++20 runs execution, Go handles ingestion and persistence, Python does the ML — each where it earns its place. Deterministic event replay, order-book simulation, execution-cost analysis and statistical risk monitoring, with walk-forward pipelines for market impact, fill probability, latency forecasting and anomaly detection. SQLite, Parquet and DuckDB underneath. Live trading is disabled and every number so far is on synthetic data, which is the honest state of it.
Source⟳
agentd
A scheduled runner that repairs its own extractions — Go
Agents run checks against external sources on a schedule. The hard part is not running them, it is what happens when a source quietly changes shape and the extraction starts returning nothing: agentd detects that failure and proposes a verified repair for a human to approve, instead of reporting a silent zero. SQLite in WAL mode for durable state, MCP plugins for the tool surface, and a hexagonal architecture whose boundaries are enforced by import-graph tests rather than by convention.
Source✚
CareNest
Healthcare booking for India — TypeScript, Next.js 16
Clinic visits, video consultations, lab tests, surgery and veterinary care under one booking flow, over Postgres split across three schemas. The part I would point at is the search: instead of geocoding every query, areas are connected by a pre-computed proximity graph with hand-authored adjacency, so "near me" resolves locally with no map provider in the request path.
Source◐
QWERTY Studio
Self-hosted anti-detect browser — Python, Playwright, React
An open alternative to GoLogin and Multilogin. Most fingerprint tools randomise each value independently, which is exactly what gives them away — a GPU that never ships with that screen, a timezone that never ships with that locale. This one draws every value from a single device archetype out of roughly four hundred, so the profile stays internally consistent.
SourceRAG
PDF AI SaaS
LLM chat over your own documents
A retrieval-augmented document intelligence app: upload a PDF and ask it questions in plain language. Handles ingestion, chunking, embedding generation, semantic retrieval and context-aware response generation, wired to REST APIs so document processing, retrieval and conversation are separate, replaceable stages.
Source♟
Hybrid Minimax–MCTS Chess Engine
Enhanced by RLHF, using Stockfish and AlphaZero — ACROSET 2025
A hybrid engine combining Minimax, Monte Carlo Tree Search and a reinforcement-learning evaluation. Self-play training was scaled to 10 million games across distributed CPU workers with automated evaluation pipelines, improving playing strength by roughly 100–150 Elo over baseline engines with full experiment tracking.
Read the paper Source📈
Advanced Stock Forecaster
CNN-BiLSTM-GRU
A deep forecasting stack reading historical market data for future trends. Three architectures — CNN, BiLSTM and GRU — were trained and evaluated against each other to find which actually captured the time-based structure rather than memorising it.
Source👁
Real-Time Animal Detection
Computer vision on live CCTV
A detection system processing live video streams to identify animals as they appear, for safety monitoring. Trained and deployed to run continuously against real camera feeds rather than a curated test set.
Source🦊
The Adventures of the Heroic Fox
A platformer in Godot — GDScript
Not everything has a model in it. A small side-scroller built in Godot, which is also where a fair amount of what you are currently standing in came from.
SourceCI
CI/CD & MLOps Pipelines
Build, test and deploy without a human in the loop
Pipelines automating build, test and deployment for both ML and application workloads, stood up on AWS using CodePipeline, CodeDeploy and CloudFormation.
SourceTechnologies
The tools I reach for, and what I actually use each one to do.
Py
Python
My primary language
Everything starts here — models, pipelines, analysis, glue. Pandas and NumPy for the data, scikit-learn for the classical work, and whatever the problem needs on top.
🔥
PyTorch
Deep learning framework
CNNs, transformers and recurrent stacks. Used across the chess engine's evaluation network and the CNN-BiLSTM-GRU forecaster. TensorFlow when a project already speaks it.
🔗
LangChain & OpenAI
LLM and RAG applications
Retrieval pipelines, embeddings, vector search in Pinecone, prompt engineering, and agentic tool / planner / memory patterns. The PDF AI SaaS is built on this stack end to end.
👁
OpenCV & YOLO
Computer vision
Object detection and image classification, trained and deployed against live video rather than static datasets — including ROS2 robotics systems running in Docker.
⚙
Docker & AWS
MLOps and deployment
Containers, CI/CD, and AWS CodePipeline, CodeDeploy and CloudFormation. MLflow and Weights & Biases for tracking, because an experiment you can't reproduce didn't happen.
JS
JavaScript & TypeScript
Interfaces and APIs
Node and REST APIs on the backend, Next.js on the front. This entire game is vanilla JavaScript on one canvas — no framework, no engine, no dependencies.
Other technologies and experience
- SQL and relational data modelling
- C++ and Bash
- Hugging Face Transformers
- scikit-learn
- ROS2 and PLC control systems
- Streamlit and Gradio
- Tableau and Excel
- Git, GitHub, Linux
Contact
Below you can find ways to get in touch with me.
Emailsaiyashwantreddypanthy@gmail.com Book a callcal.com — pick a time that suits you GitHubgithub.com/champion19007 LinkedInlinkedin.com/in/saiyashwantreddy
Here
Visited
Unseen
CHOSEN-ONE / MAP
Under the Hood
How does this portfolio work?
Architecture
There is no framework and no game engine here. The whole thing is one <canvas> element, one JavaScript file, and a fixed 60 Hz accumulator loop — about 900 lines with no dependencies at all.
The split is simple: the canvas draws the world, and ordinary DOM sits on top of it for anything made of text. Menus, dialogue and these panels are HTML, which means they get real fonts, real links and real accessibility for free, while the game underneath stays a pure pixel surface.
State lives in three places — a stage table describing the world, a player object, and a small amount of transition state. That's the entire model.
Stage System
Most 2D games build levels from a tilemap and a collision mesh. This one doesn't have either. Each painted image is a stage, exactly one screen wide, and the ground is part of the artwork.
So a stage needs only a few numbers: where the feet sit (feetY), how zoomed the art is (scale), and how far the solid ground reaches (x0 and x1). Walk past x1 and the screen fades to the next stage; walk past x0 and it fades back.
Every one of those numbers was measured against the characters already painted into the scene, so the hero stands on the same ground they do and matches their height. That's why the zoom differs per stage — the source images were shot at wildly different scales, from 1.2× to 3.0×.
Rendering
The canvas is backed at real display resolution — viewport × devicePixelRatio — and the 512×288 design space is mapped onto it with a single transform. Drawing code works in design coordinates while every pixel it produces is an actual screen pixel.
That matters more than it sounds. The naive version draws into a fixed 512×288 buffer and lets CSS stretch it, which crushes a 1280px painting to 512 and blows it back up — throwing away 60% of the detail and then magnifying what's left.
Filtering is chosen per draw, from the direction of scaling: smoothing on when an image is being shrunk, off when pixel art is being enlarged. Nearest-neighbour is right for one and actively destructive for the other.
Animation
Several stages are animated. The obvious approach — drop an animated GIF in an <img> and blit it each frame — does not work reliably: browsers only advance GIF frames while the page is actively painting, so a clipped, backgrounded or merely unlucky image freezes on frame one.
Instead each animated stage is decoded once with WebCodecs ImageDecoder into a set of ImageBitmaps, and played from the game clock. Timing is under our control and the result is identical everywhere.
The character is a different problem: an 800×448 sheet of 80×64 frames, composited at build time from six separate paper-doll layers — skin, hair, shirt, trousers, boots — into a single texture. The art faces left, so facing right is the mirrored case.
NPC System
Most of the people you can talk to were already painted into the artwork. Rather than draw new sprites over them, each is just a trigger point at that figure's x position. Two stages had nobody standing in them, so those get a villager composited from the same paper-doll layers as the hero.
Proximity is nearest-wins, not first-in-range. On a crowded screen with five people standing close together, "is anyone in range?" would let whichever one appears first in the array hold the floor while you walk past the other four.
Nobody is solid. A villager standing mid-stage would otherwise wall off the only route onward — and since the hero draws on top, walking past reads correctly as passing in front of them.
Optimization
Decoded animation frames are the only real memory cost, so they're bounded on three axes: a frame budget per stage (larger frames mean fewer of them), a decode resolution matched to the display rather than the source, and an LRU cache holding only a few stages at once.
Decoding is lazy and predictive — the current stage plus its neighbours, so the next screen is ready before you reach it.
An IntersectionObserver pauses the loop entirely when the canvas scrolls out of view, and the fixed-timestep accumulator clamps large deltas so a backgrounded tab doesn't return and simulate thirty seconds in one frame.