Every placement season, students receive internship offers that look legitimate on the surface but fall apart the moment you inspect them closely.
Some ask for “training fees.”
Some guarantee placements before interviews even happen.
Some companies barely exist online.
Others hide behind generic Gmail accounts and flashy marketing.
The worst part is that many students can’t easily distinguish between a real opportunity and a well-designed scam.
So my teammates and I built a system that tries to score internship legitimacy before students commit time or money.
We call it ShieldIntern.
The Core Idea
We wanted a system that behaves less like a chatbot and more like an auditor.
Instead of simply asking an LLM whether an internship is “fake,” we structured the analysis around four specific evaluation pillars:
- Financial transparency
- Digital footprint
- Recruitment authenticity
- Marketing credibility
The system takes internship ads, screenshots, emails, company descriptions, and URLs as input. It then analyzes the content and generates a legitimacy score between 0 and 100.
But the important part wasn’t generating a score.
The difficult part was making the scoring explainable.
The Rule That Changed Everything
One design decision became the foundation of the entire system:
If a company asks students to pay upfront fees, the legitimacy score is automatically capped below 30.
That single rule solved multiple problems at once.
Without it, the LLM occasionally produced high scores for suspicious internships simply because the company had a polished website or strong marketing language.
In reality, legitimate internships rarely require students to pay to work.
So instead of relying purely on probabilistic reasoning, we introduced deterministic penalties for critical red flags.
That hybrid approach produced much more reliable outputs.
How The System Works
The frontend was built using React, Vite, and Tailwind CSS.
Students can:
- Upload screenshots
- Paste internship descriptions
- Add company details
- Submit emails or URLs
The backend uses Express.js and Multer for request handling and file uploads.
The analysis pipeline sends structured prompts to Groq running LLaMA 3 70B.
Instead of asking broad questions, the prompt forces the model to evaluate internships through individual categories.
For example:
- Does the company use a corporate domain?
- Is the recruitment process realistic?
- Does the offer use urgency tactics?
- Are responsibilities clearly defined?
- Is there evidence of a real digital footprint?
Each category contributes to the final score independently.
That structure made the outputs significantly more consistent.
One Unexpected Problem
The first versions of the system were too optimistic.
The model often interpreted professional-looking language as credibility.
That became a serious issue because scam internships are usually designed to appear highly professional.
We had to redesign the scoring logic so that suspicious financial behavior outweighed surface-level presentation quality.
This became one of the biggest lessons we learned while building the project:
LLMs are good at pattern recognition, but trust systems still need hard constraints.
Why Explainability Matters
One thing we intentionally avoided was producing only a final verdict.
A simple “fake” or “real” label isn’t very useful to students.
Instead, the system returns:
- positive indicators
- red flags
- category breakdowns
- actionable recommendations
That way, students understand why an internship appears suspicious.
In practice, explainability matters more than raw scoring accuracy because users need confidence in the reasoning process.
Building the Frontend
We wanted the interface to feel less like an academic tool and more like a modern product.
So we added:
- drag-and-drop uploads
- animated score gauges
- color-coded verdicts
- responsive layouts
- dark mode support
The goal was to make the analysis feel immediate and intuitive.
Tech Stack
Frontend:
- React 18
- Vite
- Tailwind CSS
- Axios
Backend:
- Node.js
- Express.js
- Multer
AI Layer:
- Groq API
- LLaMA 3 70B
What We Learned
Building this project changed the way we think about AI-assisted trust systems.
A few lessons stood out:
Pure LLM reasoning is not enough for fraud detection.
Critical rules still need deterministic enforcement.Explainability matters more than confidence scores.
Users trust systems that show reasoning transparently.Scam detection is largely behavioral analysis.
Many fake internships reveal themselves through recruitment patterns rather than obvious technical signals.Small prompt structure changes drastically affect consistency.
Breaking scoring into categories improved output quality significantly.
Final Thoughts
Internship scams are becoming increasingly sophisticated, especially in online hiring spaces.
We don’t think AI alone can solve that problem.
But we do think systems that combine structured rules with language models can help students make safer decisions faster.
That was the goal behind ShieldIntern.
GitHub Repository:
https://github.com/ryxonix/HackWithBangalore