Full-stack products, AI systems, and robotics — from investigation agents and government-scheme tools to an autonomous ground vehicle. Engineering work with source, architecture, and honest status labels.
Strongest engineering evidence first — source, architecture, and honest status on every entry.
An agentic fraud investigation system combining graph-based pattern detection, LangGraph reasoning, deterministic risk scoring and next-best-action recommendations.
Vision-based autonomous navigation for an unmanned ground vehicle operating in outdoor environments.
An AI government-scheme navigator that separates language understanding from deterministic eligibility evaluation.
A telemetry dashboard connecting physical gas-sensor data with a real-time web interface.
“From a flagged account to an auditable next-best action.”
Fraud tools tend to fail in two ways: static rule engines miss relational syndicates spread across accounts, devices, and merchants — or black-box scoring models produce numbers no auditor can defend. Analysts get alerts, but not an investigation.
LLM reasoning ≠ risk calculation
The LangGraph agent structures the investigation narrative. Risk score, evidence confidence, and uncertainty are computed by deterministic engines — same inputs, same outputs, every run. Nothing is scored by the language model alone.
TigerGraph GSQL schema · deterministic local simulator as default runtime
React · TypeScript · Tailwind — case directory, force-directed graph canvas, risk gauges, pattern findings, recommended actions, and an immutable audit timeline in a single investigation workspace.
Active prototypes and open experiments — each row labeled by what it actually is.
Vision-based autonomous navigation for an unmanned ground vehicle, running end-to-end on physical hardware outdoors.
Five-stage perception-to-motor pipeline built for Smart India Hackathon 2025. Full story in the NAVIGEN case study.
“From physical motor loops to the software stack that drives them.”
Hardware, sensors, and firmware connect into languages, libraries, and architecture.
An exploratory matrix. Verified technologies are marked as “Used in”, active builds as “BUILDING”, and research horizons as “EXPLORING” or “PLANNED”.
“From writing code manually to orchestrating agents in the terminal.”
Developer tooling and AI workflows act as force multipliers for rapid prototyping.
AI Software Engineering Agent
“From task to tested code — directly from the terminal.”
“I wanted to explore what happens when AI becomes part of the software engineering workflow itself — not just a chatbot that answers questions, but a tool that can inspect a codebase, break down a task, work with developer tools, and help move an idea toward working software.”
Areas actively explored and built hands-on — zero exaggerated claims.
“From single-developer tools to real-time multiplayer products.”
Where multiple people, shared state, and live synchronization meet.
Real-Time Collaborative Workspace
“Work together. See everything.”
I'm exploring how real-time state, collaboration, and thoughtful product design come together in a full-stack application.
“I wanted to build something that goes beyond traditional CRUD applications and forces me to think about what happens when multiple people interact with the same product at the same time.”
What actually happens between two keyboards separated by hundreds of miles.
“The hard part isn't making data move.
It's making collaboration feel effortless.”
“From synchronizing live state to grounding answers in evidence.”
Turning scattered documents into traceable, verifiable intelligence.
Turn scattered knowledge into answers you can trace.
“The interesting part isn't generating an answer. It's knowing where that answer came from.”
A knowledge workspace exploring document ingestion, semantic retrieval, grounded generation, and evidence-first answers. Building systems that refuse to guess when they can verify.
Query vector matched against passage index using nearest-neighbor similarity ranking.
“What are the important hardware and processing constraints in the system?”
The primary physical constraint is processing capacity on the single-board edge processor [01]. Running full-resolution raw camera frames alongside ROS 2 nodes causes memory bus saturation. Consequently, frame capture must be cropped to the ground path ahead of the drive wheels [02], and edge motor control loops must fall back to emergency stop if telemetry pings drop for more than 500ms [03].
“The Raspberry Pi 4 edge compute budget is strictly bounded to 30 FPS at 640x480 resolution to reserve CPU overhead for the Nav2 local planner and differential wheel drive.”
Every claim is mapped deterministically to chunk character offsets. Zero ungrounded synthesis is permitted into the output payload.
Parsing varied formats (PDF, Markdown, text) into clean normalized text streams.
Evaluating fixed-size token windows vs semantic sentence and paragraph splitting.
Understanding dense representations and mathematical cosine distance mapping.
Combining keyword BM25 with vector similarity for hybrid document search.
Researching index structures like HNSW for fast k-nearest-neighbor lookups.
Budgeting prompts with only the highest-scoring chunks to avoid context dilution.
Constraining synthesis strictly to provided evidence passages with zero extrapolation.
Deterministic mapping from each output sentence back to verifiable chunk excerpts.
“From asking what is true to understanding how software ships.”
Connecting source code, automated gates, builds, and edge observability.
Forge helps build software through terminal agent loops. Nexus helps understand, verify, and ship it through operational infrastructure.
From commit to deployment — see what happens in between.
“Building software isn't just writing lines in an editor. It's managing the entire machine that takes code to users.”
An exploration of developer infrastructure that connects source code, automated checks, builds, deployments, and project health in one place.
Executes Next.js Turbopack compiler, generates server bundles and static assets.
Zero manual intervention required to prevent broken builds or leaked credentials from reaching remote environments.
Systems that turn scattered documents into verifiable answers you can trace.
Systems that take source code across automated gates into running infrastructure.
“Build systems that understand information and systems that understand software.”
One grounds intelligence in truth. The other grounds engineering in reliable pipelines.
“Building isn't a straight line.”
Every real project breaks during development. What matters isn't pretending things worked on the first try, but knowing how to inspect the failure, fix the root cause, and keep the lesson for the next build.
When running OpenCV contour detection for obstacle segmentation alongside ROS 2 nodes on the Raspberry Pi 4, the camera feed stuttered significantly, introducing unacceptable navigation delays.
Monitored CPU load via htop during live runs. The Pi's CPU cores were maxed out because the camera node was capturing uncompressed high-resolution frames, causing memory bus bottlenecks before path planning even received the image.
Lowered the camera capture resolution in code, skipped redundant intermediate frames, and cropped the region of interest strictly to the ground path ahead of the UGV wheels.
On resource-constrained edge hardware, processing less data efficiently beats trying to optimize heavy computation.
“Things I'm currently figuring out.”
Instead of a conventional biography, here is what I'm actively researching, testing, and figuring out across hardware, software, and real-time systems.
“How do node lifecycles and DDS topics translate simulation into physical motors?”
Physical robots require planning for packet loss and latency at every node boundary.
“I don't just write code. I use the tools around me to turn ideas into working products faster.”
Before writing a line of code or wiring a breadboard, I pinpoint the core constraint — whether it's an autonomous ground vehicle navigating outdoor terrain or an IoT dashboard needing instant gas hazard alerts.
Vision-based autonomous navigation for an unmanned ground vehicle.
Graph-grounded fraud investigation with deterministic risk and next-best actions.
Classification and clustering study of the UCI student performance dataset.
Scheme eligibility where the LLM understands the query and a rules engine decides.
Terminal agent that plans, inspects, codes, and verifies software.
Collaborative workspace for shared state, presence, and live sync.
Knowledge workspace that answers with evidence you can trace.
Operational view connecting repos, test gates, builds, and telemetry.
Nothing sits at concept-only stage right now — every project above is either shipped or in active build.
“I turn real-world sensor data into usable interfaces.”
Real-time monitoring of LPG concentration, solenoid valve status, hazard alerts, and activity logs — streaming from physical MQ-6 sensors. Source is public — every component and Firebase listener is inspectable in the repository.
“The language model understands. The rules engine decides.”
An AI government scheme navigator for scholarships and education schemes — the language model handles understanding; a deterministic rules engine evaluates eligibility against published scheme rules, so users can determine likely eligibility with RAG knowledge retrieval and OCR document support. Phase 1 scaffold with a four-member team across AI/RAG, eligibility, OCR, and frontend modules.
A healthcare-focused technology project combining frontend and backend components to explore practical digital solutions for healthcare. Focuses on application architecture and structured data handling.
A dashboard-focused web application demonstrating modern UI development, responsive design and component-based application interfaces for clean data presentation.
A project focused on exploring development workflows, version control best-practices, deployment concepts, and automation techniques.
“Hackathons taught me how to turn an idea into a prototype before the clock runs out.”
“Vision Based Autonomous Navigation for Unmanned Ground Vehicle for Outdoor Environment”
Engineered NAVIGEN, an autonomous navigation stack for an Unmanned Ground Vehicle navigating outdoor environments using computer vision and edge microcontrollers.
Look at the code. Verified open-source repositories and commits on GitHub.
Graph-based fraud investigation with deterministic risk scoring, a LangGraph agent, and a React investigation dashboard.
AI government scheme navigator — LLM for language understanding, deterministic rules engine for eligibility decisions.
BCA data mining case study — classification and clustering on the UCI student performance dataset with reproducible results.
Real-time IoT dashboard for monitoring LPG gas leakage and system status, visual charts, and valve alerts.
Healthcare-focused technology project combining frontend and backend components for digital health solutions.
Dashboard-focused web application demonstrating modern UI development and component interfaces.
Development workflows, version control configurations, deployment concepts, and automation practices.
All projects, robotics code, and web experiments in one place.
BCA student in Bangalore. I build full-stack products, AI systems, and robots — mostly by starting a prototype and learning whatever the problem demands.
I'm Nikhil Chhetri — a BCA student at Dayananda Sagar University who treats hackathons as proof-of-work: NAVIGEN ran on a physical UGV at Smart India Hackathon 2025, my fraud investigation agent ships with public source, and SchemeSaathi is an active team build. Outside deadlines I keep a builder's lab of prototypes, write build notes on what I'm still figuring out, and use the terminal + AI as force multipliers — without letting the tools think for me.
Learn by building · Ship under constraints · Keep the status labels honest
Bachelor of Computer Applications (BCA)
Core coursework in computer applications, programming fundamentals, data structures, database management, web systems, and computational theory.
School Education
Foundational schooling that built initial scientific inquiry, mathematics, and an abiding interest in technology and computer science.
Modern component state, client dashboards & responsive interfaces
Open to interesting projects, hackathons, internships, freelance work, and collaborations. The fastest path is email.