DEV Community: Gourav

A Privacy-First Local Price Comparator (Open-Source AI Side Hustle)

Gourav — Wed, 14 Oct 2026 07:23:03 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

I built a Privacy-First Price Comparator—a local AI tool that helps users find the best deals without sacrificing their personal data.

Most popular price-tracking extensions operate on a data theft model: they give you discounts, but they harvest your browsing history, shopping habits, and personal profiles to sell to advertisers. Even worse, some platforms use your search history to dynamically inflate prices.

This tool is designed for privacy-conscious shoppers, freelance procurement agents, and businesses who want to compare prices across e-commerce sites securely. They would pay a small one-time fee or subscription for a tool that runs entirely on their own machine, guaranteeing their data never leaves their laptop.

How I Built It

Instead of relying on centralized APIs that log user queries, this project uses local inference.

The Engine: It uses an open-weight model (like Google's Gemma) running locally.

The Process: The user feeds a product URL into the tool. The tool scrapes the raw HTML of the product pages (using standard Python scraping libraries).

The AI: The local AI model is prompted to parse the messy HTML, extract the exact price, shipping costs, and product specs, and output a clean JSON comparison—all without any data ever pinging an external server.

Why Does Open Innovation Matter?

Open innovation is the only way this product can exist.

If I built this using a closed API (like OpenAI or Anthropic), I would just be trading one privacy nightmare for another—sending my users' entire shopping intent and raw webpage data to a massive tech corporation.

By using open-weight models running locally, open innovation allows for absolute data sovereignty. It proves that we don't have to surrender our privacy just to get a good deal on the internet.

Prize Categories

Open Source AI Side Hustle

TouchGrass : Building an Offline Plant Doctor with React, FastAPI, & Open-Weight AI

Gourav — Thu, 08 Oct 2026 18:19:41 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

The "Touch Grass" Moment
Lately, my days have been an endless loop of staring at screens—juggling React/FastAPI projects, grinding LeetCode, and preparing for the GATE CS exams. My only real break is stepping out onto the balcony to check on my plants, mainly my Tulsi and Money plant.

A few days ago, I noticed the leaves on my Tulsi were turning slightly yellow, and the Money plant looked a bit droopy. I wanted to use a vision AI to diagnose them, but it hit me: why should I send photos of my home balcony to a massive corporate cloud server just to figure out if my plant needs water or magnesium? Plus, my Wi-Fi is notoriously spotty out there.

That’s when I realized the perfect fit for the Touch Grass challenge: an entirely offline, open-weight plant health assistant. A tool that forces you to step away from the IDE, walk into your garden, and interact with nature, all while keeping your data strictly local.

What I Built

I built FloraLense (or whatever you want to name it), a local-first web application that diagnoses plant health using open-source AI.

Demo

Code

https://github.com/bluea1855/FloraLense

How I Built It

Here is the stack I used:
Frontend: React.js and Tailwind CSS, built as a Progressive Web App (PWA) so I can use it like a native app on my phone while out on the balcony.

Backend: FastAPI (Python) serving as a lightweight API layer.

The AI Core: I integrated Google's Gemma (specifically a lightweight open-weight vision model) running entirely locally via my backend.

Why Does Open Innovation Matter?

This project wouldn't make sense if it wasn't open-source and running locally.

Absolute Privacy: Gardening is a personal, at-home activity. By using open-weight models, image inference happens directly on my own machine. Zero images are sent to third-party APIs.

No Dead Zones: You don't need a 5G connection in the middle of a park or a backyard to figure out what's wrong with a leaf.

Tinker-Friendly: Because the weights are open, I can eventually fine-tune the model specifically on Indian household plants (like Tulsi, Neem, or Curry leaves) which general cloud models sometimes misidentify.

Prize Categories

Best Use of Gemma: For utilizing the open-weight model to perform local, offline vision inference.
Best Use of Render: For Deploying backend on render

PrepWise AI: An Open-Source Current Affairs Tutor for Exam Prep

Gourav — Sun, 04 Oct 2026 08:46:47 +0000

What I Built & Who I Built It For

My friend Geet is rigorously preparing for competitive exams, and one of her biggest daily struggles is keeping up with "Current Affairs." Every day, she spends hours hunting for relevant news across portals and then tries to test herself. It’s a tedious, manual process that eats into her core study time.

To solve this, I built PrepWise AI for her. It’s a fully automated, open-source-powered platform that fetches the daily top news, stores it, and generates dynamic, on-demand mock tests. When Geet finishes a test, the AI doesn't just give him a score—it evaluates her answers and explains why a specific option is correct based on the latest news context.

Live Demo: https://shawty-prepwise.vercel.app/
GitHub Repository: https://github.com/bluea1855/prepwise

Screenshots

Why Open Innovation Matters for This Project

For an education tool meant for students, closed-ecosystem AI models are often too expensive and opaque. By using Google's open-weight Gemma model, I achieved three critical things:

Cost-Efficiency: Students can't afford expensive API calls for daily practice. Open-weight models like Gemma allow us to generate high-quality MCQ evaluations at zero or near-zero cost.
Transparency: In competitive exams, facts matter. With an open-source AI, I have complete control over the system prompt and temperature, ensuring the AI relies strictly on the fetched news context rather than hallucinating answers.
Future Fine-Tuning: As Geet's exams get closer, I plan to fine-tune this Gemma model specifically on historical exam papers, something that is incredibly restrictive with closed models.

How It Works (The Architecture)

I had a tight 12-hour window to build this, so I utilized an automated microservices approach:

The Automation: A Python script runs via a GitHub Actions Cron Job every midnight. It uses SerpApi to fetch the top 10 daily current affairs (India & International).
The Data Layer: The fetched news is instantly securely stored in a MongoDB Atlas collection, serving as our zero-latency knowledge base.
The Backend: A fast, lightweight Python backend deployed on Render using FastAPI.
The AI Brain: When Geet submits her test, the backend pulls the relevant news context from MongoDB and passes it to the Gemma 2B model to evaluate the answers and generate detailed explanations.
The Frontend: A responsive React application providing a distraction-free testing environment.

Prize Categories I'm Entering

Best Use of Render: The FastAPI backend handling the AI evaluations and database connections is hosted seamlessly on Render.
Best Use of Gemma: Used as the core evaluation engine to provide natural language explanations for the generated mock tests.
Best Use of SerpApi: Powers the automated daily data-pipeline to fetch high-quality, real-time Google News results without manual intervention.
Best Use of MongoDB Atlas: Acts as the reliable data layer holding our daily current affairs repository.
Best Use of GitHub Copilot: I heavily utilized Copilot to rapidly prototype the React UI components and write the GitHub Actions workflow YAML file for the midnight cron job.

Building this for a friend made this weekend hackathon incredibly fulfilling. I can't wait to see how it improves his mock scores!