Engineered for
Performance

Portfolio

My Portfolio is a premium, highly interactive full-stack web application—and the very platform you are currently exploring—engineered to serve as a dynamic digital showcase of my professional engineering capabilities. Built with a sleek, dark-themed aesthetic and fluid motion design, the architecture completely decouples the user interface from the content. It leverages a real-time cloud database to power dynamic updates seamlessly across the entire site, ensuring the platform operates as a highly scalable, living document of my work without requiring manual code deployments. Key Highlights of the Project: - Modern Tech Stack: Developed on a robust Next.js 16 (App Router) architecture, utilizing Tailwind CSS (v4) for responsive utility-first styling, and Nodemailer for secure contact form handling. - Dynamic Data Integration: Powered by Firebase Firestore for real-time content fetching, driving everything from the interactive skills cloud to dynamic project rendering completely behind the scenes. - Advanced Motion & UI/UX: Engineered with GSAP and Framer Motion to deliver complex page transitions, custom scroll tracking, floating navigation, and interactive lightbox media viewers across all device viewports. Ultimately, this portfolio is a production-grade application that reflects my core engineering philosophy: writing clean, highly reliable code that makes complex systems efficient, simple, and visually engaging.

iStars

iStars is a custom-built, full-stack web application designed as a private digital time capsule and portfolio piece for a close-knit group of computer science students (Batch of 2023-2026). The platform serves two main purposes: securely preserving the group's college memories (photos and videos) and showcasing their web development skills to the world. While the public can view the landing page and member profiles, the core media archive is protected by a custom authentication system, ensuring that private data remains strictly accessible only to the iStars members. Key Highlights of the Project: - Modern Tech Stack: Built using a robust, modern ecosystem including Next.js (v16), TypeScript, Tailwind CSS (v4.1), and MongoDB Atlas. - Advanced Media Handling: Features a direct-to-drive media storage system utilizing the Google Drive API. It includes a custom bulk media upload engine with auto-orientation detection and lazy-loaded pagination. - Security & Admin Controls: Secured via JWT and bcryptjs, the platform includes a comprehensive, hidden admin dashboard. Admins can manage users, track application logs, handle CRUD operations for all media categories, and manage encrypted site secrets. - Engaging UI/UX: Integrates libraries like GSAP, Framer Motion, and Lenis to deliver smooth scrolling, dynamic animations, and an interactive "Bento-box" layout for media galleries. Ultimately, iStars is a production-grade memory vault that elegantly blends nostalgic purpose with advanced web engineering.

Mechanical Store Management System

Mechanical Store Management System (built for Sreenarayaneeyam Engineering Works) is a comprehensive, on-premise desktop application engineered to streamline the daily administrative and operational workflows of a mechanical or engineering business. Designed to run locally as a standalone executable, it centralizes crucial business data into a single, intuitive interface, replacing scattered spreadsheets or paper records with a structured digital system. Key Highlights of the Project: - Robust Desktop Architecture: Built using Electron.js to deliver a native desktop application experience, paired with React, TypeScript, and Tailwind CSS for a modern, responsive frontend. - End-to-End Business Management: Features a deeply structured modular dashboard that handles all core operations: People (Clients, Employees, Suppliers), Inventory tracking (Materials, Products), and full lifecycle Transactions (Services, Billing, Deliveries). - Automated Reporting: Includes built-in analytics capabilities to generate structured weekly, monthly, and yearly business reports, aiding in financial tracking and strategic decision-making. - On-Premise Data Security: Utilizes a local MongoDB database instance rather than cloud storage. This architecture ensures that all sensitive business, employee, and client data remains strictly on the company's local hardware, providing maximum data privacy and absolute independence from internet connectivity. Ultimately, this project serves as a complete digital transformation tool for a traditional engineering workspace, packaging enterprise-grade management features into an easily deployable desktop .exe file.

Tuition App

Tuition App is a beautifully crafted, offline-first mobile application designed as a comprehensive administrative powerhouse for independent tutors and small tuition centers. The platform serves as an all-in-one hub to streamline daily academic operations: from robust student directory management and dynamic fee ledger tracking to academic calendar organization. While it operates primarily with lightning-fast local data for seamless offline usability, it is fortified by an on-demand cloud synchronization engine, ensuring that critical financial and academic records are safely backed up and instantly retrievable. Key Highlights of the Project: - Modern Tech Stack: Built using a robust cross-platform ecosystem including Flutter (v3.12.1+), Dart, Riverpod for immutable state management, Isar NoSQL for local caching, and Supabase for cloud infrastructure. - Offline-First Architecture: Features a lightning-fast, local-first database orchestration that allows for seamless batch filtering and zero-lag context switching, coupled with a manual Supabase sync engine for remote cloud updates. - Comprehensive Administration: Includes dynamic fee ledgers with custom base amounts, sibling group management for combined billing, and a highly optimized tournament module for tracking honour points and academic competitions. - Engaging UI & Integrations: Engineered with a premium Material 3 design system, custom native-to-Flutter splash screens, predictable background notifications, and an automated WhatsApp integration that deeply links beautifully formatted fee receipts. Ultimately, Tuition App is a production-grade management solution that elegantly blends the daily needs of independent educators with advanced, offline-first mobile engineering.

Tuition Web

Tuition Web is a real-time, highly responsive web portal and public leaderboard dashboard designed as the live, public-facing companion to My Tuition App. The platform serves as an interactive hub for students, parents, and educators to instantly access live academic standings, tournament rankings, and detailed honour point breakdowns. Operating as a highly optimized, read-heavy display interface, the portal ensures absolute data integrity by strictly restricting all write operations and data mutations to authorized mobile app syncs and authenticated server routes. Key Highlights of the Project: - Modern Tech Stack: Built on a cutting-edge web ecosystem featuring Next.js 16 (App Router with Turbopack), React 19, TypeScript (v5+), and Tailwind CSS (v4). - Live Data & Caching Engine: Powered by a direct Supabase integration for real-time data fetching, featuring a dedicated on-demand cache revalidation endpoint (/api/revalidate) that instantly refreshes web pages the moment new data is synced from the Flutter application. - Dynamic Leaderboards: Showcases interactive, animated top-3 podiums for weekly and overall tournaments, detailed honour point breakdown modals, and academic standings filterable by class and semester. - Engaging UI/UX: Engineered for a seamless user experience with full Material-inspired dark and light mode switching (via next-themes), fluid component animations using Framer Motion, and mobile-optimized slide-out filter drawers. Ultimately, Tuition Web is a high-performance, production-grade portal that elegantly transforms complex backend academic data into an engaging, competitive, and accessible public dashboard.

Ninja Dodge

Ninja Dodge is a fast-paced, 2D arcade survival game built entirely with Python and Pygame, designed to test player reflexes and algorithmic difficulty scaling. The application challenges players to control a ninja and survive an endless barrage of incoming kunai knives. As the player's score increases, the game's internal engine dynamically ramps up the difficulty, altering the speed, spawn rate, and trajectory of the obstacles to create a progressively intense and engaging survival experience. Key Highlights of the Project: - Core Tech Stack: Developed natively in Python using the Pygame library, featuring a clean, modular project architecture that separates game logic, entity classes (Character.py, Kunai.py), and asset management. - Dynamic Difficulty Engine: Engineered a progressive scaling system that automatically increases obstacle velocity, spawn frequency, and attack patterns (including horizontal trajectories) based on real-time score tracking. - Advanced Collision & Animation: Utilizes Pygame's mask collision system for pixel-perfect hitbox detection, paired with custom, multi-state sprite animations for seamless running, jumping, idling, and dying actions. - Accessible Deployment: Distributed as a compiled, standalone Windows executable (.exe) for frictionless, plug-and-play use, complete with full audio integration and an in-game mute toggle. Ultimately, Ninja Dodge is a polished, highly interactive project that highlights a strong command of object-oriented Python, real-time game loop management, and precise state handling.

Word Seach

Word Search is a highly interactive, browser-based puzzle game engineered using modern front-end web technologies to modernize the classic hidden-word mechanic. The application challenges players to identify and track hidden words within a dynamic letter matrix. It serves as an excellent demonstration of complex grid-based algorithmic logic, interactive state management, and custom puzzle generation within a modern Next.js ecosystem. Key Highlights of the Project: - Modern Tech Stack: Built on a robust Next.js 16 (App Router) architecture, utilizing TypeScript for strict data typing, Tailwind CSS (v4) for responsive styling, and Framer Motion for fluid UI animations. - Algorithmic Grid Generation: Features custom internal algorithms (GameCreationAlgorithm.ts, GenerateWords.ts) capable of dynamically rendering and scaling puzzle grids across multiple difficulty levels. - Custom Puzzle Engine: Empowers users to step outside standard gameplay by creating highly personalized word search puzzles using their own custom word lists. - Engaging UI/UX: Engineered with a fully responsive, touch-friendly board that allows players to directly select hidden words across both desktop and mobile screens, paired with real-time word tracking state management. Ultimately, this Word Search application is a polished, engaging front-end project that highlights a strong command of algorithmic grid generation, interactive React concepts, and responsive utility-first design.

Wordle (Nextjs)

Wordle is a highly responsive, browser-based implementation of the popular word-guessing game, engineered entirely using modern front-end web technologies. The application challenges players to deduce a hidden five-letter word within six attempts. It serves as a clean, interactive demonstration of advanced state management, dynamic UI rendering, and real-time user feedback within a modern React ecosystem. Key Highlights of the Project: - Modern Tech Stack: Built on a cutting-edge web ecosystem featuring Next.js 16 (App Router), React 19, TypeScript (v5), and Tailwind CSS (v4). - Interactive Game Mechanics: Implements robust core logic featuring an automated evaluation engine that provides instant, color-coded visual feedback for correct, misplaced, and incorrect letter guesses. - Dynamic UI & Accessibility: Engineered with a fully responsive layout that includes an integrated on-screen keyboard, which maps seamlessly to physical keyboard events for a smooth experience across desktop and mobile devices. - Modular Architecture & Deployment: Hosted live via Vercel for immediate browser access, backed by a clean, component-driven project structure (Board.tsx, Keyboard.tsx, WordLine.tsx). Ultimately, this Wordle clone is a polished, front-end project that highlights a strong command of modern React concepts, strict TypeScript data typing, and responsive utility-first styling.

Task Manager API

Task Manager API is a robust, RESTful backend web service engineered to securely handle user authentication and streamline comprehensive task management workflows. Operating as a fully modular backend architecture, the application provides secure, authenticated access to task creation, tracking, and modification. It prioritizes data integrity and security by utilizing JSON Web Tokens (JWT) for session management and strict Pydantic schemas to validate data across all incoming API requests. Key Highlights of the Project: - Modern Backend Stack: Built natively with Python and FastAPI, leveraging SQLAlchemy for ORM-based database interactions and PostgreSQL for highly reliable, relational data storage. - Secure Authentication & Validation: Implements secure JWT-based authentication and bcrypt password hashing, paired with strict input validation and support for dynamic partial data updates. - Automated Background Processes: Engineered with a custom background lifespan worker designed to automatically detect and purge temporary sandbox accounts and stale tasks, ensuring continuous database optimization. - Interactive API Documentation: Automatically generates and serves interactive OpenAPI documentation via Swagger UI and ReDoc, enabling seamless developer onboarding and immediate endpoint testing. Ultimately, Task Manager API is a highly structured, production-ready backend service that highlights a strong command of modern Python API design, relational database modeling, and secure authentication flows.

Daily You

DailyYou is a native Android mobile application engineered to foster discipline and productivity by uniting task management, daily scheduling, and automated reminders into a cohesive, offline-first platform. Designed as a comprehensive personal performance tracker, the application seamlessly handles time-sensitive routines and alerts, ensuring users stay consistent with their daily goals without relying on a constant internet connection. Key Highlights of the Project: - Core Tech Stack: Developed natively in Kotlin, leveraging the modern Android Jetpack ecosystem—including Room, Fragments, and ViewBinding—paired with strict Material Design UI standards. - Advanced Background Services: Engineered a reliable background alert engine utilizing Android's AlarmManager and a custom BroadcastReceiver to trigger precise, time-bound system notifications with dynamic categorization. - Offline-First Architecture: Implements a robust local persistence layer using Room Database (SQLite abstraction) and custom type converters to securely store tasks, routines, and a comprehensive notification history log directly on the device. - State & Performance Tracking: Features custom tracking managers and SharedPreferences to dynamically monitor user completion metrics, translating raw task data into actionable, visual productivity analytics. Ultimately, DailyYou is a highly polished, production-ready mobile utility that showcases a strong command of the native Android lifecycle, background process management, and local database orchestration.

Sentiment Analysis on Movie Reviews

Sentiment Analysis on Movie Reviews is an end-to-end Data Science and Natural Language Processing (NLP) pipeline engineered to accurately classify raw text data into binary positive or negative sentiments. Originally developed in November 2025, the project processes a massive, balanced dataset of 50,000 IMDB records. It serves as a comprehensive demonstration of the full machine learning lifecycle, transitioning seamlessly from data preprocessing and feature extraction in a Jupyter Notebook to a modular Command Line Interface (CLI) built for real-time inference. Key Highlights of the Project: - Core Tech Stack: Built natively with Python and Scikit-Learn, featuring a robust data preprocessing engine that cleans raw HTML text and transforms it into over 450,000 numerical feature vectors utilizing unigram and bigram TF-IDF vectorization. - Algorithmic Performance: Trained and rigorously evaluated multiple classification algorithms, including Logistic Regression, Multinomial Naive Bayes, and Support Vector Machines. The LinearSVC achieved the highest performance, peaking at over 92% accuracy and a 0.92 F1-Score. - End-to-End Workflow: Implements a complete data science pipeline with an 80/20 data split, paired with comprehensive matplotlib visualizations for evaluating Accuracy, Precision, Recall, and F1-Scores across models. - Modular CLI Deployment: Extended beyond a standard exploratory notebook by packaging the machine learning pipeline into a modular Python application (main.py), allowing users to trigger on-demand model training, artifact exportation, and interactive terminal predictions. Ultimately, this Sentiment Analysis pipeline is a highly structured, production-minded project that highlights a strong command of NLP fundamentals, machine learning model evaluation, and modular Python software design.

Code Playground

Code Playground is a lightweight, distraction-free desktop code editor and execution environment engineered to streamline live coding events. Originally developed to eliminate the setup overhead of heavy, traditional IDEs during a fast-paced programming competition, the application provides a clean, unified interface for users to instantly write, highlight, and test Python, C, and C++ code. Key Highlights of the Project: - Core Tech Stack: Built entirely with Python and Tkinter, demonstrating the ability to construct responsive, standalone graphical user interfaces without relying on external web frameworks. - Custom Execution Engine: Features a robust background compilation system utilizing Python's tempfile and subprocess modules to seamlessly invoke local C/C++ compilers or Python interpreters, piping stdout and stderr directly back to the integrated UI console. - Dynamic UI/UX: Engineered with custom, regex-based syntax highlighting for keywords, strings, and comments, paired with synchronized live line numbers that scroll perfectly with the active text editor. - Frictionless Deployment: Packaged as a standalone, ready-to-run Windows executable (.exe) for true plug-and-play accessibility, ensuring participants can start coding immediately. Ultimately, Code Playground is a highly practical, solution-oriented tool that elegantly blends low-level background process management with a clean, user-centric design.

Movie Recommendation System

Movie Recommendation System is a machine learning web application engineered to deliver real-time, personalized movie suggestions through content-based filtering. The application serves as an interactive discovery platform that evaluates deep movie metadata—including genres, plot summaries, keywords, top cast members, and directors—to determine content affinity. Designed with an automated, end-to-end machine learning pipeline, the system handles everything from automated dataset ingestion and text feature engineering to similarity matrix computation and web delivery. Key Highlights of the Project: - Modern Python & ML Stack: Developed natively with Python (v3.13+) and managed via uv, leveraging Scikit-learn, Pandas, NumPy, and Joblib for high-performance data manipulation and serialized model storage. - Feature Engineering Pipeline: Combines and cleans unstructured metadata across multiple attributes (parsing JSON strings, extracting top 3 actors, and isolating directors) into dense, unified text feature tags. - Cosine Similarity Engine: Employs CountVectorizer to transform composite text tags into numerical vectors, computing a comprehensive pairwise Cosine Similarity matrix that reliably serves top-5 nearest-neighbor movie recommendations. - Self-Healing & Tested Architecture: Features a dynamic Streamlit UI with auto-complete search and responsive poster grids, backed by a self-healing startup routine that regenerates missing assets on cloud startup and a 100% test-covered pytest suite. Ultimately, this Movie Recommendation System is a production-grade machine learning project that highlights a strong command of NLP preprocessing, vector similarity computation, and robust data pipeline engineering.

Leaderboard (Nextjs)

Leaderboard is a highly interactive, retro-themed web application engineered to digitize and modernize tournament tracking and competitive rank management. Originally conceived to replace error-prone, manual paper tracking, the fully modernized platform serves as a production-ready utility for tournament organizers. It automatically computes match scores, processes custom tie-breakers, and dynamically sorts live standings, providing an engaging and error-free experience for live events. Key Highlights of the Project: - Modern Tech Stack: Built on a robust Next.js (App Router) and TypeScript architecture, featuring a vibrant, highly responsive retro UI developed entirely utilizing custom vanilla CSS tokens. - Advanced UI/UX Animations: Engineered with FLIP (First, Last, Invert, Play) layout transitions to seamlessly and smoothly animate team row swaps in real-time whenever leaderboard rankings shift. - Dynamic State Persistence: Features a robust JSON import and export engine, empowering users to download their complete tournament state (teams, stats, configurations) and instantly restore progress on demand. - Live Event Security: Implements strict algorithmic input validation to prevent duplicate team entries and score manipulation, alongside integrated browser refresh safety warnings to prevent accidental data loss during active matches. Ultimately, this Leaderboard application is a polished, highly engaging utility that highlights a strong command of complex state management, dynamic sorting algorithms, and fluid React animations.

BGMI - Points Calculator

BGMI Points Calculator is a lightweight, desktop-based graphical application engineered to automate leaderboard tracking and point calculations for competitive Battlegrounds Mobile India (BGMI) custom tournaments. Originally developed to manage a live collegiate esports event, the application replaces manual spreadsheet tracking with a streamlined, real-time interface. It allows tournament organizers to input post-match statistics on the fly, instantly computing complex scoring metrics and dynamically re-sorting the leaderboard. Key Highlights of the Project: - Core Tech Stack: Built entirely with Python and Tkinter, demonstrating the ability to construct custom, dark-themed standalone graphical user interfaces without relying on heavy web frameworks. - Algorithmic Scoring Engine: Integrates the official competitive scoring system, automatically calculating and aggregating placement points (from 1st to 40th rank) alongside total finish points (1 point per kill). - Dynamic Data Management: Features a complete local CRUD interface to register, edit, and delete participating teams, ensuring flexible roster management during high-pressure live events. - Accessible Distribution: Packaged and distributed as a standalone Windows executable (.exe) for frictionless, plug-and-play use by organizers, alongside open-source Python scripts for developers. Ultimately, the BGMI Points Calculator is a highly practical, solution-oriented utility that showcases a strong fundamental grasp of Python GUI development and automated data sorting.