Project PhURL
A Web Platform That Detects Phishing URLs with AI - and Teaches You to Spot Them
Phishing doesn't break in - it tricks its way in, one convincing link at a time. PhURL is an end-to-end project that pairs a trained machine-learning model with a calm, educational interface, so anyone can paste a link, get an instant verdict, and actually learn why it's risky. The guiding mantra throughout: if it looks phishy, it probably is.
Context & The Problem
Phishing attacks evolve faster than most people can keep up with - a fresh malicious domain, a lookalike login page, a shortened link in a message. Many existing tools either block silently in the background or flash a cryptic warning, but they rarely help a person understand why a link is dangerous. The result is a population that stays one careless click away from compromise.
"Phishing attacks are evolving rapidly… existing solutions often lack adaptability and fail to educate users effectively."
Problem Statement
People need a fast, trustworthy way to check whether a URL is safe - and just as importantly, to learn the cues of a phishing attempt so they can protect themselves next time.
The Goal
Build an accurate ML model for phishing detection, wrap it in an intuitive interface, teach users about phishing through real resources, and keep the whole system scalable, adaptable and secure.
Target Audience
Everyday individuals and organisations who want phishing protection plus genuine cybersecurity awareness - regardless of their technical background.
Discovery & Research
Research ran on two tracks at once: understanding what users actually need from a URL checker, and understanding the data and models that could power it. The two informed each other - a model is only useful if people trust and understand its output.
Detect-Only Tools vs. PhURL's Opportunity
- Block or flag links without explaining the risk
- Static rule-sets that struggle to adapt to new tactics
- No learning layer - users never get more phishing-aware
- An ML model that learns patterns from real URL data
- A clear, instant verdict anyone can read at a glance
- A built-in learning hub that turns a scan into a lesson
Who We Designed For
"I got a weird link in a message - can I just paste it somewhere and be told if it's safe?"
"I want a dependable check my whole team can use, with low false positives."
"Don't just tell me it's phishing - show me what made it phishing."
Cross-Persona Insights
The AI & ML Engine
At the heart of PhURL is a supervised classifier trained to tell malicious URLs from safe ones. The pipeline takes a raw link, engineers a set of numeric features from it, scales the data, and runs it through a trained model that returns a confident verdict.
Detection Pipeline
Model Selection
Three gradient-boosting and ensemble classifiers were trained and benchmarked on the same dataset. The Light GBM Classifier came out ahead on both accuracy and false-positive/negative balance, so it became the model shipped to production.
Light GBM · Chosen
The best performer at 96.6% accuracy with low false positives and negatives. Serialised to a .joblib file and loaded by the backend at inference time.
Random Forest
A strong ensemble baseline - reliable, but edged out on accuracy and speed for this feature set.
XGBoost
Competitive gradient boosting that performed well, but didn't beat Light GBM's balance on this data.
The model was trained on a public Kaggle dataset (by Manu Siddhartha) spanning phishing, malware, defacement and safe URLs. Heavy preprocessing, feature engineering and data scaling were needed to squeeze reliable signal out of messy, real-world links.
UI & Visual Design
A security tool only works if people aren't scared of it. The interface was designed in Figma around three priorities - simplicity (a clean, minimal layout that never overwhelms), accessibility (clear navigation and readable type for all levels), and engagement (interactive checks and learning content that invite exploration).
PhURL's palette - a vivid purple and electric lime over a deep purple-black, with red reserved for danger and grey for neutral UI.
255, 255, 255
143, 255, 0
112, 75, 255
17, 7, 45
175, 175, 175
255, 0, 0
Core Interface Components
URL Scanner
One-field input · Real-time check · Clear verdict
Learning Hub
Articles · Infographics · Videos
Results Dashboard
Verdict · Confidence · Guidance
Feedback & Errors
Friendly states · Recovery guidance
High-Fidelity Screens
The screens below show the core PhURL experience - from the scan input to the safe/phishing result and the learning content that backs it up. Click any screen to view it in high resolution.
Development & Deployment
PhURL is a full-stack build: a React front end talking to a Django back end that wraps the trained model behind a clean API. Development followed a hybrid of Agile, Scrum and Waterfall - structured enough to plan the ML work, flexible enough to iterate on the UI from user feedback.
Frontend
Built in React + JavaScript - an interactive dashboard and a real-time URL verification tool that calls the backend and renders the verdict instantly.
Backend
A Django service in an MVC structure exposing API endpoints for URL verification, with the Light GBM classifier loaded for inference.
ML Integration
The trained model is serialised to joblib and called per request - feature-engineering the URL, scaling, then classifying it as safe or malicious.
Deployment
Packaged for Heroku (Procfile, runtime & requirements) for easy, scalable hosting of the Django app and model together.
Quality came from real testing: User Acceptance Testing with university students plus cross-browser checks on Chrome, Brave, Firefox and Opera Mini - each round feeding fixes back into the UI/UX.
Explore the engineering behind it:Backend & API repo ↗ · Heroku deployment repo ↗
Outcome & Impact
Key Outcomes
"PhURL successfully addresses the growing threat of phishing by combining advanced machine learning with user education - its intuitive design, high accuracy and scalability make it valuable for individuals and organisations alike."
📈 Outcome
A reliable detector (96.6% accuracy, low false positives) wrapped in an interface that testers praised for its design and educational resources - and confirmed working across major browsers.
🧗 Challenges
Dataset limitations meant extensive preprocessing; tuning the model was a constant balance between accuracy and minimising false positives/negatives; and interface warnings had to be reworked from user feedback.
💡 What I Learned
A hybrid methodology balanced flexibility with structure, and continuous user feedback was crucial to refining usability. Above all: adaptability is essential against evolving phishing tactics.
🚀 Next Steps
On-screen warnings as users browse, deeper detection capabilities, and a mobile app to put PhURL's protection in more hands.