
AI Can Answer Anything. So We Built VeriFYI to Make It Prove Something.
What if AI could tell you not only what it thinks is true, but also what evidence supports it? We built VeriFYI to verify claims in internship offers, recruiter messages, and online opportunities using an evidence-first AI pipeline. This article covers the architecture, AI validation pipeline, AWS deployment, and the engineering decisions behind building it.
Don't just trust it. Verify it.
Every day, people receive internship offers, recruiter messages, scholarship announcements, job listings, and opportunity links online.
The difficult part isn't always understanding the message.
The difficult part is knowing which parts of the message can actually be trusted.
A single opportunity message can contain several different claims:
- Who is the company?
- Does the recruiter actually represent the company?
- Is the salary legitimate?
- Is the contact information trustworthy?
- Is the requested payment legitimate?
- Is the deadline real?
- Is the opportunity actually associated with the organization being mentioned?
A conventional AI system might answer these questions confidently even when it doesn't have enough evidence.
That creates a problem:
AI can produce false confidence.
We built VeriFYI to approach this problem differently.
Instead of asking an AI model to simply decide whether something is a scam, VeriFYI breaks a message into individual claims and asks:
What can actually be supported by evidence?
What is VeriFYI?
VeriFYI is an evidence-first claim verification tool for internship offers, recruiter messages, scholarships, job listings, and other online opportunities.
A user can paste a message or opportunity listing into VeriFYI.
The system extracts meaningful claims and evaluates them individually.
Each claim receives one of three statuses:
SUPPORTED
Available evidence supports the claim.
UNVERIFIED
There isn't enough evidence available to establish the claim.
CONTRADICTED
Available evidence goes against the claim.
The system then produces an overall verification result together with explanations and recommended next actions.
Instead of hiding everything behind a single score, VeriFYI exposes the reasoning structure:
CLAIM ↓EVIDENCE ↓STATUS ↓EXPLANATION ↓NEXT ACTIONThis makes the result easier for a user to inspect and question.
Why we built it
The original idea came from a simple observation:
A confident answer isn't necessarily a verified answer.
Imagine receiving this message:
Congratulations! You have been selected for an AI internship.
Salary: Rs 80,000/month.
Pay Rs 1,500 onboarding fee.
Contact recruiter at googlecareers@gmail.com.There are multiple claims hidden inside those few lines.
For example:
- The candidate was selected.
- The internship pays Rs 80,000/month.
- The candidate needs to pay Rs 1,500.
- The email address belongs to the claimed organization.
- The recruiter represents the organization.
These shouldn't necessarily receive the same status.
One claim may be directly present in the submitted message.
Another may require external evidence.
Another may have no evidence at all.
So instead of producing:
SCAM SCORE: 87%VeriFYI produces a claim-level report.
That distinction is important because users can see why the system reached its result.
The verification pipeline
The application follows a simple but deliberate architecture:
User Input ↓Claim Extraction ↓Claim Classification ↓Evidence Validation ↓Anti-Fabrication Gate ↓Verification Result ↓User InterfaceThe AI model handles the language understanding and claim analysis.
But the model is not given unlimited authority over the final result.
A separate validation layer checks the generated response before it reaches the user.
This was one of the most important engineering decisions in the project.
Making evidence a first-class concept
One of the biggest problems we wanted to avoid was fabricated evidence.
A language model can generate text that sounds like a citation, quote, or source even when it doesn't actually exist.
For a verification product, that is especially dangerous.
If VeriFYI says:
"This claim is supported by the company's official website."
we need to know that the source actually exists and was actually retrieved.
Similarly, if the model says:
"Pay Rs 1,500 onboarding fee."
as evidence from the submitted message, that quotation should actually occur in the user's input.
So the validation layer checks user-provided evidence against the submitted source text.
If the quoted evidence cannot be traced back to the source, it is rejected.
If the model invents an external URL or search result, it is not accepted as external evidence.
If a claim is marked as supported but doesn't have valid evidence, the validator can downgrade it to:
UNVERIFIEDThe principle is:
No evidence means no claim of verification.
The model is not the final authority
Our AI architecture is intentionally provider-independent.
The current production AI provider is Gemini 2.5 Flash.
The application also contains an Amazon Bedrock provider implementation as a future provider option, so the underlying AI provider can be changed without rebuilding the verification system itself.
The architecture looks like this:
┌─────────────────┐ │ VeriFYI UI │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ /api/analyze │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ AI Provider │ └────────┬────────┘ │ ┌────────┴────────┐ ▼ ▼ Gemini 2.5 Flash Bedrock (current) (future option) │ ▼ ┌──────────────────┐ │ Validation Layer │ └────────┬─────────┘ │ ▼ VerificationResult │ ▼ VeriFYI UIThis separation means the verification logic does not need to be rewritten if the underlying model changes.
The model interprets the input.
The validation layer protects the contract.
Building VeriFYI with AWS
AWS is part of the production foundation of VeriFYI.
AWS Amplify
We deployed the Next.js application using AWS Amplify and connected it to our GitHub repository.
The resulting workflow is:
GitHub ↓AWS Amplify ↓Build ↓Deploy ↓Production applicationThis was especially useful during a hackathon because we could push changes to GitHub and have Amplify handle the production build and deployment workflow without maintaining our own application server.
Our production application is currently hosted through AWS Amplify.
Amazon DynamoDB
VeriFYI uses Amazon DynamoDB for verification persistence.
The application integrates DynamoDB through the AWS SDK for JavaScript.
The server-side verification layer is responsible for persistence rather than exposing database credentials or operations directly to the browser.
This fits the application well because the project does not need to maintain a traditional database server.
AWS SDK for JavaScript
We use the AWS SDK for JavaScript to communicate with AWS services from the server-side application.
For example, the DynamoDB integration uses the AWS SDK clients for database operations.
Keeping this integration server-side also helps us maintain a clean separation between:
Browser ↓Application API ↓AWS servicesrather than giving the browser direct access to infrastructure credentials.
Production observability
Another important part of the application is structured logging.
Instead of printing arbitrary debugging information, the application uses structured server-side logs.
The goal is to make production events easier to diagnose while avoiding sensitive information.
For example, diagnostics can record safe metadata such as:
provider = geminimodel = gemini-2.5-flashproviderConfigured = truewithout logging:
- API keys
- raw user messages
- sensitive credentials
This became particularly important while debugging our production deployment.
A real production lesson: mock data should never be the default
One of our most useful discoveries happened after our first deployment.
During development, we had a mock analysis mode so that the interface could be developed without depending on a live AI provider.
That was useful locally.
But our initial frontend behavior had a dangerous edge case:
If the mock environment variable wasn't explicitly configured, the frontend could default to mock mode.
That meant the application could display a perfectly valid-looking demo report without actually calling the production API.
We discovered this because the deployed application was showing a familiar five-claim report even though we expected it to use the live AI provider.
After tracing the request flow, we found two separate issues:
Frontend ↓Mock mode enabled by default ↓Canned analysisand independently:
Production API ↓Gemini configuration ↓Runtime configuration neededWe changed the frontend architecture so that mock mode is now:
EXPLICIT OPT-INrather than:
DEFAULT BEHAVIORThis means production failures should surface as actual failures instead of silently turning into demo data.
That experience reinforced an important engineering principle for us:
A production application should fail honestly.
Development shortcuts are useful, but they should never silently masquerade as production results.
Designing for trustworthy AI
VeriFYI isn't just an AI wrapper.
The model is one component inside a larger system.
The verification contract defines the expected structure:
VerificationResult│├── Overall Status├── Summary├── Claims│ ├── Claim│ ├── Category│ ├── Status│ ├── Confidence│ ├── Explanation│ ├── Evidence│ └── Recommended Action│└── Recommended ActionsThis gives the frontend a predictable structure regardless of the underlying model.
It also allows us to validate model output before it reaches the user.
The result is a pipeline where:
AI interpretation ↓Validation ↓Structured contract ↓User-facing reportThe AI is powerful, but the surrounding software determines what the application is actually willing to trust.
Why we didn't build another scam detector
We deliberately avoided reducing VeriFYI to:
"This message is 87% likely to be a scam."
A single score hides too much information.
Suppose two messages both receive a high-risk result.
A user still needs to know:
- Which claim caused concern?
- What evidence supports that finding?
- Which claims couldn't be verified?
- What should they check next?
VeriFYI therefore focuses on claim-level transparency.
For example:
CLAIM
"The message requests a Rs 1,500 onboarding fee."
STATUS
SUPPORTED
EVIDENCE
"Pay Rs 1,500 onboarding fee."
ACTION
Avoid sending payment before independently verifying the opportunity.The user can inspect the evidence instead of simply trusting a number.
What we learned building it
The biggest lesson from VeriFYI was that building an AI application is not just about choosing a model.
The harder engineering questions were around trust boundaries.
We had to think about:
- What counts as evidence?
- What happens when evidence is missing?
- How do we prevent fabricated quotations?
- How do we prevent invented URLs?
- What happens when an AI provider is unavailable?
- How do we keep mock data from reaching production?
- How do we protect API keys?
- How do we make model-provider changes without rewriting the application?
These questions shaped the architecture more than the model choice itself.
Security considerations
We also treated the AI API key as a server-side secret.
The Gemini API key is stored in the deployment environment and is not exposed through a
NEXT_PUBLIC_* variable.The application does not intentionally log the API key.
The repository also excludes local environment files from version control.
This gives us a clear separation:
Client │ │ User input ▼Server │ ├── AI credentials ├── AI provider ├── Validation └── AWS integrations │ ▼ResultThe browser receives the verification result, not the provider credentials.
What's next for VeriFYI?
The current version focuses on text-based verification.
The next step is making the system work with richer evidence.
We are exploring:
Screenshot verification
Users could upload screenshots of recruiter messages or opportunity announcements.
PDF verification
Users could submit offer letters, scholarship documents, or other opportunity-related PDFs.
Evidence extraction
An ingestion layer could extract text from uploaded documents before passing the relevant claims into the verification pipeline.
AWS-native ingestion
The architecture is designed to extend toward services such as:
- Amazon S3 for document storage
- Amazon Textract for document text extraction
These are future extensions rather than components of the current live text-analysis workflow.
More evidence sources
The next stage is also to introduce real external retrieval so claims can be checked against authoritative sources.
The key requirement remains the same:
External evidence must come from an actual retrieval system, not from the language model inventing a source.
From prototype to production
One of the most rewarding parts of this project was taking the idea beyond a local prototype.
The final architecture combines:
Next.jsReactTypeScriptGemini 2.5 FlashAWS AmplifyAmazon DynamoDBAWS SDK for JavaScriptStructured loggingAnti-fabrication validationThe result is not simply an AI chatbot.
It is a verification workflow built around a stricter principle:
CLAIM ↓EVIDENCE ↓STATUS ↓EXPLANATION ↓ACTIONA huge part of this journey was building and iterating on VeriFYI alongside my teammate Jayashankar P.
Final thoughts
The internet is full of information that looks convincing.
AI makes generating convincing information even easier.
That makes verification more important, not less.
With VeriFYI, we wanted to build a system that doesn't ask users to blindly trust an AI-generated verdict.
Instead, it asks a different question:
What can we actually verify?
If there is evidence, show it.
If the evidence contradicts the claim, show that.
If there isn't enough evidence, say:
UNVERIFIED.
That is the philosophy behind VeriFYI.
Don't just trust it. Verify it.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article