Engineered for
Performance

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.

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.

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.

Memory Cards

Memory Cards is a classic, interactive 2D puzzle game built entirely with Python and Pygame, engineered to test cognitive recall and real-time state management. The application challenges players to clear a dynamic grid by successfully identifying matching pairs of hidden cards. It serves as a clean demonstration of event-driven programming, randomized data structuring, and interactive user interfaces within a continuous game loop. Key Highlights of the Project: - Core Tech Stack: Developed natively in Python utilizing the Pygame library, featuring a clean, modular project architecture (Card.py, Game.py) that strictly separates individual card logic from main game rendering. - Dynamic Grid Generation: Engineered a randomized shuffle algorithm that dynamically distributes six matching pairs across a 12-card grid, ensuring unique puzzle states for every playthrough. - Interactive UI & Event Handling: Implements precise mouse-click detection and time-delayed flip mechanics to gracefully handle mismatch states, complemented by a custom main menu and post-game dialog boxes for seamless replayability. - Accessible Deployment: Packaged as a compiled, standalone Windows executable (.exe) for frictionless, plug-and-play accessibility, allowing users to experience the game without configuring a local Python environment. Ultimately, Memory Cards is a polished, highly interactive project that highlights a strong command of 2D game loop logic, event-driven user inputs, and object-oriented UI management.

Snake Game

Snake Game is a classic, console-based implementation of the retro arcade game, engineered entirely in C++ to run seamlessly directly within the Windows terminal. Originally developed as a quick side-project during a power outage, the application evolved into a rigorous exercise in low-level terminal rendering, continuous input tracking, and real-time game state management. It serves as an excellent demonstration of building continuous game loops without relying on external graphics engines. Key Highlights of the Project: - Core Tech Stack: Built natively in C++ utilizing the Windows API (<windows.h>) and <conio.h> for direct, low-level console manipulation and asynchronous keystroke tracking. - Advanced Console Rendering: Engineered a flicker-free visual engine using precise cursor positioning to update individual board coordinates, completely bypassing the visual stutter associated with traditional system("cls") terminal clearing commands. - Dynamic Time Management: Integrates the <chrono> library to construct a custom, time-based game loop, ensuring smooth frame rates and consistent movement speeds independent of the system's raw execution speed. - Engaging UI & Mechanics: Features a fully colored terminal interface utilizing ANSI escape codes, paired with classic arcade mechanics, collision detection (walls and self), and immediate reset functionality. - Accessible Deployment: Packaged as a compiled, standalone Windows executable (.exe) for frictionless, plug-and-play accessibility without requiring users to configure a local C++ compiler. Ultimately, this C++ Snake Game is a highly polished terminal application that highlights a strong foundational grasp of real-time memory management, custom game loops, and direct operating system API interactions.

User Management System

User Management System is a comprehensive full-stack web application engineered primarily to demonstrate and master backend authentication, middleware authorization, and Role-Based Access Control (RBAC). The platform serves as a functional dashboard for administrative user management. It features a robust, custom-built authentication system that strictly enforces dynamic routing and API protection, ensuring that sensitive data and administrative privileges—like modifying roles or toggling account statuses—remain securely isolated based on assigned user roles. Key Highlights of the Project: - Modern Full-Stack Ecosystem: Built bridging a React (Vite) and Tailwind CSS frontend with a Node.js, Express, and MongoDB Atlas backend, fully typed with TypeScript across the entire stack. - Secure Authentication & RBAC: Implements secure JSON Web Token (JWT) sessions and password hashing (via bcryptjs), driving a strict Role-Based Access Control engine that dynamically restricts backend endpoints and frontend navigation. - Comprehensive Admin Controls: Features a dedicated administrative interface allowing authorized users to seamlessly manage user states, perform full CRUD operations on system roles, and trigger cascading permission updates. - Protected Routing & UX: Utilizes custom React Router guards (ProtectedRoute) to prevent unauthorized access, complete with a specialized read-only demo mode for safe public deployment and testing. Ultimately, the User Management System is a practical, security-focused project that highlights a strong foundational grasp of full-stack integration, custom Express middleware, and robust API design.

AI Customer Support Chatbot

AI Customer Support Chatbot is a modern, full-stack web application engineered to demonstrate real-time conversational AI integration and automated support ticket generation. The platform serves as a functional customer support interface powered by Google Gemini. It focuses heavily on robust backend proxy architecture to secure API credentials, while utilizing optimistic UI updates to ensure a seamless, non-blocking user experience during asynchronous database writes. Key Highlights of the Project: - Modern Full-Stack Ecosystem: Built with a React (Vite) frontend featuring custom Glassmorphism CSS, backed by a Node.js and Express server, and integrated with Firebase Firestore for cloud persistence. - Real-Time AI & Summarization: Leverages the gemini-3.5-flash model to provide fluid conversational support and automatically generate structured ticket summaries—including issue categorization and priority assignment—upon chat completion. - Secure Proxy Architecture: Implements a dedicated Express proxy backend to safely orchestrate AI model requests, strictly preventing frontend API key exposure and ensuring secure data handling. - Optimized Data Persistence: Features asynchronous Firebase Firestore integration to silently save chat histories, metadata, and generated tickets in the background without interrupting the user interface. Ultimately, this AI Customer Support Chatbot is a highly polished project that highlights a strong command of LLM API integration, secure backend proxying, and responsive UI design.

Flappy Bird

Flappy Bird is a classic desktop arcade clone built entirely with Python and Pygame, engineered to replicate the highly addictive, physics-based mechanics of the original mobile game. The application challenges players to navigate a bird through an endless, dynamically generating obstacle course without hitting the boundaries or pipes. It serves as an excellent demonstration of real-time 2D rendering, continuous environment scrolling, and precise collision detection within a continuous game loop. Key Highlights of the Project: - Core Tech Stack: Developed natively in Python using the Pygame library, featuring a clean asset management structure that seamlessly integrates custom sprites, backgrounds, and game logic. - Advanced Collision Mechanics: Utilizes Pygame masks and fine-tuned hitboxes to ensure pixel-perfect collision detection between the player entity and the dynamically generated pipes. - Dynamic Game Environment: Engineered an infinite scrolling system with randomized pipe gap generation, ensuring that obstacle heights dynamically shift to make every playthrough unique. - Sprite Animation & State Management: Implements responsive sprite animations that alternate wing states (up, neutral, down) based on real-time movement and user inputs. - Accessible Deployment: Packaged as a compiled, standalone Windows executable (.exe) for frictionless, plug-and-play user accessibility, bypassing the need for local Python environment setups. Ultimately, Flappy Bird is a highly polished, nostalgic project that highlights a strong command of 2D game loop architecture, dynamic obstacle generation, and precise physical state management.

Fruit Ninja

Fruit Ninja is a fast-paced desktop clone of the classic arcade game, engineered entirely using Python and Pygame to deliver engaging, physics-based slicing mechanics. The application challenges players to maximize their score by slicing a variety of airborne fruits while strategically managing a three-heart life system and actively avoiding game-ending bomb obstacles. It serves as a strong demonstration of event-driven programming, entity physics, and real-time state management. Key Highlights of the Project: - Core Tech Stack: Developed natively in Python using the Pygame library, featuring a clean, object-oriented project structure (Fruit.py, Game.py) that strictly separates game loop rendering from individual entity logic. - Interactive Mechanics: Engineered fluid mouse-slicing mechanics utilizing click-and-drag event handling, paired with precise collision logic for instant hit detection on moving targets. - Dynamic Game Logic: Implements robust entity physics handling gravity and slicing states, alongside a scalable point system and immediate game-over triggers for obstacle interactions. - Accessible Deployment: Packaged as a standalone, ready-to-play Windows executable (.exe) for frictionless, plug-and-play accessibility, allowing users to play without configuring a local Python environment. Ultimately, Fruit Ninja is a fun, nostalgic project that highlights a strong grasp of 2D game loop logic, event-driven user inputs, and object-oriented physical state management.