I Built InternLens in 3 Days: An AI-Assisted Internship Safety & Opportunity Analyzer
Over three days, I built InternLens, a decision-support tool that helps students review internship listings by identifying potential risk signals, career-value signals, missing information, and questions to ask. This is the story of how I built it using Python, Flask, AWS Strands Agents, Ollama, and Llama 3.2.
From an Internship Listing to a Working AI-Assisted Analyzer
Internship listings can look exciting at first glance, especially when they promise certificates, projects, stipends, remote work, or fast hiring.
But students also have to ask a different set of questions:
- Is there enough information about the company?
- Are there any upfront fees?
- What exactly will I work on?
- Who will mentor me?
- Is the recruiter using an official communication channel?
- What should I verify before applying?
I wanted to build something that could help answer those questions without pretending that an AI model could determine whether an internship is definitely safe or definitely a scam.
That idea became InternLens.
Over three days, I went from a problem statement to a working web application, integrated the AWS Strands Agents SDK, tested the system with different internship listings, fixed several issues, and recorded a complete demo for First Commit 2026.
What is InternLens?
InternLens is an AI-assisted internship safety and opportunity analyzer for students.
A student pastes an internship listing into the application, and InternLens analyzes it across several categories:
- Potential risk signals
- Career-value signals
- Missing information
- Questions to ask
- Safe next steps
- A concise AI-generated summary
The important design decision is that InternLens does not simply tell a student:
"This internship is a scam."
Instead, it provides evidence and uncertainty that the student can investigate.
A risk signal is not proof of fraud, and the absence of a risk signal does not guarantee that an opportunity is legitimate.
The goal is decision support.
The Problem I Wanted to Solve
Students often encounter internship opportunities through job boards, social media, messaging groups, college communities, and direct messages.
The problem is not only finding internships.
It is knowing what to verify before applying.
A student may notice a registration fee, vague company information, unrealistic promises, or urgent language, but they may not know which details deserve more investigation.
At the same time, focusing only on risks is not enough.
A useful internship listing can contain signals such as:
- Relevant technical work
- Mentorship
- Code reviews
- GitHub collaboration
- A defined duration
- Compensation
- A clear technology stack
- Portfolio-building opportunities
I wanted InternLens to look at both sides.
Day 1 — Turning the Idea Into a Working Application
The first goal was simple:
Get the complete flow working before worrying about making it perfect.
I built the initial Flask backend and browser frontend and defined the structured analysis that InternLens would perform.
The basic flow became:
Internship Listing
|
v
Frontend
|
v
Flask Backend
|
v
Structured Analysis
|
v
ResultThe Python backend handles the core analysis.
Instead of asking a language model to decide everything, I defined deterministic checks for the signals I wanted the application to identify.
This gave me predictable application behavior and made the output easier to understand and test.
I also built the frontend around the actual questions a student might have after seeing an internship listing.
Day 2 — Adding AI With AWS Strands Agents
Once the basic application was working, I wanted to add AI without making the entire application dependent on an LLM.
This is where the AWS Strands Agents SDK came in.
InternLens uses:
- Python
- Flask
- AWS Strands Agents SDK
- Ollama
- Llama 3.2 3B
- HTML
- CSS
- JavaScript
The architecture became:
Internship Listing | v Frontend | v Flask Backend | +----------+----------+ | | v v Deterministic Analysis Strands Agent | | | v | Ollama + Llama 3.2 | | +----------+----------+ | v Final Analysis | v StudentThe separation was intentional.
Deterministic analysis
Python handles the structured checks for:
- Risk indicators
- Opportunity indicators
- Missing information
This means the important structured signals do not depend entirely on the language model.
Generative AI
The Strands Agent is used to generate a concise natural-language summary from the structured analysis.
This gave me a useful division of responsibility:
Python ↓Predictable structured signals
Strands Agent ↓Natural-language explanationThis was one of the most important architectural decisions I made during the project.
Why I Didn't Let the LLM Make the Entire Decision
One of the easiest ways to build an AI application is to send everything to an LLM and ask it to produce an answer.
But for InternLens, I didn't want the model to become the final authority on whether an internship was safe.
That could create a false sense of certainty.
Instead, the application separates:
Evidence → Analysis → Explanation
The deterministic layer identifies structured signals.
The AI layer explains those results in a concise way.
The student remains the decision-maker.
This also made the system easier to reason about because I could test the structured checks independently from the generated summary.
Day 3 — Bugs, Testing, and Getting It Ready to Ship
Getting the core idea working was only part of the challenge.
The last stage was about making the project behave like an actual application rather than a collection of working pieces.
I ran into frontend/backend integration issues while connecting the browser interface to the Flask API.
At one point, the frontend was being opened directly as a local file, which caused browser security and JavaScript issues.
I also had to fix the analysis flow so that the frontend correctly handled:
- Loading states
- API responses
- Risk levels
- Opportunity signals
- Missing information
- Questions
- AI summaries
- Errors
Another practical challenge was model latency.
Because Llama 3.2 was running locally through Ollama, generating the analysis was not instantaneous.
Instead of hiding that delay, I added a visible loading state.
The application now communicates that the analysis is being processed instead of leaving the student wondering whether the application has stopped responding.
Testing With Two Different Internship Listings
I tested InternLens with different types of listings.
For a normal software engineering internship, the application could identify career-value signals such as:
- Technical work
- Mentorship
- GitHub collaboration
- Code reviews
- A defined duration
- Stipend information
It could also identify information that was still missing, such as company background.
Then I tested a more concerning example containing an upfront registration fee and urgency around limited seats.
InternLens surfaced those as risk signals while still showing the student what information was missing and what questions they could ask.
This was important to me because the application should not simply produce a scary label.
It should help the student understand why something deserves attention.
What Fought Back
The hardest part of the project was not writing one particular piece of code.
It was getting all the pieces to work together under a deadline.
Some of the challenges were:
Frontend and backend integration
The UI had to correctly communicate with the Flask API and render different parts of the analysis.
Local AI latency
Running a local Llama 3.2 model through Ollama introduced noticeable processing time.
I had to design the interface around that reality instead of assuming an instant response.
Deciding where AI belongs
I had to think carefully about which parts should be deterministic and which parts actually benefited from generative AI.
That led to the architecture I ultimately used.
Making AWS usage visible
Because AWS usage needs to be demonstrated in the hackathon submission, I made sure the demo showed the actual Strands Agent integration in the Python code as well as the application architecture.
Finishing the product, not just the code
The final stage involved testing, documentation, GitHub cleanup, demo recording, and preparing the submission.
A working prototype is different from a project that someone else can actually understand and run.
Using AWS Strands Agents
InternLens uses the AWS Strands Agents SDK as its AWS technology for the Build It track.
The relevant integration is in the Python backend:
from strands import Agentfrom strands.models.ollama import OllamaModelThe model is configured through the Ollama provider:
model = OllamaModel( host=OLLAMA_HOST, model_id=MODEL_NAME, max_tokens=80, keep_alive="10m")
agent = Agent(model=model)The project uses the local open-source approach rather than AWS cloud deployment.
I did not use Amazon Bedrock, Lambda, S3, EC2, or other AWS cloud services in this implementation.
What I Learned
This project gave me hands-on experience with several areas that I had mostly understood conceptually before building them.
AWS Strands Agents SDK
I learned how an agent framework can be integrated into a conventional Python web application rather than building an application around an AI framework from scratch.
Local model integration
I learned how to connect Ollama to a locally running Llama model and work with the practical limitations of local inference.
Deterministic + generative AI
The biggest lesson was that an AI application does not have to make everything generative.
Sometimes the better design is:
Deterministic logic +Generative AI =More controlled AI-assisted workflowFrontend/backend integration
I also learned a lot from connecting the browser interface to the Flask backend and handling loading and error states.
Building under a deadline
A hackathon forces you to make decisions about what actually needs to be built.
There are always more features that could be added.
The challenge is knowing when the core product is useful enough to stop adding features and start testing and shipping.
Responsible AI
InternLens is designed as a decision-support tool.
It does not claim that a particular internship is definitely fraudulent based only on the information in a listing.
Instead:
- A risk signal is not proof of fraud.
- A missing signal does not guarantee safety.
- Students should verify companies and recruiters independently.
- Students should avoid sharing sensitive financial information unnecessarily.
- Students should ask for written details about the role, compensation, responsibilities, and organization.
The goal is to help students ask better questions before they apply.
What I Would Build Next
There are several directions I would explore if I continued developing InternLens.
Company verification
Add structured verification of company information using trusted public sources.
Recruiter verification
Help students distinguish official company communication channels from suspicious contact information.
Browser extension
Allow students to analyze internship listings directly while browsing job boards.
Better evidence collection
Show the exact text from a listing that triggered each signal.
More evaluation
Build a larger test dataset of internship listings and evaluate the consistency of the structured analysis.
Deployment
A future version could be deployed using AWS cloud services rather than running entirely locally.
Final Thoughts
Three days is not a long time to build an application.
There were plenty of moments where I could have spent hours adding another feature or rewriting something that already worked.
Instead, I focused on getting one complete flow working:
Paste Listing ↓Analyze ↓Show Signals ↓Explain Missing Information ↓Suggest Questions ↓Generate SummaryThe biggest lesson I am taking away is that building an AI application is not just about choosing a model.
It is about deciding where AI actually adds value, controlling the parts that should remain predictable, handling the practical limitations of the technology, and building something useful for a real person.
That is what InternLens became for me.
Links
Hackathon: First Commit 2026 — Bharat Builds Tour
Track: Build It
Technology Stack
- Python
- Flask
- HTML
- CSS
- JavaScript
- AWS Strands Agents SDK
- Ollama
- Llama 3.2 3B
Built as a solo project for AWS First Commit 2026.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article