Notice2Action: Turn Any Important Notice into Clear Next Steps with Gemma

LUCKY — Sun, 04 Oct 2026 06:40:39 +0000

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

The Problem: The "Wall of Text" Penalty

My friend Vishwa has a problem that I think a lot of students can relate to.

He doesn't usually miss opportunities because he doesn't care about them. He misses them because the important information is often buried inside a huge PDF.

A scholarship deadline might be somewhere on page 3 of a college circular. A hackathon announcement might mention the registration link at the bottom and the required NOC somewhere in the middle. An internship opportunity might have five different requirements scattered across several paragraphs.

And when you have to read four pages just to find two things that actually matter, it's very easy to think: "I'll read it later."

And sometimes, later is after the deadline.

That was the problem I wanted to solve. I didn't want to build Vishwa another AI chatbot where he uploads a PDF and asks: "What does this notice mean?"

I wanted to flip the whole workflow.

Instead of asking "What does this notice mean?", the tool should answer "What does this mean for YOU, and what exactly should you do next?"

So I built Notice2Action.

What I Built

Notice2Action is a small AI-powered web app that turns long and confusing notices into a simple, personalized action plan.

It can take a:

PDF
Text file
Pasted notice

...and combine it with a little context about the person receiving the notice. Then Gemma turns that information into things that are actually useful:

Deadline - When do you need to act?
Eligibility - Do you appear to meet the requirements?
Documents - What do you need to collect?
Warnings - What information is still missing or needs to be verified?
Action Plan - What should you do first, second, and third?
Friend Message - A short message that can be shared with the person.

The goal isn't to create another summary. The goal is to reduce the distance between "I received this notice" and "I know exactly what I need to do."

The basic idea:

Long/confusing notice → Gemma 4 → Understand the notice → Extract deadlines & requirements → Compare with friend's info → Find missing data → Create action plan

Try It Yourself

Live Demo
👉 Vercel (Instant): https://notice2action-pi.vercel.app/
👉 Render: https://notice2action-7pjr.onrender.com/
(The Render deployment is on a free-tier instance, so it can take a little while to wake up if it hasn't been used recently.)

The easiest way to understand Notice2Action is honestly just to try it with a long notice. Take a scholarship announcement, hackathon circular, or internship announcement. Instead of reading the entire thing first, give it to Notice2Action and see what it pulls out.

What Does the Output Actually Look Like?

Imagine a scholarship notice says that students need to meet a certain eligibility condition, submit some documents, get an NOC, and apply before Thursday.

A normal summarizer might give you a paragraph explaining the scholarship. Notice2Action tries to turn that into something more practical:

DEADLINE: Thursday

ELIGIBILITY: Check whether you satisfy the requirements mentioned in the notice.

DOCUMENTS: Student ID, Required certificate, HOD NOC

WARNING: Your profile doesn't contain enough information to confirm one of the eligibility conditions.

ACTION PLAN:

Check your eligibility.

Request the HOD NOC.

Collect the required documents.

Submit the application before Thursday.

That's the difference I was trying to build.

Not just "here's what the document says."

But: "Here's what the document means for you."

Why I Built It for Vishwa

This part matters because the challenge is Build for a Friend.

I didn't start with: "What AI product should I build this weekend?" I started with a person.

I already knew Vishwa had this problem. He gets the same kind of college notices that most students get - PDFs, WhatsApp messages, and long documents where the important information is mixed with everything else.

So instead of building a generic productivity app and then trying to find a user for it, I decided to build something specifically around the problem I had already seen.

Can I make it easier for my friend to stop missing important opportunities?

That became Notice2Action.

How I Built It

I wanted to keep the stack relatively simple so I could spend more time actually solving the problem. The main stack is:

Next.js App Router (React, TypeScript)
Google GenAI SDK (Gemma 4)
pdf-parse (for text extraction)
Custom responsive CSS
Vercel / Render

The flow is basically:
PDF + Friend Profile → Next.js API Route → Extract text → Send to Gemma → Structured JSON → React UI

The important thing here is that Gemma isn't just sitting behind an "Ask AI" button. Gemma is doing the main transformation that makes the product useful.

One of the First Problems: PDF "String Soup"

One thing I learned while building this is that PDFs are messy. When you extract text from a typical college circular, you don't necessarily get clean paragraphs. Tables can get flattened, headings merge, and footers end up in strange places.

Instead of something beautiful, the application receives something closer to:
ScholarshipApplications2026...lastdate...studentsmust...documentsrequired...Page3...

Basically, string soup. That made the AI side more interesting. I couldn't just tell Gemma to "Summarize this." I needed it to understand what information actually mattered.

Making Gemma Useful to the UI

Another thing I wanted to avoid was getting one huge AI-generated paragraph. The interface has separate sections for deadlines, eligibility, documents, warnings, and action steps.

So I designed the Gemma response around structured information. The frontend then takes that structured result (JSON) and turns it into the cards and sections you see in the interface.

The Part I Cared About Most: Knowing When It Doesn't Know

This was probably one of my most important design decisions. AI can sound extremely confident even when it doesn't have enough information.

Imagine a scholarship notice says: Family income must be below ₹3,00,000.
But I don't know Vishwa's family income.

The app shouldn't say: "You are eligible." That would be making something up. Instead, Notice2Action should tell the user: "This requirement still needs to be verified."

If something important is missing, the app surfaces it as a warning. I think that's much more useful than pretending the AI knows everything. Uncertainty should be visible.

Why Gemma?

Gemma isn't just an AI feature added to the project because the challenge mentions AI. It is the part that turns an unstructured notice into a personalized decision and action plan.

If I remove Gemma, I don't just lose a chatbot. I lose the main transformation that makes Notice2Action what it is. That's why I'm entering Best Use of Gemma.

Why Open Innovation Matters

For me, the interesting part of using an open-weight model isn't simply saying: "My project uses open-source AI." It's what that choice makes possible.

This MVP currently uses hosted Gemma inference to get a working product into Vishwa's hands quickly. But an open-weight model gives the project room to move in different directions later:

Local inference for more privacy and better control over sensitive documents.
Self-hosting: Deploying under infrastructure controlled by a university or individual.
Task-specific improvements: Fine-tuning for specific categories like scholarships or government schemes.

The open-weight foundation gives Notice2Action a path toward more controlled deployment in the future.

Then I Actually Gave It to My Friend

This was my favorite part of the project. I didn't want to finish the website, look at it myself, and decide it was useful. I gave Notice2Action to Vishwa, asked him to grab a real notice, and tested it.

And this was his reaction:

"Bro, this is actually insane. I literally just pasted that massive 4-page PDF about the upcoming hackathon and it just gave me the registration link and told me I need a NOC from the HOD by Thursday. I usually miss this stuff because I hate reading those circulars. This is going to save my life this semester."

The part that stood out to me wasn't even the compliment.

It was that he immediately mentioned the NOC requirement and the Thursday deadline.

Those were exactly the kinds of details I wanted the app to surface.

What I Learned From That

Before building this, I thought the main value would be summarizing long notices. After seeing Vishwa use it, I realized that wasn't really the important part.

He didn't need another four-paragraph explanation. He needed to know:
What is this? → Does it apply to me? → What do I need? → What am I missing? → What should I do now?

The goal isn't to create a prettier summary. The goal is to remove the friction between receiving a confusing notice and knowing what to do next.

What's Next?

This is still a weekend MVP, so there are a lot of things I'd like to improve:

Better document understanding for image-heavy notices.
Multilingual support for regional-language notices.
Local inference for more privacy and better control over sensitive documents.
Calendar integration to turn deadlines into reminders with one click.

I'd rather make one workflow really good: Receive something confusing → understand what matters → know what to do next.

Prize Categories

Overall Winner
I'm entering Notice2Action for the overall Hacktoberfest Weekend Challenge: Build for a Friend. The project started with one real person, one real frustration, and one weekend-sized attempt to solve it.

Best Use of Gemma
I'm also entering Best Use of Gemma. Gemma isn't an optional chatbot layer in Notice2Action. It is responsible for the central transformation in the product: extracting information, identifying eligibility, surfacing warnings, and structuring action plans.

So, What's the Point?

I didn't start this project thinking I was going to build an AI startup this weekend.

I started with something much smaller:

"Can I make it easier for my friend to stop missing important opportunities?"

I built a first version.

I gave it to him.

He tried it with a real notice.

And the feedback made me realize that this wasn't just a demo sitting on my laptop.

It was actually solving a small problem in his day-to-day life.

That's what I wanted from this challenge.

Not a giant product.

Not a complicated AI demo.

Not another chatbot with an AI label on it.

Just a real problem, a real person, and something useful built in a weekend.

Built for a friend. Built during the Hacktoberfest Weekend Challenge.

Code

Lucky-Quantum / notice2action

Notice2Action

From “What does this notice mean?” to “Here is exactly what to do next.”

Notice2Action is a friend-first AI tool for students and young adults who regularly miss scholarships, internships, college opportunities, community programs, and other time-sensitive notices because the source material is long, confusing, or buried inside screenshots and chats.

Instead of giving another generic summary, Notice2Action turns a notice into a personalized decision-and-action layer: what matters, whether the person appears eligible, what documents are needed, what could be missing, what to do next, and a short message they can send to their friend.

Hacktoberfest 2026 — Weekend Challenge

Theme: Build for a Friend

Notice2Action was started as a new project for the Hacktoberfest Weekend Challenge entry window (October 2–5, 2026). It is being developed specifically around a real friend-first problem rather than as a pull request to an existing project.

The problem

Important opportunities…

View on GitHub

DEV Community: LUCKY