Flutter, Dart, TMDb API, WebView, URL Launcher, SharedPreferences, Git, GitHub

DramaBuddy was inspired by my love for Korean Dramas and the need for a single, mobile first app to track, rate, and discover content. The goal is to make drama tracking fun, simple, and visually engaging.

Github Repo

Overview

DramaBuddy is a K-Drama tracking and discovery application built with a strong focus on clarity, usability, and mobile-first design. The app allows users to manage their watchlist, track viewing progress, and explore new content through structured metadata and social-inspired discovery.

The project is designed as a scalable product with future App Store release in mind.

What it does

DramaBuddy provides tools to help users manage their drama experience:

• Organize shows by Watching, Completed, and Planned
• Track episode progress per show
• Add private ratings and notes
• Discover dramas using curated metadata
• Explore trending drama-related content
• View a visual Monthly Wrapped summary

Screens

Core Experience

Discovery & Profile

Details & Insights

Product & Design Focus

DramaBuddy emphasizes:

• A minimal, iOS-inspired interface
• Clear information hierarchy
• Smooth navigation between sections
• Visual consistency across screens
• Thoughtful empty and loading states

The design prioritizes approachability and ease of use over complexity.

Technical Approach

The application is built using modern mobile development practices:

• Cross-platform development with Flutter
• Modular UI components for reusability
• External API integration for metadata
• Local persistence for user data
• Separation between presentation and data layers

Implementation details are intentionally abstracted at this stage.

Architecture Overview

DramaBuddy follows a layered architecture:

• Presentation Layer: Screens and reusable UI components
• Domain Layer: Models representing dramas and user state
• Data Layer: Services responsible for fetching and storing data

This structure supports maintainability and future feature expansion.

What I focused on

• Designing a product-ready mobile experience
• Balancing feature richness with simplicity
• Creating a foundation suitable for App Store deployment
• Thinking beyond a demo toward a real consumer app

Future Direction

Planned enhancements include:

• User authentication and cloud sync
• Smart recommendations
• Push notifications for new content
• Shareable viewing summaries
• App Store release

Acknowledgments

• Korean Drama Industry: For the creative work that inspired the product concept
• Flutter Ecosystem: For tools and open-source packages
• Mobile Design Community: For iOS UI and UX inspiration

Python, Flask, BeautifulSoup, Requests, HTML/CSS, Render

I developed this web-based educational vulnerability scanner to provide a safe and controlled environment for demonstrating common web security flaws. Built with Flask and Python, the tool allows users to scan predefined demo targets for vulnerabilities like SQL Injection (SQLi) and Cross-Site Scripting (XSS).

Live Demo

Github Repo

Inspiration

I wanted to create a hands-on tool that helps students and aspiring security researchers understand how vulnerabilities are detected at the code level. I realized that many people find “black-box” scanning intimidating, so I built this scanner to be transparent and ethical—restricting it to safe demo environments so users can learn without the risk of harming live production websites.

Demo

What it does

I designed the scanner to focus on the most common web-based attack vectors found in the OWASP Top 10:

• SQL Injection (SQLi) Detection: I implemented logic to identify forms that are susceptible to malicious SQL queries.
• Cross-Site Scripting (XSS) Scanning: The tool analyzes how web pages handle user-supplied data to detect potential script injection points.
• Target Verification: For safety, I built a verification system that restricts scans to predefined targets like “Juice Shop” or “Localhost.”
• Real-time Results: I created a clean, intuitive web interface that displays simulated vulnerability results immediately after a scan.

How I built it

• Core Logic: I wrote the scanning engine in Python, utilizing BeautifulSoup to parse HTML and identify input forms and Requests to simulate interactions with the target server.
• Backend: I used Flask to handle the web routing and the communication between the UI and the scanning core.
• Security layer: I developed a security.py module specifically to act as a whitelist, ensuring that the scanner cannot be used for unauthorized activities.
• Deployment: I deployed the final application on Render, configuring it to automatically bind to the correct ports for seamless web access.

Challenges I ran into

• Safe Scoping: One of my biggest challenges was ensuring the scanner couldn’t be “tricked” into scanning non-whitelisted sites. I had to refine my URL parsing logic to prevent bypass attempts.
• Parsing Complex Forms: I found that many modern web applications use dynamic forms that are difficult for basic scrapers to read. I spent extra time optimizing my BeautifulSoup selectors to ensure accurate form detection.
• Deployment Port Mapping: I initially struggled with getting the Flask app to communicate correctly with Render’s environment variables, which required a deep dive into gunicorn and port binding.

Accomplishments that I am proud of

• I successfully created a functional, ethical hacking tool that is accessible directly through a web browser.
• I maintained a strict security posture by successfully implementing a robust whitelist system.
• I delivered a project that serves as a practical educational resource for understanding web security.

What I learned

• I gained a much deeper understanding of how automated vulnerability scanners “see” the web.
• I learned how to manage security-sensitive Python applications in a cloud-hosted environment.
• I improved my skills in ethical software design, specifically how to build tools that prevent misuse while still being useful for learning.

What is next for my Scanner

• I plan to add more vulnerability checks, such as Insecure Security Headers and Command Injection.
• I want to enhance the UI/UX with better result visualization, perhaps using D3.js for interactive threat reports.
• I am looking to Dockerize the entire application to allow for more consistent and isolated local deployments for classroom settings.

Python, Streamlit, Scikit-learn, Random Forest, SVM, FastAPI, Matplotlib, Joblib, Pandas

This project is a real-time anomaly detection dashboard built to monitor and detect cyber threats in Internet of Medical Things (IoMT) environments. By leveraging machine learning, it provides a vital layer of security for smart hospital systems.

Github Repo

Inspiration

As healthcare systems become increasingly connected, they also become more vulnerable to cyberattacks. I created this dashboard to provide healthcare IT professionals with a real-time tool to detect and visualize anomalies—such as spoofing, unauthorized access, and ransomware—before they can compromise patient safety or data.

What it does

The IoMT Anomaly Detection Dashboard offers a suite of tools for real-time monitoring and model evaluation:

• Real-time Simulation: Simulates IoMT data streams to provide live predictions on network health.
• Dual-Model Detection: Utilizes both Random Forest and Support Vector Machine (SVM) models to identify anomalies.
• Model Evaluation: Displays live confusion matrices to help researchers understand model performance.
• Automated Logging: Maintains a detection_log.csv of all predictions for post-incident analysis and performance auditing.

Demo

How I built it

• Data Source: IoMT.csv dataset containing labeled network traffic patterns.
• Machine Learning: Developed using Python and Scikit-learn, focusing on Random Forest and SVM classifiers for high-accuracy threat detection.
• Dashboard: Built with Streamlit to create an interactive, web-based UI that handles live data processing.
• Preprocessing: Utilized StandardScaler and Joblib for efficient model serialization and real-time feature scaling.

Architecture

Challenges I ran into

• Real-time Performance: Ensuring the dashboard could process and visualize data points rapidly without lag.
• Model Accuracy: Tuning the SVM model to minimize false positives, which are critical in a healthcare setting to avoid “alert fatigue.”
• Data Structuring: Handling the specific feature requirements of medical IoT devices while maintaining a clean preprocessing pipeline.

Accomplishments that I am proud of

• Successfully integrated two distinct ML models into a single, cohesive dashboard.
• Developed a functional logging system that records threats automatically.
• Created a tool that bridges the gap between complex machine learning research and practical cybersecurity application.

What I learned

• How to deploy machine learning models into a live Streamlit environment.
• The specific characteristics of IoMT network traffic and how they differ from standard IT environments.
• Advanced visualization techniques for displaying model evaluation metrics like confusion matrices in real-time.

What is next for IoMT Dashboard

• Integrate the FastAPI backend to support remote data ingestion from actual medical devices.
• Implement deep learning models to better detect time-series based attack patterns.
• Add an automated alert system that sends notifications via email or SMS when high-severity threats are detected.

Python, Salesforce API, NLP, JavaScript, Shell Scripting

CaseyBot is an AI-driven tool that transforms case management within Salesforce by intelligently matching new cases with historical ones. It streamlines customer support processes by suggesting relevant past cases and solutions, improving response times and enhancing the overall customer experience.

Github repository

What it does

CaseyBot revolutionizes Salesforce case management through these core features:

• Case Matching: Automatically identifies and matches new Salesforce cases with similar, previously solved cases to accelerate resolution time.
• Solution Suggestions: Provides relevant solutions based on past cases, helping support teams respond to customer issues more efficiently.
• Integration with Salesforce: Seamlessly integrates into Salesforce’s case management system, leveraging existing case data to make real-time recommendations.
• AI-Powered Insights: Uses machine learning models to ensure accurate case matching by analyzing various case attributes like issue descriptions, categories, and resolution methods.

How we built it

• Data Collection: Salesforce data was extracted and used to train CaseyBot’s machine learning models, allowing it to recognize and match cases with high accuracy.
• AI Model: Developed using Python, CaseyBot uses natural language processing (NLP) to parse case descriptions and apply semantic similarity algorithms.
• Machine Learning: Implemented techniques to rank the relevance of past cases to new ones, ensuring high-quality matches.
• Frontend and Integration: The JavaScript and HTML-based frontend is embedded within Salesforce, providing an intuitive user interface for customer service teams.
• Salesforce API: Integration allows CaseyBot to access real-time case data and make recommendations on the fly.
• Automation: Shell scripts were used for deployment automation, while Nushell facilitates shell scripting in the workflow.
• Custom Styling: CSS ensures that the user interface remains consistent with Salesforce’s design standards.

Building CaseyBot required a deep dive into the Salesforce API to ensure seamless data flow between the AI model and the CRM. We focused on building a robust NLP pipeline that could handle the specific technical jargon often found in support tickets.

Challenges we ran into

• Data Variability: Matching cases accurately required handling inconsistent or incomplete data across historical logs.
• Performance: Ensuring real-time case matching without compromising Salesforce’s native performance was critical.
• Integration Complexity: Integrating the AI model smoothly into the Salesforce UI required careful API management and handling various edge cases.

Accomplishments

• Successfully built a fully functional AI-powered case matcher that dramatically reduces case resolution times.
• Improved case matching accuracy through NLP and machine learning, leading to better customer support outcomes.
• Created a seamless user experience that fits naturally within the existing Salesforce ecosystem.

What is next for CaseyBot

• Implement automated response drafting based on the matched solutions.
• Expand the machine learning model to support multi-language case matching.
• Add advanced analytics dashboards for support managers to track solution accuracy.

Kohl’s × Sephora × PACT Case Study

Project Context

Role: Conceptual System Designer (Case Competition Entry)
Objective: Propose a technology-backed solution to increase sustainability engagement in retail.

View the Full Group 3 Presentation (PDF)

The Challenge

Kohl’s and Sephora have a strong partnership, but bridging the gap between physical sustainability (recycling) and digital loyalty (Kohl’s Rewards) remains a manual process. The goal was to design a system that automates this bridge to drive foot traffic and environmental impact.

The Proposed Solution: “The Smart-Pact Bin”

The core concept is an AI-assisted recycling kiosk that identifies beauty product packaging and rewards the user instantly.

Conceptual System Architecture

The system would require a three-tier integration:

1. Hardware Layer: IoT-enabled bins with weight sensors and high-resolution cameras.
2. Processing Layer: A Computer Vision (CV) model to identify Sephora-brand packaging vs. non-recyclable waste.
3. Incentive Layer: Integration with the Kohl’s Rewards API to credit accounts in real-time.

Role of AI & Machine Learning

In this conceptual model, AI is the “trust layer” that removes the need for store associates to manually verify recycled items.

1. Object Recognition

Using a pre-trained image classification model, the bin would verify if the deposited item matches Sephora’s accepted materials (e.g., plastic bottles, glass jars, or tubes).

2. Weight-to-Point Logic

By combining visual data with a weight sensor, the system would estimate the mass of the material and apply a conversion formula:

• Formula Concept: $Points = (Weight_{material} \times Material_{value}) + Loyalty_{bonus}$

Feasibility & Cost Analysis

A major part of the study involved high-level financial modeling for a pilot program:

• Total Estimated Pilot Cost: ~$862,500.
• Hardware (Bins/Sensors): Primary cost driver.
• Maintenance & Logic: Assumed API integration costs and data handling fees.

Key Takeaways

This project allowed me to practice Technical Product Thinking—the ability to look at a business problem and break it down into modular technical components.

• System Design: Thinking about how IoT hardware interacts with cloud APIs.
• Data Integrity: Addressing how to prevent “reward fraud” using sensor data.
• User Experience: Designing a frictionless flow for the non-technical consumer.

Disclaimer

This project was developed for a case competition. It represents an exploration of technical feasibility and business strategy. All cost estimates and technical architectures are theoretical.This project is a conceptual proposal. No physical system was built, and no code was deployed. The following documentation outlines the high-level system architecture and the logic behind the proposed AI integration.

R, ggplot2, dplyr, tidyverse, readr, HTML, CSS, GitHub Pages

I analyzed NVIDIA’s stock performance from 1999 to 2024 to understand historical trends, volatility, and key price movements. Using R, I created visualizations and statistical summaries to gain insights into the company’s market behavior.

Live Report

GitHub Repo

Inspiration

I wanted to see how NVIDIA evolved from a GPU company to an AI powerhouse and how this growth impacted its stock price over 25 years. I also aimed to identify periods of high volatility and major market events.

What it does

The NVIDIA Stock Analysis project examines historical stock data to uncover patterns and trends over time. Key features include:

• Summary Statistics: Provides descriptive statistics, variance, and price ranges for closing prices.
• Stock Price Visualizations: Line charts showing opening, closing, high, and low prices from 1999–2024.
• Daily Returns Analysis: Tracks daily percentage changes to detect volatility and market spikes.
• Top Price Difference Days: Highlights days with the largest difference between open and close prices.

How I built it

• Data Source: Historical NVIDIA stock prices 1999–2024
• Processing: R with tidyverse, dplyr, readr, and ggplot2 for cleaning, merging, and visualization
• Visualization: Line charts, bar charts, and scatter plots to highlight trends and volatility
• Website: GitHub Pages for hosting the interactive HTML report

Sample R Analysis Work

• Nvidia Closing Stock Price 2020-2024
  

• Top Ten Days with Highest Price Differences
  

• Daily Returns
  

Key Features

• Explore NVIDIA stock trends and volatility
• Analyze daily returns and significant price movements
• Interactive HTML report hosted on GitHub Pages
• Visualizations that clearly explain trends and anomalies

Challenges I ran into

• Data Cleaning: Combining 25 years of stock data without errors
• Volatility Analysis: Identifying periods of high market movement
• Visualization: Making charts readable and informative for a broad audience

Accomplishments that I am proud of

• Created a comprehensive analysis of NVIDIA stock from 1999–2024
• Developed clear visualizations for trends, daily returns, and volatility
• Hosted an interactive HTML report on GitHub Pages

What I learned

• How to analyze long-term financial data and detect patterns
• How to visualize stock trends and volatility using R
• How to combine data analysis with an accessible, interactive web presentation

What is next for NVIDIA Stock Analysis

• Add predictive modeling for future stock trends
• Include interactive dashboards for deeper data exploration
• Incorporate additional financial indicators such as volume and market cap

Python, OpenAI API, LangChain, Web Scraping, NLP

Eduowl was created to simplify the university admissions journey by guiding students through the application process and helping them discover academic majors that align with their interests, strengths, and career goals.

Github repository

Inspiration

As a group of college students who vividly recall the complexities and uncertainties of the university admissions process, we found our collective inspiration. Our team of four, each from different majors and backgrounds, recognized a common challenge faced by high school graduates: the overwhelming task of choosing a major while navigating complex admissions requirements. Eduowl was created to turn this daunting pre-college experience into an empowering and streamlined journey, particularly for students applying to Rowan University.

What it does

Eduowl revolutionizes the university admissions process by offering two core capabilities:

• Admissions Guidance Chatbot: An AI-driven chat interface that answers questions about Rowan University, including academics, admissions requirements, campus life, and student resources.
• Major Recommendation System: Evaluates students’ interests, strengths, and career goals to recommend suitable academic majors.
• Interactive AI Conversations: Provides engaging, real-time, context-aware responses.
• Data-Driven Advising: Uses structured admissions data sourced directly from official university resources.

How we built it

• Backend: Python
• Web Scraping: BeautifulSoup, Requests
• PDF Processing: PyPDF2
• AI & NLP: OpenAI API
• Framework: LangChain
• Conversation Memory: ConversationBufferMemory
• Data Handling: Text chunking and token estimation

Building Eduowl began by gathering the latest admissions information from Rowan University’s official website. We implemented web scraping techniques to extract accurate and up-to-date admissions data, with a focus on international admissions requirements. To extend the chatbot’s knowledge base, we processed PDF documents using PyPDF2.

The chatbot was powered by OpenAI’s language models and integrated using LangChain. ConversationBufferMemory enabled the bot to maintain context across interactions, resulting in coherent and relevant responses. Text chunking and token estimation were used to efficiently handle large volumes of scraped and document-based content.

Demo

Challenges we ran into

• Persistent errors when attempting to integrate JSON data into Azure AI Studio
• Handling large volumes of scraped and PDF-based data
• Maintaining response accuracy and contextual relevance

Accomplishments

• Built a functional AI-powered admissions chatbot
• Designed a form-based major recommendation feature
• Successfully pivoted from Azure AI Studio to the OpenAI API
• Delivered a student-focused solution addressing real admissions challenges

What we learned

• How to build conversational AI using OpenAI and LangChain
• How to scrape, structure, and process real-world admissions data
• The importance of adaptability when encountering technical roadblocks

What is next for Eduowl

• Expand major recommendations across additional academic disciplines
• Integrate Microsoft Azure to enhance AI capabilities
• Improve chatbot memory, intelligence, and response accuracy
• Add academic advising and writing assistance features

HTML, CSS, JavaScript, Python, SpaCy, Matplotlib, Seaborn, GitHub Pages, HuggingFace Spaces, Kaggle

I collaborated with 3 people for this project. As a group, we combined our skills in data science, NLP, web development, and visualization to explore how climate change discussions affect housing sentiment.

Live Website

Chatbot

Github Repo

Inspiration

We created SentiShelter to help people understand how climate change conversations influence the housing market. From rising insurance rates to homes becoming less sustainable, we wanted to provide a tool that visualizes sentiment trends and highlights key topics and locations.

What it does

SentiShelter analyzes Reddit comments from 2010-2022, tracking sentiment over time related to climate change and housing. Key features include:

• Sentiment Analysis: Identify positive, negative, or neutral sentiment in discussions about climate and housing.
• Topic Clusters: Extract major topics and trends from discussions.
• Interactive Website: Users can explore data visualizations and access a chatbot to learn more about the dataset.
• Data Visualization: Bar charts, line graphs, and scatter plots show sentiment trends over time.

Final Product

How we built it

• Data Source: Kaggle Reddit Climate Change Dataset (2010-2022)
• Processing: Python, SpaCy NLP for cleaning and extracting entities like people and locations
• Visualization: Matplotlib and Seaborn for sentiment trends, topic clusters, and frequency charts
• Website: Responsive HTML/CSS/JS site with integrated Hugging Face chatbot

Sample Kaggle Data Science Work

• Cleaning the Dataset

• Average Sentiment Analaysis per month
  

  Key Features

• Explore Reddit sentiment trends (2010-2022)
• Identify top entities (persons, locations) and their associated sentiment
• Interactive visualizations and data exploration
• Hugging Face chatbot integration for learning about climate and housing

Challenges we ran into

• Large Dataset: Required sampling to maintain performance without losing insights
• Entity Analysis: Identifying meaningful relationships between people, locations, and sentiment was complex
• Visualization: Presenting data clearly while maintaining an interactive user experience

Accomplishments that we are proud of

• Successfully combined NLP, data visualization, and web development
• Developed a user-friendly website with clear insights
• Integrated a chatbot interface for exploring climate change and housing discussions

What we learned

• How to extract insights from large datasets using NLP
• How to visualize and present complex sentiment data interactively
• How to combine Python analysis with a responsive website

Winner of Technica 2023

• My team and I won first place in the Fannie Mae “Climate Change Sentiment Analysis and Impacts on Housing” competition, and second place in the Bloomberg Industry Group “Best AI-Powered Solution” competition.

What is next for SentiShelter

• Add more real-time sentiment tracking as new data becomes available
• Expand chatbot capabilities to provide more detailed explanations of trends and insights
• Enhance topic clustering and sentiment analysis using advanced NLP models

FastAPI, SvelteKit, NLP, SQL, Data Visualization

MedLingua was created to bridge the communication gap between doctors and patients by transforming complex medical data into clear, patient-friendly insights.

Github repository

Inspiration

MedLingua addresses the challenge that nearly 2 in 3 patients struggle to understand their healthcare providers due to complex medical jargon and disconnected patient data. The platform synthesizes structured health records and unstructured clinical notes into clear explanations, personalized recommendations, and meaningful visualizations.

What it does

MedLingua interprets medical data to improve communication between patients and providers. Key features include:

• Personalized Explanations: Converts complex medical terminology into patient-friendly language.
• Smart Recommendations: Provides tailored healthcare recommendations based on patient data.
• Medical Visualizations: Displays connected medical histories through intuitive charts.
• Structured & Unstructured Data Integration: Merges EHR data with clinical notes seamlessly.
• Provider-Focused Insights: Supports clinical decision-making with organized data views.

Architecture

How we built it

• Backend: FastAPI
• Frontend: SvelteKit
• Machine Learning: Codebox
• NLP: Custom NLP models
• Database: SQL
• Data Processing: MIMIC Dataset & Clinical Data Pipelines

Challenges we ran into

• Integrating structured and unstructured medical data
• Ensuring patient-friendly explanations without losing clinical accuracy
• Building intuitive visualizations for complex health records

Accomplishments

• Successfully combined backend, frontend, NLP, and data visualization
• Delivered a tool that helps patients and providers communicate more effectively
• Built a fully functional platform with clear insights

What we learned

• How to process structured and unstructured healthcare data
• How to visualize complex datasets in an accessible way
• How to integrate Python backend with a responsive frontend

What is next for MedLingua

• Expand NLP models for more nuanced medical notes
• Include real-time analytics and patient dashboards
• Improve visualizations with more interactive charts

HTML, CSS, JavaScript

Live Website

GitHub repository

Inspiration

The Coffee Recommender is a fun and interactive web application designed to help users discover their perfect coffee based on their preferences for strength, milk, and sweetness. The app uses a simple quiz interface to guide users and provides a coffee suggestion based on their choices.

What it does

The application lets users select their coffee preferences and generates a recommendation. Key features include:

• Interactive Quiz: Users answer three questions to determine their coffee preference.
• Coffee Recommendations: Suggests popular coffee types like Espresso, Latte, Cappuccino, Americano, Macchiato, and Flat White.
• Responsive Design: Works seamlessly across desktop and mobile devices.
• Separate Files: HTML, CSS, and JavaScript are in separate files for modularity and maintainability.

How it was built

• Frontend: HTML5 for structure, CSS3 for styling, JavaScript for quiz logic
• Responsive Design: Ensured proper display on desktop and mobile
• Separate Modular Files: index.html, style.css, script.js

How It Works

1. Users select their preferences for coffee strength, milk, and sweetness.
2. Clicking Submit triggers JavaScript to determine the recommended coffee.
3. Recommendation is displayed on the screen; Retry allows retaking the quiz.
4. Input validation ensures all questions are answered before showing results.

Challenges

• Validating user input and ensuring smooth quiz flow
• Making the layout responsive for different screen sizes
• Structuring modular files for maintainability

Accomplishments

• Developed a fully interactive quiz from scratch
• Practiced DOM manipulation and JavaScript logic
• Built a responsive and user-friendly design

What I learned

• Improved JavaScript skills for handling user input and quiz logic
• Learned modular coding practices with separate HTML, CSS, and JS files
• Strengthened responsive web design skills for a better user experience