This project involved designing and implementing an AI-powered skincare shopping validator called Facecart, built as a full-stack web application. The app guides users through a skin intake flow, generates personalized treatment strategies using OpenAI analysis, and employs a deterministic rules engine to validate conflict-free, budget-optimized product carts with external purchase links.

Key features include:

• Intake flow capturing skin descriptions, optional photo uploads, and yes/no questions for allergies and concerns.

• AI-generated skin profile covering sensitivity, oil production, inflammation risks, and treatment paths with previews.

• Deterministic scoring engine (0–100 compatibility) based on ingredients, conflicts, ratings, and user preferences.

• AM/PM routine builder, existing product conflict checks, refill predictions, allergy filtering, and budget optimization.

• Cart validation with swap/remove options, buy links, shopping list export, and accessibility features like high-contrast mode.

Through this project, core skills in full-stack development (React/Vite/TypeScript frontend, Node.js/Express backend), AI integration (OpenAI vision/text models with Zod), deterministic rule engines, local state management (localStorage), and privacy-focused UX design were reinforced in a practical e-commerce context.

This project involved designing and implementing a C++ program to analyze real-world red light camera violation data. The application reads data from a file, processes and stores it using custom CameraRecord classes, and computes key statistics, such as the total number of violations, records grouped by neighborhood, trends over different months, and searching for specific cameras by attributes. 

Key features include:

• Get an overview of total records, unique cameras, total violations, and most violations in a day.

• View violation statistics by neighborhood, with dynamic sorting to identify the most problematic areas.

• Visualize monthly trends using a simple bar chart.

• Search for specific cameras by intersection or neighborhood.

Through this project, core programming concepts like file I/O, class design, vector use, string manipulation, and data aggregation were reinforced in a practical context.​

Designed and implemented a menu-driven Library Database Management System using Python that interfaces with a MySQL database. This system supports core library operations through user-friendly functions including adding new books, registering borrowers, processing book checkouts and returns, and searching for books.

Key features include:

• Unique ID generation for books and borrowers.

• Displaying data from various database tables.

• Robust connection and transaction management using the mysql.connector Python library.

This project demonstrates practical skills in database design, SQL integration, and backend programming, showcasing a full-stack approach to managing library resources efficiently.

Developed a fully functional digital version of the Half-Gammon board game in C++, bringing classic turn-based gameplay to an interactive console environment. The application supports two-player matches, handling all aspects of board initialization, checker movement, dice rolling (using a Mersenne Twister random number generator for fairness), and real-time move validation. The game logic ensures correct enforcement of official Half-Gammon rules, including checker bumping, removal, and detailed win condition checks.

Key features include:

• Interactive menu for starting games, viewing the board, and executing moves.

• Automated dice rolls and piece movement driven by player turn.

• Input validation and user guidance throughout gameplay (e.g., highlighting illegal moves and available options).

• Efficient array-based tracking of game state and checkers for both players.

This project demonstrates proficiency in algorithm design, procedural logic, and array-based data management, and reflects practical skills in implementing complex rule-based systems as engaging software simulations.

Developed a t wo-player Connect Four game implementing a 6x7 grid where players alternate turns dropping colored discs (Red 'R' or Yellow 'Y') to connect four in a row vertically, horizontally, or diagonally. The program includes full game mechanics with input validation, real-time board display, win detection, and tie condition handling. Players can select columns to drop discs, and the game dynamically updates and checks for victory or draw after every move.

Key features include:

• Board initialization and display with clear visual structure.

• Input validation ensuring moves are within range and columns are not full.

• Efficient algorithms for detecting horizontal, vertical, and diagonal wins.

• Tie detection when the board fills without any player winning.

• User-friendly interface with prompts for player turns and move selections.

This project reinforced skills in 2D array manipulation, control flow logic, modular function design, and interactive console programming in C++.

Created a digital version of the Peg Game where users input three-letter moves to jump pegs and attempt to reduce the board to a single peg, signaling a win. The program manages the game state through individual peg variables representing positions marked as occupied ('T') or open ('.'). Valid moves are thoroughly checked for rules compliance using position relationships and adjacency.

Key features include:

• Board display representing the current state of all pegs.

• Comprehensive move validation enforcing legal jumps and capturing the peg logic accurately.

• User interaction loop accepting move inputs, validating them, executing moves, and checking for a win condition.

• Accurate management of peg states via getter and setter functions.

• Logical row and column mapping functions to translate peg characters into board positions.

This project demonstrates proficiency in state management, input validation, game logic implementation, and user interaction design within a console-based C++ application.

This interactive game is built using Python's turtle graphics library and challenges players to navigate a turtle on the screen to reach a randomly positioned target while managing limited attempts and score.

Key features include:

• Custom game window setup and colorful background using Python's turtle graphics.

• User inputs angles and distances to move the turtle; each move halves the score encouraging efficiency.

• Random target placement on screen requiring precise navigation.

• Win/loss conditions based on proximity to the target and score available.

• Animated heart shapes display as a reward upon winning.

• Detailed scoreboard displaying attempts and score in real-time.

This project highlights skills in graphical programming, user interaction design, control flow, and animation effects using Python’s turtle library. It showcases creativity combined with practical implementation of game mechanics.

This interactive graphical game simulates a virtual pizzeria where players can place and customize pizza orders through a series of fun and visually appealing screens.

Key features include:

• Multiple pizza dough options such as Thin crust and Thick crust, and a variety of toppings including Pepperoni, Pineapple, Green Peppers, Mushroom, Olives, and Cheese.

• Cheese options include Mozzarella, Cheddar, and Parmesan, allowing for a fully customizable order experience.

• Uses Python's turtle graphics to create an engaging interface with animated buttons and dynamic order display.

• Interactive buttons allow players to start the game, select dough, choose toppings, and place or pick up their order.

• Random pizza order generation to simulate real-world ordering scenarios, displayed clearly with textual and graphical elements.

• Visual enhancements through resized GIF images for buttons and toppings, creating an intuitive and attractive user interface.

• A celebratory final screen with colorful fireworks animations upon completing an order.

• Organized modular functions coordinating screen changes and user input handling to provide seamless game flow.

This project showcases skills in graphical user interface programming, event-driven interaction, image handling with PIL, and creative game design within Python. It demonstrates a multidisciplinary approach combining coding, graphics, and user experience design.