Beacon Hub: Turning Opportunity Overload Into a Plan

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

What I Built

A friend of mine, let's call her P, is building a career in cybersecurity and AI. She doesn't have a problem finding opportunities in her domain. In fact, they're everywhere. The problem is keeping track of them.

She would save hackathons, internships, courses and certifications across different tabs, bookmarks and messages, then eventually lose track of what she had actually signed up for. Sometimes she'd find something after the deadline had already passed.

Keeping track of everything became overwhelming, so I built Beacon Hub for her.

What it changes for P is that instead of a pile of tabs, she sees ten cards at a time. She chooses separately what goes on her To-Do list and what goes on her Calendar, and ticking something off moves it to a Completed stack instead of deleting it. When the app doesn't know a date, the card says "dates missing, check the link", so she can trust the dates it does show.

Beacon Hub brings all these opportunities together in one place, in a format that feels simplified and easier to work through.

Demo

Here's the demo link- https://beacon-hub-e3ag.onrender.com/
Live demo

Hosted on Render's free tier. The first load can take about a minute while the service wakes up, and the hosted SQLite database should be treated as a temporary shared demo rather than persistent personal storage.

The hosted version contains the 101-opportunity snapshot I collected locally. Gemma runs locally through Ollama during the discovery and extraction process, so the hosted demo does not need to run the 4B model or expose my SerpApi key.

Code

hanfaimran / beacon-hub

beacon-hub

Find → Save → Plan → Do.

Beacon Hub is a personal opportunity tracker built for a friend who was overwhelmed by the number of hackathons, internships, courses, certifications and events she wanted to keep track of.

It brings opportunities across Cybersecurity, AI and Cloud into one place, so users can discover opportunities, save the ones they care about, plan deadlines and track what they have completed.

Demo

Live: https://beacon-hub-e3ag.onrender.com/

Hosted on Render's free tier. The first load may take around a minute if the service is sleeping.

The hosted version contains a snapshot of 101 opportunities collected locally. Gemma runs locally during the discovery and extraction process.

The hosted SQLite database is intended for demonstration purposes and should not be treated as persistent personal storage.

Features

• 🔎 Discover opportunities across Cybersecurity, AI and Cloud
• 🏷️ Filter by events, hackathons, courses, internships, certifications and more
• 📄 Browse 10 opportunities…

View on GitHub

How I Built It

Beacon Hub uses Gemma 3 4B, an open-weight model running locally through Ollama. I built it on a 16 GB laptop without a GPU, so I designed the system to keep the model's job small and predictable.

The core idea is:
Code finds the facts. Gemma handles ambiguity. Code verifies the result.

The pipeline

1. SerpApi searches for Cybersecurity, AI and Cloud opportunities. Results are cached and logged, with a hard search cap to protect the quota.

1. The application fetches relevant public pages and converts them into text. Irrelevant sources are filtered, and LinkedIn pages are never fetched.
2. Code extracts candidate dates using regex and dateparser. A date must actually appear in the source text.
3. Code looks at the surrounding text to determine whether a date is likely an application deadline, event date, start date, etc.
4. Gemma 3 4B via Ollama handles ambiguous cases. It receives a small prompt at temperature 0 and chooses between dates that the code has already found.
5. Pydantic and application code validate the result. If information cannot be confirmed, it stays missing instead of being guessed.
6. The verified opportunities are stored in SQLite and served through FastAPI to the frontend.

The rest of the stack

• FastAPI for the backend and API
• Vanilla HTML, CSS and JavaScript for the frontend
• SQLite for opportunities, To-Do items and Calendar data
• Temporal for optional durable reminders
• Render for the hosted demo

Reminders are calculated by code and scheduled through Temporal, so the LLM never decides when a user should be reminded.

I also added validation and security checks around the pipeline. External pages are treated as untrusted input, the model has no tools to call, API keys stay server-side, and dynamic opportunity data is rendered with textContent rather than innerHTML.

What went wrong

A few problems shaped the final design:

• Ollama was streaming responses and breaking my JSON parser, so I disabled streaming.
• Gemma returned dates as prose, so I moved date selection into code.
• A database path change caused the app to read an empty database, which I caught before deployment.
• Search results contained irrelevant pages, so I added source and topic filtering. The result was a system where the AI does less, but what it does is easier to control and verify.

Shortcomings

1. It's a snapshot from [date] and doesn't refresh itself. New results need a SerpApi key and a local Gemma model. To refresh your own copy, clear cache/ and rerun python -m app.seed ai (also cyber and cloud).
2. It's a small catalog that relies on SerpApi's free plan, and it's built for one user at a time.
3. It fetches single public pages from search results and doesn't crawl.

Why Does Open Innovation Matter?

This is probably the part of Beacon Hub I care about most. I didn't use an open model just because the challenge asked for one. The fact that Gemma could run locally changed what I was able to build.

I could install the model on my own laptop, experiment with it, change the prompts, change its role in the pipeline, and run the whole extraction process without needing a paid AI API.

That mattered because Beacon Hub deals with something personal: someone's career plans, saved opportunities, and deadlines.
With local inference, the core AI processing can stay on the user's machine.

But the bigger advantage was control. A closed API might have made it tempting to send an entire webpage to a powerful model and ask it to extract everything. With a 4B model running locally, I had to think much more carefully about what the model should actually be responsible for.

That led to a better architecture:
Code finds the facts. Gemma handles ambiguity. Code verifies the result.

The model is also replaceable. If someone wants to run a different Ollama-compatible model, the application doesn't need to be rebuilt around a proprietary API.
Open innovation made the AI layer something I could inspect, experiment with, constrain, and run myself, rather than a black box sitting behind an API call.
That's what made it _valuable _for this project.

My Agent Session

I built Beacon Hub with Google Antigravity and used it throughout the project for coding, debugging, and figuring things out as I went. The project was built pretty much one problem at a time: build, test, break, fix, repeat.

Prize Categories

• Best Use of Temporal: Reminders run as Temporal workflows. Adding an item to the To-Do list starts one, which waits on durable timers and then posts the reminder in the app. Removing or completing the item cancels it. Plain code decides when reminders fire, never the LLM. I tested it with short demo timers, and the screenshots above show those runs in Temporal's dashboard.
• Best Use of SerpApi: Used to discover Cybersecurity, AI and Cloud opportunities.
• Best Use of Gemma: Gemma 3 4B runs locally through Ollama for opportunity extraction and date disambiguation.
• Best Use of Render: Used to host the live demo.

SOLO project submission. One woman army!!💪

Here's what my friend said about the project--