Projects
A collection of things I've built, from web applications to creative experiments.
GitResume: Where Your Code Becomes Your Resume
GitResume is a production-ready web application designed to automatically generate professional, ATS-optimized resume content directly from a developer's GitHub repositories. By simply providing a repository URL, users can leverage AI to analyze their codebase, identify key technical achievements, and produce impactful, data-driven narrative sections for their resumes. CORE FEATURES & FUNCTIONALITY 1. AI-Powered Content Generation: At its core, GitResume uses AI models to transform repository data into compelling resume sections. This includes a project title, a list of technologies, and achievement-focused bullet points. 2. Intelligent Code Analysis: The application clones a user's repository and uses the tree-sitter library to parse the code, identify the tech stack, analyze the structure, and extract key metrics like function and class counts. 3. Job Description Tailoring: Users can input a job description to generate resume content that is specifically tailored to the requirements of the role, integrating relevant keywords naturally. 4. In-depth Project Insights: Beyond bullet points, the tool generates additional notes on technical setups, future plans for the project, and potential advancements. 5. Interview Preparation: To help users prepare for interviews, the application generates a list of potential technical and behavioral questions based on the repository's content, complete with comprehensive answers. 6. Real-time Streaming UI: The generation process is streamed to the user in real-time via WebSockets, showing the current status from cloning and analyzing to generating the final output. 7. Secure GitHub Authentication: Users can log in via GitHub OAuth to securely analyze their private repositories. TECHNICAL ARCHITECTURE & STACK 1. Backend: The application is built with FastAPI and Python 3.11. It handles user authentication, repository analysis, and communication with AI services. The backend also features robust error handling and logging. 2. Frontend: The user interface is rendered using Jinja2 templates and styled with Tailwind CSS (via CDN) for a clean, retro-modern aesthetic. The frontend is designed to be responsive and accessible. 3. AI & Code Analysis: * AI Providers: Modular support for multiple AI providers including Gemini, OpenAI, Groq, and Claude, which can be configured via environment variables. * Code Parsing: Leverages Tree-sitter for efficient and accurate parsing of various programming languages to identify the tech stack and code structure. * Grammar Correction: An integrated AI-powered grammar check ensures the generated text is polished and professional. 4. Caching & Performance: Redis is used for session management and rate limiting to ensure the application is scalable and performant. 5. Containerization: The entire application is containerized using Docker with a multi-stage build process for a minimal and secure production image, served by Uvicorn.
Finance Manager: From Concept to Container
Finance manager is a comprehensive and secure personal finance management application from the ground up. The goal was to create a tool that is not only functional but also intuitive and user-friendly, allowing users to take full control of their financial lives. This application is a testament to my skills in full-stack development, database management, and building secure, scalable web applications. CORE FEATURES & FUNCTIONALITY The Finance Manager is packed with features designed to provide a complete financial overview: 1. Interactive Dashboard: The heart of the application, the dashboard offers an immediate snapshot of the user's financial health. It displays key metrics like total income, expenses, and current balance, along with a chart visualizing income vs. expenses over time and a list of recent transactions. 2. Seamless Transaction Management: Users can effortlessly add, edit, and delete income and expense records. The transaction forms are designed for a smooth user experience, with options for advanced details like payment methods, tags, and notes. 3. Intelligent Budgeting System: The application features a robust budgeting system where users can set monthly budgets for different expense categories. Progress bars and visual cues provide instant feedback on spending, helping users stay on track. 4. In-Depth Financial Reporting: The reports section offers a deep dive into the user's financial data. With dynamic charts, users can analyze monthly trends, break down spending by category and payment method, and even get a cash flow projection. 5. Personalized User Experience: Users can customize the application to their liking, with support for light and dark themes, multiple currencies, and custom date formats. TECHNICAL ARCHITECTURE & STACK I chose a modern and robust tech stack to build this application, ensuring it is both scalable and maintainable: 1. Backend: The application is powered by Python and the Flask web framework. I designed a clean and modular application structure, with a focus on security and performance. The backend handles user authentication, data processing, and serves a RESTful API for the frontend. 2. Database: I used MongoDB as the database, which is a perfect fit for the flexible data structures of financial transactions. I leveraged PyMongo for seamless integration with the Flask application. 3. Frontend: The user interface is built with HTML, CSS, and JavaScript, and styled with the Bootstrap 5 framework for a responsive and modern design. I used Chart.js to create the dynamic and interactive charts that are a core part of the reporting features. 4. Deployment: The entire application is containerized using Docker and Docker Compose, which allows for easy and consistent deployment across different environments. The application is served by Gunicorn, a production-ready WSGI server, ensuring it can handle a high volume of requests. SECURITY CONSIDERATIONS Security was a top priority throughout the development process. I implemented several security measures to protect user data: 1. Secure Authentication: User passwords are not stored in plaintext. Instead, they are hashed using bcrypt, a strong and widely-trusted password hashing algorithm. 2. Rate Limiting: To prevent brute-force attacks on the login and registration pages, I implemented rate limiting using the Flask-Limiter library. 3. Secure Sessions: The application uses secure, HttpOnly session cookies to protect against cross-site scripting (XSS) attacks. 4. Admin Privileges: The application includes a secure admin system for user management. Sensitive admin actions, like granting or revoking admin rights, require password confirmation for an extra layer of security.
Smart AC Control: An End-to-End IoT Solution
This project, developed for an internship at Ellipsis Infotech, is a complete IoT ecosystem for centralized air conditioning control in workspaces. The system allows multiple AC units to be controlled remotely through a unified dashboard, enabling efficient climate management across large workspaces. CORE FEATURES & FUNCTIONALITY The AC Control system is packed with features designed to provide a complete and seamless user experience: 1. Real-time Dashboard: The dashboard provides an at-a-glance overview of the entire AC system, including key statistics like total devices, online devices, active devices, and configured zones. 2. Device Management: Users have full control over individual AC units, with the ability to turn them on or off, and adjust the mode, temperature, and fan speed. 3. Zone Control: To simplify management, devices can be grouped into zones based on their location, such as "Living Room" or "Upstairs". 4. Batch Operations: The system supports batch operations, allowing users to control multiple devices at once, even across different zones. 5. Secure Authentication: User accounts are protected with JWT-based authentication to ensure that only authorized users can access the system. TECHNICAL ARCHITECTURE & STACK The system is comprised of three main components: a FastAPI backend, a Next.js frontend, and ESP8266 firmware. 1. Backend: The backend is built with FastAPI, a modern Python web framework, and uses SQLAlchemy for asynchronous database operations with a PostgreSQL database. It handles user authentication, device management, and real-time communication via WebSockets and MQTT. 2. Frontend: The frontend is a responsive web application built with Next.js, React, and TypeScript. It uses Tailwind CSS for styling and Shadcn/ui for its component library, providing a modern and intuitive user interface. The application is deployed on Vercel. 3. Firmware: The firmware for the ESP8266-based IoT devices is built using the Arduino Framework and PlatformIO. It uses an IR LED to send commands to the AC units and communicates with the backend via MQTT. The firmware also supports Over-the-Air (OTA) updates for remote maintenance. SECURITY CONSIDERATIONS Security was a key consideration in the design of this system: 1. Secure Communication: The system uses MQTT over TLS and JWT authentication to secure communication between the frontend, backend, and IoT devices. 2. Device Authentication: Each device has a unique secret key for authentication with the backend. 3. Password Security: User passwords are not stored in plaintext; instead, they are hashed using bcrypt. SYSTEM CAPABILITIES 1. Multi-tenancy: The system is designed to support multiple customers or organizations. 2. Scalability: The backend is deployed on Google Cloud Run, which provides serverless auto-scaling to handle a high volume of requests. 3. High Performance: The use of asynchronous operations and optimized database queries ensures a responsive and efficient system.
Cansat India: Real-Time Data Visualization & Control System
For the Cansat India competition, I developed a comprehensive, desktop-based ground control station to provide real-time data visualization, mission control, and post-flight analysis. My goal was to create a robust and high-performance system to ensure we had complete oversight and control of our CanSat from launch to recovery. Here’s a breakdown of how I built it and what I achieved. CORE MISSION: REAL-TIME INSIGHT AND CONTROL The primary challenge was to process a continuous stream of telemetry data from our CanSat's hardware and present it in an intuitive, actionable desktop application. I engineered the system to feature a live dashboard with dynamic charts and gauges, a command interface for mission-critical events, and a robust data logging mechanism for post-flight analysis. ARCHITECTING THE APPLICATION WITH PYTHON & PYQT5 I chose Python for its powerful data handling libraries and built the entire ground control station as a desktop application using the PyQt5 framework. This approach allowed for a highly responsive user interface and direct access to the system's serial ports for hardware communication. 1. Bridging Hardware and Software: I wrote a dedicated serial_handler module using the pyserial library to interface directly with our ground station's hardware. This module runs in a background thread, continuously listening for incoming data packets. To safely update the GUI from this background thread, I used PyQt5's signal and slot mechanism, ensuring the application remained responsive and thread-safe. 2. Command Handling: Sending commands back to the CanSat was a critical feature. I implemented functions in the GUI that, when triggered by button clicks in the mission control panel, would write commands directly to the serial port via the serial_handler, enabling us to trigger events like payload deployment remotely. 3. Robust Data Logging: For post-mission analysis, I created a data_handler module. Every piece of telemetry received is timestamped and appended to a mission-specific CSV file. For post-flight analysis, I integrated pandas for data manipulation and matplotlib to generate and display summary plots directly within the PyQt5 application, which was invaluable for our flight reports. CRAFTING AN INTUITIVE DESKTOP GUI WITH PYQT5 The entire user interface, from windows and buttons to live charts, was built using PyQt5's rich set of widgets. This allowed me to create a native desktop application that felt fast and reliable. 1. Live Data Visualization: I developed a custom dashboard with real-time data visualizations. I used graphing libraries compatible with PyQt5 (like Matplotlib's Qt backend or a dedicated Qt charting library) to create dynamic line graphs for telemetry like altitude and pressure, and custom widgets to act as gauges for instantaneous readings. 2. GPS Tracking Map: To visualize the CanSat's position, I integrated a mapping widget capable of displaying GPS coordinates on a map, which updated in real-time as new data came in. 3. Mission Control Interface: I designed a simple but effective mission control panel within the application where team members could send predefined commands with a single click. The interface provided immediate feedback on command transmission status. ACHIEVEMENTS & OUTCOMES This project was a significant achievement in building a complete, real-time IoT application with a sophisticated desktop GUI. I successfully bridged the gap between raw hardware data and a high-performance user interface. The system provided our team with the critical tools needed for a successful Cansat mission: live monitoring, remote control, and detailed data analysis, all within a self-contained and reliable desktop application.
Ground Station and Telemetry System for Model Satellite Competition
This project is a comprehensive ground station and telemetry system designed for the Teknofest 2024 Model Satellite Competition. It features a ground station GUI developed with PySide6 for real-time data visualization and a Raspberry Pi-based satellite system for collecting and transmitting telemetry data. The system monitors crucial flight data, including altitude, pressure, temperature, and GPS coordinates, while also providing a 3D visualization of the satellite's orientation. Key Features: 1. Real-time Data Visualization: The ground station displays live telemetry data through various graphs and line edits, allowing for immediate analysis of the satellite's performance. 2. Interactive Map: A Folium-powered map tracks the satellite's GPS location in real-time, plotting its trajectory with a polyline. 3. 3D Orientation Display: A VTK-based widget provides a 3D visualization of the satellite's orientation (roll, pitch, and yaw), offering a more intuitive understanding of its behavior. 4. CSV Data Simulation: A separate GUI tool allows for simulating telemetry data from a CSV file, enabling thorough testing of the ground station's functionality without a live satellite connection. 5. Data Logging: All incoming telemetry data is logged to a CSV file for post-flight analysis and blackbox purposes. 6. Websocket Communication: The ground station and Raspberry Pi communicate via websockets, ensuring a reliable and real-time data link. Technologies Used 1. Backend: * Python: The core language for both the ground station and the Raspberry Pi. * Raspberry Pi: The main computer of the science payload, handling sensor data acquisition and telemetry transmission. * Websockets: Used for real-time, bidirectional communication between the Raspberry Pi and the ground station. * Asyncio: Utilized for concurrent operations in the backend, particularly for handling websocket connections and sensor data streams. * Flask: Used to create a simple web server on the Raspberry Pi for streaming logs and media files. * Adafruit CircuitPython Libraries: Used for interfacing with various sensors like BMP390, TMP117, and BNO055. 2. Frontend (Ground Station): * PySide6: The core GUI framework used to build the ground station application. * Folium: Used for creating the interactive map visualization. * VTK (Visualization Toolkit): Employed for the 3D rendering of the satellite's orientation. * PyQtGraph: Used for plotting the real-time telemetry data in various graphs.
Flipkart GRID 5.0 Robotics Challenge – Autonomous Pick-and-Place System
Developed for the Flipkart GRiD 5.0 Robotics Challenge, this project tackles a critical bottleneck in modern logistics: the slow, costly, and error-prone nature of manual package sorting. To solve this, I engineered a fully autonomous robotic system designed to bring speed, accuracy, and efficiency to the warehouse floor. The solution is a "smart" 4-DOF robotic arm that intelligently identifies, classifies, and sorts packages without human intervention. The system's perception is driven by a sophisticated multi-camera setup: an Intel RealSense camera identifies the precise 3D location of packages, while a dedicated ESP32-CAM reads QR codes to determine their destination. The core intelligence comes from a custom-trained YOLO AI model, which enables rapid and reliable detection. To translate this visual data into action, I developed an inverse kinematics algorithm that calculates the exact joint movements for the robotic arm, allowing it to handle packages with fluid precision. This entire process is orchestrated through a central Python application that communicates with an Arduino Mega for low-level hardware control, all running seamlessly in real-time thanks to a multi-threaded architecture. The result is a complete, end-to-end automated sorting system that demonstrates a powerful integration of AI, computer vision, and robotics. CORE FEATURES 1. AI-Powered Vision: Utilizes custom YOLO models for rapid and accurate package and QR code detection. 2. 3D Robotic Control: Combines 3D depth perception with inverse kinematics for precise package handling. 3. End-to-End Automation: A complete, hands-off system from package identification to final sorting. 4. Real-Time Performance: Built with multi-threading to operate seamlessly in a live logistics workflow. CODE BREAKDOWN 1. main.py (The Conductor): The central script that initializes all components and uses threading to manage concurrent operations from the cameras and the robotic arm. 2. object_detector.py (The Eyes): A wrapper for the YOLO model. It loads the pre-trained .pt files and performs detection on image frames, returning the coordinates of detected objects. 3. inverse_kinematics.py (The Brains of the Arm): Contains the core logic for robotic control. It uses trigonometric calculations to convert the target's (x, y, z) coordinates into the specific angles required for the arm's joints. 4. arduino_communication.py (The Nervous System): Establishes a serial connection to the Arduino and sends the calculated joint angles in a formatted string. 5. ARDUINO/ARDUINO.ino (The Muscle): The C++ code on the Arduino that listens for serial data, parses the angles, and commands the servo motors to execute the movement.
IMDb & TMDb Movie Scraper
This project is a sophisticated data scraping tool built in Python to systematically gather comprehensive information about movies and TV series from IMDb. To create a richer and more complete dataset, the scraper intelligently enriches the initial IMDb data by fetching detailed metadata from The Movie Database (TMDb) API. The final, cleaned data, containing everything from titles and ratings to budgets, cast, and crew, is then exported into structured JSON and CSV files for easy analysis and use. The core of the project is built upon the powerful and flexible Scrapy framework, which manages the scraping workflow. To handle IMDb's dynamic, JavaScript-heavy web pages and ensure all content is loaded correctly, the scraper utilizes Selenium to automate a web browser. Once the initial movie data is collected, the script makes concurrent API calls to TMDb using the Requests library, fetching a wealth of additional information. This dual-source approach ensures the final dataset is far more detailed than what could be obtained from a single source. The project features two distinct spiders to demonstrate both foundational and advanced scraping techniques. The basic_scrapper provides a straightforward implementation for smaller-scale tasks. The advance_scrapper is engineered for high-performance, large-scale data collection. It employs Python's concurrent.futures.ThreadPoolExecutor to run multiple browser instances in parallel, dramatically increasing scraping speed. This advanced version also includes a robust task management system using a queue to process scraping jobs by year and month, along with resilient error handling and automatic retries, making it a powerful tool for building large datasets efficiently and reliably.
Tasmota MQTT Smart Bulb Dashboard
This project is a self-hosted Progressive Web App (PWA) that provides a modern and intuitive interface to control Tasmota-flashed smart bulbs in real-time. It features a responsive dashboard for instant control over your smart lighting, including power, color temperature, RGB color, and brightness. The application is secured with API key authentication and is designed for easy one-click deployment on Vercel, offering a native-like experience on both desktop and mobile devices. The backend is built with Express.js and TypeScript, establishing a secure connection to an MQTT broker to communicate with the Tasmota-flashed smart bulb. It listens for real-time state changes using Tasmota's stat/, tele/, and discovery topics and publishes commands to the cmnd/ topic. The backend also serves the frontend and provides a simple, authenticated API for the client. For robust and type-safe validation of all incoming API requests, Zod is used, and structured logging is handled by Winston. The frontend is a responsive, mobile-first single-page application built with Tailwind CSS and vanilla JavaScript. It communicates with the backend via a simple API and uses a service worker for PWA functionality and offline asset caching. The UI dynamically updates based on the latest device state received from the backend, providing real-time information at a glance including IP address, hostname, firmware version, Wi-Fi signal strength, and more. KEY FEATURES: * Real-Time Control: Instantly syncs with your bulb's state using an efficient MQTT-first approach, backed by HTTP polling. * Full Power Control: Toggle the bulb on or off with a responsive button. * White Ambiance: Fine-tune color temperature from warm (153 mired) to cool (500 mired). * RGB Color Selection: An intuitive hue and saturation slider lets you pick the perfect color. * Brightness Dimmer: Adjust brightness levels from 0% to 100%. * Secure Authentication: Protects your dashboard with a mandatory API key. * PWA-Compatible: Install it as a standalone app on desktop or mobile for a native-like experience with offline support. TECHNOLOGIES USED: * Backend: Node.js, Express.js, TypeScript, MQTT.js, Zod, Winston, dotenv, cors. * Frontend: HTML, Tailwind CSS, Vanilla JavaScript. * Deployment: Vercel. * Others: Git, npm.
Flask & MongoDB User Management API
This project is a robust and scalable RESTful API designed for user management, built with Python's Flask framework and a NoSQL MongoDB database. It provides a complete set of endpoints for all essential CRUD (Create, Read, Update, Delete) operations, forming a solid backend foundation for any modern web application that requires user data handling. The API is containerized using Docker, ensuring consistent and reliable deployment across different environments. CORE FUNCTIONALITY & TECHNICAL IMPLEMENTATION The application is architected with a clear separation of concerns, making it maintainable and easy to understand. * Application Entry Point & Configuration: The application is served by a production-ready WSGI server. A central configuration point initializes the Flask application and its extensions for database integration and security. This setup also establishes a robust logging system for both development and production environments. Configuration is managed securely through environment variables, a best practice for handling sensitive data. * API Endpoints: The routing logic is neatly organized within Flask Blueprints, defining all the public-facing API endpoints for user operations. This includes routes for fetching all users, creating a new user, and performing specific actions like retrieving, updating, or deleting a single user. This layer is responsible for handling incoming request data, validating it, and returning appropriate JSON responses. * Business Logic: A dedicated service layer encapsulates the core business logic and interaction with the database. It contains functions that handle the specifics of creating a user (including checking for existing emails and hashing passwords), fetching user data (while excluding sensitive information), updating records, and deleting users. This separation keeps the API routing layer clean and focused on handling HTTP requests. * Containerization: The project is fully containerized using Docker, which creates a lightweight and efficient image for the application. This setup installs all necessary dependencies and configures the environment, making the API incredibly easy to deploy, run, and scale consistently across any system. TECHNOLOGIES USED * Backend: Python, Flask * Database: MongoDB (with Flask-PyMongo) * Deployment: Docker, Waitress (WSGI Server) * Security: Flask-Bcrypt for password hashing * Others: python-dotenv for environment management, Centralized Logging This project demonstrates a strong understanding of backend development principles, including API design, database management, security best practices, and modern deployment workflows.