Sentra

Threat Analyzer
Meet The Team
Sentra Home

This an AI Track Development

Inspiration

Phishing is the most-reported cybercrime in the United States — over 190,000 FBI complaints in 2025 alone, with losses jumping 208% in a single year to over $215 million (source). What struck us most wasn't the scale, it was the asymmetry: a phishing campaign costs an attacker as little as $120 to launch, but can cost a victim their life savings. Most people also have no idea why a message is suspicious — they just get a vague gut feeling, if they notice at all. We wanted to build something that doesn't just say "this is a scam," but actually teaches people to recognize the next one themselves.

What it does

Sentra is an AI-powered cybersecurity assistant that analyzes suspicious emails, texts, and links. A user pastes in a message, and Sentra breaks it down across five key indicators:

🚩 Urgency and threat language
🚩 Credential or personal information requests
🚩 Suspicious or malformed URLs
🚩 Brand impersonation
🚩 Typosquatting (e.g. paypa1.com instead of paypal.com)

It returns a Low / Medium / High risk score, along with a plain-language explanation of exactly what triggered the flags — turning a one-off warning into a teachable moment.

How we built it

Sentra's API handles the core analysis logic — regex-based URL detection, keyword matching against curated phishing indicator lists, and pattern matching for typosquatted domains. Here's a simplified look at the scoring logic:

def calculate_risk_score(findings):
    score = 0
    score += min(len(findings["suspicious_urls"]), 3) * 15
    score += min(len(findings["urgency_flags"]), 3) * 10
    score += min(len(findings["credential_flags"]), 3) * 15
    return min(score, 100)

Each finding is weighted and combined into a 0–100 risk score. The frontend is built with React and Vite, calling the API over a CORS-enabled /analyze endpoint.

We split the work by role: backend and threat-detection logic, frontend/UI, and AI integration + testing, syncing regularly on the shape of the data passed between each piece so nothing broke when we connected them.

Challenges we ran into

Getting Git set up locally. Before we could write a single line of shared code, we had to get Git properly installed on each of our Macbooks, understand the difference between Git (the tool) and GitHub (the remote repo), and actually clone the repository from the host teammate's computer onto our own machines. Simple in hindsight, but it ate real time early on.
Authentication for push/pull. Getting each of our machines authenticated to actually push and pull from GitHub — rather than just being able to view the repo — turned into its own mini debugging session, especially for teammates setting this up for the first time.
Version control discipline. Learning to commit in small, logical chunks instead of one giant dump of code, and getting comfortable with the stage → commit → push cycle so nothing got overwritten or lost between teammates.
Variable/environment consistency. Making sure things like python vs python3, installed packages, and file paths matched across everyone's machines — a missing dependency or a different command name on one laptop could silently break something that worked fine on another.
CORS. Our first attempt at connecting the React frontend to the API was silently blocked by the browser until we added flask-cors — a classic full-stack gotcha for a team newer to connecting separate frontend/backend services.
Balancing detection sensitivity. Tuning the scoring so it reliably flags real phishing attempts without over-flagging normal messages took some iteration — we tested against both obvious phishing examples and everyday messages to make sure the analyzer actually discriminates rather than just flagging everything.

Accomplishments that we're proud of

We got a fully working detection pipeline end to end — paste a message in, and Sentra correctly distinguishes a phishing attempt from a normal message, with a clear explanation of why. It's a genuinely useful tool built and shipped in a single hackathon.

What we learned

The full mechanics of a real Git workflow — not just writing code, but getting Git installed, cloning a shared repo, authenticating for push/pull access, and committing in small, reviewable chunks across a team.
How to structure a Git workflow across a team so multiple people can build in parallel without stepping on each other's work.
The real mechanics of connecting a frontend and backend as separate services — CORS, JSON contracts, and why agreeing on a data shape early saves a lot of pain later.
Just how significant and fast-growing phishing is as a threat to everyday people, not just companies.

What's next for Sentra

OCR support so users can upload a screenshot of a suspicious message instead of retyping it.
Deeper URL analysis (e.g. checking domain age, redirect chains).
Expanding detection coverage with more impersonation and typosquatting patterns as new attack trends emerge.