DEV Community: Rishabh shukla

SANKALP: I Built an AI That Turns School Concepts into Interactive 3D Experiences

Rishabh shukla — Sun, 04 Oct 2026 06:09:42 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built SANKALP for my younger brother, who is currently around Class 6.

While helping him study, I noticed that he could read a chapter, look at a textbook diagram, and still struggle to understand the actual concept.
Take something as simple as a mitochondrion.

A textbook gives you a 2D diagram with labels like outer membrane, inner membrane, cristae, and matrix. I can explain what each part does, but the moment he has to imagine how those structures are actually arranged in three dimensions, it becomes much harder.

The same problem comes up with the human heart, engines, and many other concepts where understanding how different parts fit together matters more than simply memorising a picture.

At some point, instead of saying, "Look at the diagram again," we asked:

What if the diagram didn't have to stay 2D?
That became SANKALP.
SANKALP is an AI-powered 3D visualization system designed for students from Class 1 to Class 12.
A student enters a topic or query, and SANKALP attempts to turn that concept into something they can actually see, rotate, explore, and understand in 3D.
The goal isn't simply to generate a visually impressive model.
The goal is better understanding.
A student should be able to go from:

"What is a mitochondrion?"
to:
"Now I can actually see how its different parts are arranged."
That is the problem SANKALP is trying to solve.

Live Demo

[https://sankalp2.vercel.app/]

Video Demo

[https://drive.google.com/file/d/14f5mbDT4jmmLcESnkNdyOZx6WiRcRr1Q/view?usp=drive_link]
The demo shows the journey from a student's query to a retrieved or generated 3D learning experience and interactive exploration.

GitHub Repository

Fumer057/SANKALP
The repository contains the complete full-stack implementation, including the frontend, FastAPI backend, retrieval pipeline, semantic validation, 3D asset handling, and generative fallback.

How I Built It

The core idea behind SANKALP is a hybrid retrieval + generation architecture.

We didn't want every query to trigger generation when a suitable resource already exists.
So the system first tries to retrieve relevant information and existing 3D assets.

Those candidate assets are then evaluated using an AI-based semantic validation layer to determine whether they actually match the student's query.

If a candidate crosses the configured confidence threshold, SANKALP serves it directly.
If no suitable candidate is found, the system falls back to AI-based 3D generation using Shap-E.

Retrieve when we can. Generate when we need to.

Query Understanding

The pipeline starts with a natural-language query from the student.
For example:

"Show me a 3D model of a human heart."

The system processes the query to identify the main entity, category information, and descriptive visual properties that can be used during retrieval.

Retrieval

SANKALP searches across multiple sources instead of depending on a single repository.
It can work with:

Local SQLite-backed cached assets.
Curated model sources.
Sketchfab.
Public CDNs.
Three.js public repositories.

This retrieval-first approach allows the system to reuse an existing model when an appropriate one is already available.

Semantic Validation

Finding a 3D model is not enough.
A retrieved asset might technically match the search term while still being irrelevant to the actual request.
SANKALP therefore uses an AI-based validation layer to compare the candidate metadata with the original query and calculate a normalized confidence score.
Only models that satisfy the configured relevance threshold are selected for delivery.

Generative Fallback

When retrieval does not produce a suitable asset, SANKALP falls back to Hugging Face Shap-E to generate a 3D representation.
This means the system is not restricted to whatever models already exist in public repositories.
It has a second path when the retrieval path comes up empty.

Interactive 3D Experience

Once an appropriate asset has been selected or generated, it is rendered through an interactive browser-based 3D viewer.
The viewer is built using:

Three.js
React Three Fiber
Drei

Students can rotate, inspect, and explore the model instead of trying to mentally reconstruct a three-dimensional object from a static textbook image.

Why Does Open Innovation Matter?

Open innovation is a big part of why SANKALP was possible to build.
The project combines several different areas:

AI
Natural-language understanding, semantic expansion, validation, and generative 3D.

Information Retrieval
Finding relevant knowledge and models from multiple sources.

3D Graphics
Rendering and interacting with models in the browser.

Backend Engineering
Connecting all of those pieces into one reliable pipeline.
Using open technologies allowed us to combine these pieces without building everything from scratch or depending entirely on one proprietary platform.
We can use FastAPI for the backend, React and Next.js for the application layer, Three.js and React Three Fiber for 3D rendering, SQLite for local caching, and Shap-E as a generative fallback.

That freedom is important for a student-built project.
We can experiment with the retrieval strategy.
We can change the validation threshold.
We can replace an asset source.
We can try a different model.
We can improve one stage without rebuilding everything around a single closed system.
Open innovation turns:

"Someone should build this."
into:
"Let's build it ourselves."
And for SANKALP, that freedom was essential.

My Agent Session

A large part of the development involved AI-assisted engineering.
The agent helped with architecture exploration, implementation, debugging, integration between the frontend and backend, and iterating on different stages of the AI and 3D pipeline.

The Hand-over

The reason I built SANKALP was not a benchmark.
It started with my younger brother struggling to understand a diagram.
I could explain the same concept five different ways.
I could show him another image.
I could draw it again.
But he still had to imagine the missing dimension.
That was the moment the idea clicked.
Maybe the problem wasn't that he needed another explanation.
Maybe he needed a different representation of the explanation.
With SANKALP, the question changes.

Instead of asking him to imagine what the inside of a heart looks like, I can give him a 3D representation and let him explore it.
Instead of asking him to memorise another mitochondria diagram, he can actually look around the structure
And that is the part that matters to me.
I didn't build SANKALP because I wanted students to see more 3D models.
I built it because I wanted them to understand more.

Future Vision

SANKALP is designed with Class 1 to Class 12 education in mind.
The long-term goal is to make difficult concepts across subjects easier to understand through interactive visualization.
Imagine a student asking:

"How does a combustion engine work?"
and exploring the engine in 3D.

Or:

"Show me how blood flows through the heart."
and following the flow interactively.
Or:

"Explain the structure of a cell."
and seeing the entire structure spatially instead of staring at another flat diagram.
The bigger vision is to make interactive 3D visualization another layer of education, especially for concepts that are difficult to understand through text and static images alone.

My hope is that one day a student can simply type:

"I don't understand this."

And SANKALP can respond:

"Let's visualize it."

Prize Categories

#devchallengesvg
#weekendchallengesvg
#hf26challenge

[Render]

# Second Look: I Built a Scam Checker for My Mom After She Sent Me a ₹10k Payment Screenshot

Rishabh shukla — Sat, 03 Oct 2026 14:30:23 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

A small AI safety layer for the people in our families who get asked to "just click this once."

What I Built

I built Second Look for my mom.
The idea started from a situation that feels very familiar in a lot of Indian families.
She gets a suspicious message.
She isn't sure whether it is real.
And the first thing she does is send it to me.

"Is this genuine?"

So I thought about what that interaction could look like in a worst-case scenario.
Imagine opening WhatsApp and seeing a screenshot of a ₹10,000 payment.
The message underneath says:

"Your bank KYC has expired. Your account will be blocked today. Verify immediately using the link below."

There is a link.
There is a transaction reference.
There is a familiar-looking bank name.
And there is one thing the message is really good at creating:

Urgency.

The screenshot used with this post is the real one that my mom talked about
The important part isn't the exact ₹10k amount.
It's the question that comes after seeing something like that:

"Should I click this?"

That's the question I wanted to make easier to answer.
I didn't want to build another cybersecurity dashboard filled with technical indicators that only security professionals understand.
I wanted something my mom could actually use.

So I built Second Look.

What Is Second Look?

Second Look is a small AI-powered scam checker that lets a user paste a suspicious SMS or WhatsApp message, or upload a screenshot, and get a clear, understandable verdict.

The application gives three simple outcomes:

🚨 Scam

Strong indicators of fraud or social engineering were detected.

⚠️ Be Careful

The message contains suspicious elements and should be verified before taking action.

✅ Looks OK

Nothing strongly suspicious was identified from the information available.
But the verdict itself isn't the important part.

Second Look also explains:

Why does this look suspicious?

What should I do next?

What should I avoid doing?

And if the person still isn't comfortable making that decision alone, they can use:

"Send to my family"

to share the result with someone they trust.

So the experience becomes:

Suspicious Message
        │
        ▼
   Second Look
        │
        ▼
 Understand the Risk
        │
        ▼
   What To Do Next
        │
        ├────────────────┐
        ▼                ▼
   Take Action       Ask Family

I didn't want AI to replace the person you trust.
I wanted it to make the first check faster and easier.

The Problem I Wanted to Solve

Scam messages are often effective precisely because they don't look obviously fake.
They create pressure.
They use familiar language.
They mention things people recognize:

KYC
UPI
Banks
Courier deliveries
Account verification
Refunds
Jobs
Government notices

A person receiving one of these messages doesn't necessarily need a lesson in cybersecurity.
They need an answer to a much simpler question:

"What is happening, and what should I do right now?"

That's how I approached Second Look.
Instead of giving the user:

"This message exhibits characteristics of credential harvesting and social engineering."

the application should explain the situation in plain language.

Something closer to:

This message is creating urgency and asking you to verify your account through a link. Don't click it. Contact your bank through its official website or app instead.

That difference matters.
The model isn't there just to classify.
It is there to explain.

How It Works

Second Look accepts both text and screenshots.

That's important because suspicious content doesn't always arrive as clean, copyable text.
Sometimes it's an SMS.
Sometimes it's a WhatsApp message.
Sometimes someone sends you a screenshot and says:

"Look at this."

So the pipeline looks like this:

                         ┌────────────────────┐
                         │        USER        │
                         └──────────┬─────────┘
                                    │
                    ┌───────────────┴───────────────┐
                    │                               │
                    ▼                               ▼
              Paste Text                    Upload Screenshot
                    │                               │
                    └───────────────┬───────────────┘
                                    │
                                    ▼
                         ┌─────────────────────┐
                         │   Privacy Layer     │
                         │                     │
                         │ Card / PAN / Aadhaar│
                         │ / Account Redaction │
                         └──────────┬──────────┘
                                    │
                                    ▼
                           ┌──────────────────┐
                           │      Gemma       │
                           │  Multimodal AI   │
                           └─────────┬────────┘
                                     │
                                     ▼
                        ┌────────────────────────┐
                        │ Scam / Risk Analysis   │
                        │                        │
                        │ + Explanation          │
                        │ + Recommended Action   │
                        └───────────┬────────────┘
                                    │
                    ┌───────────────┼───────────────┐
                    │               │               │
                    ▼               ▼               ▼
                 🚨 Scam       ⚠️ Be Careful    ✅ Looks OK
                    │               │               │
                    └───────────────┼───────────────┘
                                    │
                                    ▼
                         ┌────────────────────┐
                         │  What should I do? │
                         └──────────┬─────────┘
                                    │
                       ┌────────────┴────────────┐
                       │                         │
                       ▼                         ▼
                   Read Aloud             Send to Family

The important architectural decision is that privacy comes before model inference.
That was deliberate.

Privacy Was Not an Afterthought

The messages we're dealing with can contain extremely sensitive information.
A bank message might contain:

Account information
Transaction details
Phone numbers
Card numbers
Identity information

So before anything reaches the model, Second Look redacts sensitive identifiers.

The application specifically handles things such as:

Card numbers
Aadhaar numbers
PAN numbers
Bank account numbers

The basic idea is:

Raw Message
     │
     ▼
Sensitive Data Redaction
     │
     ▼
Sanitized Message
     │
     ▼
Gemma
     │
     ▼
Verdict + Explanation

The model should get enough context to understand what is happening without unnecessarily receiving sensitive financial information.
That was a product requirement from the beginning, not something I wanted to bolt on later.

Why Gemma?

The core model powering Second Look is Gemma, Google's open-weight model.
I specifically wanted to build around an open model instead of making the entire application dependent on one closed API.
Second Look uses an OpenAI-compatible interface, which makes the model backend replaceable.

That gives the application two paths:

                         Second Look
                              │
                              ▼
                 OpenAI-Compatible Interface
                              │
                   ┌──────────┴──────────┐
                   │                     │
                   ▼                     ▼
              Hosted Gemma          Local Ollama
                                         │
                                         ▼
                                     Gemma 3 4B

The local path is especially interesting because it gives the application a route toward private local inference.

Fully Local Mode

Second Look can run with Ollama and Gemma locally.

ollama pull gemma3:4b

Then configure:

LLM_BASE_URL=http://localhost:11434/v1
LLM_API_KEY=
LLM_MODEL=gemma3:4b

And run the application locally:

python -m venv .venv

Windows

.venv\Scripts\activate

macOS / Linux

source .venv/bin/activate

Then:

pip install -r requirements.txt
uvicorn app:app --reload

Open:

http://localhost:8000

The important part is that the application code doesn't need to be rewritten just because the model moves from a hosted endpoint to a local Ollama instance.

Multimodal Input

One of the things I really wanted was screenshot support.
Because people don't always copy suspicious messages.
Sometimes the entire interaction is an image.

So Second Look supports:

Text
 │
 ▼
Gemma

and:

Screenshot
 │
 ▼
Multimodal Gemma
 │
 ▼
Analysis

This makes the system much closer to how people actually encounter suspicious content.

Scam Patterns

The application is tuned around scam patterns that are particularly relevant to users in India.

Some examples include:

KYC scams
UPI collect-request scams
Digital arrest scams
Courier scams
Task scams
Other common social-engineering attacks

The application can also surface the 1930 cyber-fraud helpline when appropriate.
This is not intended to be a universal cybercrime classifier.
It's meant to be a first layer of decision support before someone clicks, pays, shares credentials, or follows instructions from a suspicious message.

12 Languages

There was another problem I didn't want to ignore:

Language.

Security advice isn't very useful if the person receiving it has to translate it first.

Second Look supports responses in 12 languages, including:

Hindi
Tamil
Bengali
and more

The selected language is remembered.
So a user doesn't need to keep configuring the application every time they check another message.
The idea is simple:

Digital safety advice should be understandable in the language you actually use.

Voice Output

There is also a small accessibility feature that turned out to be useful.
The application can read the verdict aloud using the browser's built-in speech engine.

So instead of reading a long explanation on a phone screen:

Check Message
      │
      ▼
Get Verdict
      │
      ▼
Listen to Explanation
      │
      ▼
Take Action

No separate paid speech API is required.

Send to My Family

This is probably my favourite feature.
Because the answer isn't always:

"AI says Scam."

and the user immediately knows exactly what to do.
Sometimes they are still unsure.
And that's completely reasonable.
So Second Look has a:

"Send to my family"

button.

It can use WhatsApp or the device's native share sheet to send a short explanation to someone the user trusts.
That changes the workflow from:

"Send me the original message and I'll check it."

to:

"Run a Second Look first."

And if the person still wants another human opinion, the family is one tap away.

Suspicious Message
        │
        ▼
   Second Look
        │
        ▼
 AI Explanation
        │
   ┌────┴────┐
   │         │
   ▼         ▼
Understood  Unsure
               │
               ▼
        Send to Family

I didn't want AI to isolate the user from the people they trust.
I wanted it to make that interaction easier.

Recent Checks

Second Look can optionally use MongoDB Atlas for a family view of recent checks.
There is an important privacy distinction here:

The application stores verdicts, not the original messages.

So the family view can show recent results without turning the database into a permanent archive of private SMS and WhatsApp conversations.

Architecture

                         ┌──────────────────┐
                         │       USER       │
                         └─────────┬────────┘
                                   │
                    Text / Image / Screenshot
                                   │
                                   ▼
                         ┌──────────────────┐
                         │     FastAPI      │
                         └─────────┬────────┘
                                   │
                                   ▼
                        ┌────────────────────┐
                        │ Privacy Redaction  │
                        └─────────┬──────────┘
                                  │
                                  ▼
                         ┌──────────────────┐
                         │      Gemma       │
                         │ Multimodal Model │
                         └────────┬─────────┘
                                  │
                                  ▼
                       ┌─────────────────────┐
                       │ Risk + Explanation  │
                       └──────────┬──────────┘
                                  │
              ┌───────────────────┼───────────────────┐
              │                   │                   │
              ▼                   ▼                   ▼
           Verdict             Actions           Explanation
              │                   │                   │
              └───────────────────┼───────────────────┘
                                  │
                                  ▼
                         ┌──────────────────┐
                         │    Frontend      │
                         │  HTML/CSS/JS     │
                         └────────┬─────────┘
                                  │
                 ┌────────────────┼─────────────────┐
                 │                │                 │
                 ▼                ▼                 ▼
             Read Aloud      Family Share      Recent Checks
                                                (Optional DB)

Tech Stack

Backend

FastAPI
Python

Frontend

HTML
CSS
Vanilla JavaScript

AI

Gemma
OpenAI-compatible API

Local Inference

Ollama
Gemma 3 4B

Database

MongoDB Atlas (optional)

Deployment

Render

Repository

Fumer057/second-look

Why I Didn't Build a Giant Cybersecurity Platform

I could have built a much bigger application.
More dashboards.
More graphs.
More technical indicators.
More complicated scoring.
But that wasn't the point.
The person using Second Look isn't trying to become a cybersecurity analyst.
They're trying to answer:

"Can I trust this?"

So I kept the core interaction intentionally simple.

Upload
  ↓
Check
  ↓
Understand
  ↓
Act

The complexity stays behind the interface.

Why Does Open Innovation Matter?

This project is where open innovation becomes more than just a buzzword.
The messages we're analyzing can be incredibly private.
A bank notification.
A WhatsApp conversation.
A screenshot containing someone's financial information.
A suspicious UPI request.
Those aren't the kinds of things I want to blindly send to an unknown server.

Using an open-weight model gives Second Look another architecture:

Private Message
      │
      ▼
Second Look
      │
      ▼
Local Gemma
      │
      ▼
Result

The application can therefore move toward local inference when privacy requires it.
That's something I value much more than simply saying:

"We used AI."

Open innovation also gives us control over the architecture.
The model can change.
The inference provider can change.
The deployment can change.
The rest of the application doesn't need to be rebuilt from scratch.

The Model Is Not the Product

One of the biggest things I learned while building Second Look is that a model output is not a product.
A model can say:

"This looks like phishing."

But the user still has questions:

Why?

What should I avoid?

What should I do instead?

Can I ask someone I trust?

That's why the product is built around the entire decision-support flow rather than just the classification itself.

Detection
   ↓
Explanation
   ↓
Recommended Action
   ↓
Human Support

The AI is one component.

The experience around it is the actual product.

What I Learned

Building Second Look taught me something I wasn't expecting.
The hardest part wasn't integrating a model.
It wasn't building the FastAPI backend.
It wasn't getting screenshots into the pipeline.
The hardest part was deciding what the user actually needs to see.
A security system can technically identify something as suspicious and still fail the person using it.

Because knowing:

"This is suspicious."

is not the same as knowing:

"What should I do now?"

That distinction influenced almost every part of Second Look.

My Agent Session

Second Look was built with AI-assisted development throughout the process.
The agent helped with architecture exploration, implementation, debugging, integrating the model workflow, and iterating on the user experience.

DevRelay Agent Session

[Add your DevRelay agent session link here]

The Hand-over

The first version of Second Look started with something very ordinary.
My mom gets a suspicious message.
She isn't sure whether it is real.
She sends it to me.
I check it.
I reply:

"Don't click it."

Then the next suspicious message comes.
And we do the same thing again.
That made me realise something.
I was effectively acting as a human Second Look every time.
So I turned that interaction into the product.
Now the first step doesn't have to be:

"Send this to my son."

It can be:

"Let me take a Second Look."

And when the answer still isn't enough, the family is still there.
That was important to me.
Because I don't want the AI to become the person my mom trusts instead of me.
I want it to become the small tool that helps her decide when she should stop and ask.

The Story Behind the Name

The name came from the behaviour I wanted to encourage.
Not:

Trust the AI.

Not:

Ignore everything.

Just:

Take a second look before you act.

Because sometimes that extra ten seconds is enough to notice:

The link looks wrong.
The message is creating unnecessary urgency.
Someone is asking for sensitive information.
The payment request doesn't make sense.
The safest action is to stop.

The product is called Second Look for exactly that reason.

Future Vision

Right now, Second Look focuses on suspicious SMS messages, WhatsApp messages, and screenshots.
But I want to push the same idea further.
Imagine being able to right-click something suspicious on the web and ask:

"Second Look?"

Imagine taking a screenshot of an unfamiliar payment request and getting an explanation immediately.
Imagine a parent receiving a message in Hindi and being able to hear the explanation instead of reading it.
Imagine a family having a lightweight safety layer where parents can ask for help without having to understand cybersecurity terminology.
The larger idea isn't just scam detection.
It's a personal digital safety layer for people who don't want to become cybersecurity experts just to use the internet safely.

The Actual Goal

I didn't build Second Look to prove that Gemma can classify scam messages.
I built it because I don't want the people I care about to feel like they have to understand cybersecurity before they can safely use a phone.
The ideal outcome isn't:

"My mom trusts Second Look."

It's:

"My mom knows when to pause, understands why something looks suspicious, and knows who to ask when she's unsure."

The AI is simply there to help create that pause.

Try It

Live Demo

[*https://second-look-b2nu.onrender.com/]

GitHub

https://github.com/Fumer057/second-look

Run Locally

python -m venv .venv

Windows

.venv\Scripts\activate

macOS / Linux

source .venv/bin/activate

Then:

pip install -r requirements.txt
uvicorn app:app --reload

Open:

http://localhost:8000

Fully Local / Private Mode

ollama pull gemma3:4b

Then:

LLM_BASE_URL=http://localhost:11434/v1
LLM_API_KEY=
LLM_MODEL=gemma3:4b

Deploy on Render

Second Look includes a Render deployment configuration.
You can deploy directly from the repository:

Fumer057/second-look

Then configure the required model API environment variable for hosted inference.

Contributing

Second Look is intentionally small enough to understand and extend.

Contributions are welcome around:

New Indian scam patterns
Better multilingual support
Additional privacy protections
Multimodal improvements
Better explanations
Accessibility
Local model support
Additional deployment options

The goal is to keep improving the system around the actual user problem rather than turning it into a generic AI demo.

License

MIT

Final Thought

A scam doesn't need to fool a cybersecurity expert.
It only needs to convince someone to act before they think.
So I wanted to add one tiny step in between:

Message
   ↓
Pause
   ↓
Second Look
   ↓
Understand
   ↓
Decide

Before you click, take a Second Look.

Prize Categories

#devchallenge
#weekendchallenge
#hf26challenge

Render,Gemma,ElevenLabs