Vatsal.
Computer Engineering student focused on building Full-Stack AI, Embedded, and Systems Software.
01. About Me
I'm Vatsal a Computer Engineering student who enjoys understanding how systems work beneath the abstractions.
Many of my projects involve rebuilding core ideas rather than relying entirely on existing frameworks whether that's implementing automatic differentiation for neural networks, writing real-time game loops, or integrating embedded hardware with backend services. I find that recreating these systems exposes trade-offs that are easy to miss when using high-level abstractions alone.
While I'm comfortable building full-stack applications, I'm increasingly drawn toward systems programming, embedded software, AI infrastructure, and software that interacts closely with hardware or runtime constraints.
Right now I'm focused on strengthening my understanding of Full-Stack Devlopment operating systems, networking, embedded software, and machine learning internals while continuing to build projects that expose how these systems behave under real-world constraints.
Currently Exploring
- ▹Operating systems and computer networking
- ▹Full-Stack Devlopment
- ▹Building ML systems from first principles
- ▹Real-time software
02. Core Skills
Languages
- C
- Python
- TypeScript
- Java
- C++
- SQL
Web & Backend
- Next.js
- React
- Node.js
- Express
- FastAPI
AI & Machine Learning
- Neural Networks
- NumPy
- RAG
- Vector Search
- LLM APIs
Databases
- PostgreSQL
- MongoDB
- SQLite
- MySQL
- Qdrant
Systems & Infrastructure
- Linux
- Docker
- Git
- REST API Design
- Embedded Systems
Systems Concepts
- Game Loops
- Physics Simulation
- State Machines
- Collision Detection
- Real-Time Systems
03. Selected Projects
System Context
Road accidents often leave victims unable to call for help, delaying emergency response. A lightweight, low-cost system was needed to automatically detect potential accidents and notify emergency contacts.
Architectural Solve
Developed the ESP8266 firmware, hardware integration, and FastAPI backend for an IoT-based smart helmet that detects abnormal acceleration using an MPU6050 sensor, provides a cancellation window, and automatically sends emergency email alerts with live location and contact information.
Impact
Built a complete IoT-to-cloud workflow integrating embedded hardware, wireless communication, backend APIs, and a mobile application, demonstrating real-time emergency alert capabilities during a hackathon.
Observation
Reliable IoT systems require careful coordination between embedded devices, mobile apps, backend services, and network communication. Hardware reliability and graceful failure handling are just as important as software architecture.
System Context
High-level ML frameworks hide how backpropagation, gradient flow, and memory usage actually work, making it difficult to reason about performance and correctness.
Architectural Solve
Implemented a scalar-based automatic differentiation engine and built a small neural network framework on top of it, including forward/backward passes, activation functions, and optimizers.
Impact
Gained a concrete understanding of computational graphs, gradient propagation, and why matrix operations dominate ML performance.
Observation
Most ML performance gains come from optimizing data layout and matrix operations, not from model architecture tweaks.
System Context
LLMs tend to hallucinate when answering technical or domain-specific questions without access to verified context.
Architectural Solve
Built a Retrieval-Augmented Generation pipeline using vector embeddings stored in Qdrant and query rewriting ensuring responses are grounded in retrieved documents.
Impact
Improved answer reliability for technical queries by prioritizing retrieval quality over raw model capability.
Observation
Good retrieval and clean data matter more than larger models for accuracy.
System Context
I wanted to build a small arcade-style game while staying close to the code, instead of relying on a full game engine with heavy abstractions.
Architectural Solve
Built a 2D arcade game in Python using Pygame, implementing my own game loop, physics updates, collision handling, and state management.
Impact
The project helped me understand how real-time systems behave when timing, physics, and input handling are managed manually.
Observation
Simple games are a great way to learn real-time loops, state machines, and physics without the overhead of a full engine.
System Context
I wanted to build a modern blogging platform that goes beyond basic CRUD by leveraging Next.js 14’s Server Components and hybrid rendering architecture for performance and scalability.
Architectural Solve
Built a full-stack blog platform using Next.js 14 (App Router), MongoDB, and NextAuth with Google OAuth, implementing React Server Components for server-side rendering, client components for interactivity, pagination for scalability, and optimized database queries using Mongoose lean().
Impact
The project helped me deeply understand hybrid rendering, authentication flows, server/client component boundaries, database optimization, and how modern full-stack React applications are architected for performance and SEO.
Observation
Modern web apps require thoughtful separation between server and client logic, efficient database querying, authentication handling, and performance-first architecture decisions rather than just building features.
System Context
I wanted a structured way to store and organize my reading notes instead of keeping scattered summaries across notebooks and random documents.
Architectural Solve
Built a full-stack web application using Node.js, Express, and PostgreSQL that allows users to add, edit, delete, categorize, search, and sort book notes, with authentication via Google OAuth and local strategy.
Impact
The project strengthened my understanding of backend architecture, authentication systems, database design, and MVC structuring in real-world applications.
Observation
Building a full-stack CRUD application with authentication taught me how real-world systems handle user sessions, database relationships, secure auth flows, and clean project structuring.
04. Engineering Philosophy
Fundamentals First
Frameworks change quickly. Core concepts like algorithms, memory, and data flow do not. I focus on understanding the fundamentals so tools become interchangeable.
Abstractions Leak
Frameworks are useful, but understanding what's happening underneath makes debugging, optimization, and design decisions much easier.
Build to Understand
Reimplementing systems from scratch exposes edge cases, trade-offs, and constraints that tutorials often hide.
"The most powerful tool in an engineer's arsenal is not a specific language or framework, but the ability to learn deeply and build with precision."