DEV Community: Shreshth Khetan

Zero-Cost Shopify Review Analyzer: A B2B Side Hustle Built with Local AI

Shreshth Khetan — Sun, 18 Oct 2026 22:57:25 +0000

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

What I Built

To build a successful side hustle, you need to solve a painful problem for people who are willing to pay. E-commerce store owners (like Shopify or Amazon sellers) are drowning in customer reviews. They desperately need to know what to fix to increase sales, but nobody has the time to manually read through hundreds of reviews.

I built the E-Commerce Review Insight Engine. It is a standalone web dashboard where a store owner uploads their raw customer reviews CSV. The app uses a local, open-weight AI model to instantly process the feedback and output a structured dashboard showing:

Top Customer Praises
Top Complaints (the urgent fires they need to put out)
An Actionable Business Plan

Store owners would absolutely pay a monthly subscription for this because it turns unstructured feedback into immediate revenue-saving actions.

The UI is built to be dead-simple for non-technical store owners: upload a file, click analyze, and get a dashboard.

Code

shreshth2906 / Shopify-Review-Sentiment-Analyzer

🛍️ E-Commerce Review Insight Engine

A 100% local, privacy-first AI dashboard for Shopify & DTC e-commerce merchants.
Built for the Hacktoberfest Side Hustle Challenge.

💡 Why This Project?

Most Shopify and DTC store owners receive hundreds of customer reviews every month through apps like Judge.me, Loox, Yotpo, or Shopify Reviews. However:

Cloud AI is expensive: Sending thousands of reviews to OpenAI or proprietary APIs incurs heavy recurring token costs.
Data privacy risks: Customer feedback often contains personal details, order IDs, and proprietary product feedback that brands prefer not to leak to third-party cloud AI vendors.
The Solution: The E-Commerce Review Insight Engine uses open-weight LLMs (llama3.2, gemma2) running 100% locally on your machine via Ollama. Zero API fees, zero cloud data transfer, and strict structured JSON business intelligence.

✨ Features

Zero API Costs & Total Privacy: Uses Ollama locally on your hardware.
Smart Column Detection: Automatically…

View on GitHub

How I Built It

The application is built in Python using Streamlit for the frontend and Pandas for CSV data manipulation.

For the AI core, I used the ollama Python library to run open-weight models (like Llama 3.2 / Gemma 2) completely locally. I specifically utilized Ollama's format="json" parameter combined with a strict system prompt to force the local LLM to return perfectly structured JSON data. Streamlit then maps this JSON directly into the visual dashboard components.

Why Does Open Innovation Matter?

If I built this side hustle using a commercial, closed-source API, the business model would fall apart for two reasons:

Profit Margins & Scale: Passing hundreds of lengthy customer reviews into an LLM context window eats up massive amounts of tokens. If I paid per token, my API costs would scale linearly with my users, forcing me to charge expensive monthly subscriptions. Running an open-source model locally means my inference cost is $0. My profit margin stays near 100%.
Data Privacy: Customer reviews contain sensitive PII (names, order numbers, and specific complaints). Store owners do not want to upload their proprietary business data to a closed-source corporate cloud. Open-source local inference guarantees the data never leaves their local machine.

My Agent Session

I used the Antigravity IDE assistant to scaffold the Streamlit UI, handle the Pandas CSV parsing logic, and construct the specific prompt injection that forces the local model to output perfectly structured JSON.

Campus Flora Finder: An Offline-First AI Botanist That Gets You Outside

Shreshth Khetan — Sun, 11 Oct 2026 23:07:56 +0000

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

What I Built

As developers, we spend hours hunched over keyboards staring at screens and debugging code. For this week's "Touch Grass" challenge, I wanted to build a project that turns outside breaks into an engaging exploration.

I built the Campus Flora Finder, an offline-first botanical companion designed to make the screen the shortest part of the experience:

Get outside: Step away from the desk, walk around campus or local parks, and discover local plants, shrubs, and trees.
Snap a photo: Take a quick photo of unfamiliar flora.
Instant identification: Upload the image to receive the common name, scientific classification, key botanical traits, and an ecological fun fact—then put the phone away and get right back to the walk.

Demo

(Tip: Drag and drop a screenshot or GIF of your Streamlit app running locally with a plant identified right here!)

The interface runs locally in the browser with zero external network dependencies, processing uploaded plant photos in seconds.

Code

shreshth2906 / Campus-Flora-Finder

🌿 Campus Flora Finder

Hacktoberfest 2026 Week 1 Challenge Entry (Theme: "Touch Grass")
An interactive, 100% offline, privacy-first botanical identification web application built with Streamlit and open-weight vision models running locally via Ollama.

🍃 Overview & The "Touch Grass" Philosophy

The goal of Hacktoberfest's "Touch Grass" challenge is simple: encourage developers and university students to step away from code editors, take a breath of fresh air, explore their campus green spaces, and reconnect with the natural world.

Campus Flora Finder bridges tech and nature. Take a walk across your university grounds, snap a photo of any wild tree, shrub, or blooming flower on your laptop or phone camera, and receive instant field botany diagnostics—without sending a single byte of personal data or images to external cloud APIs.

✨ Features

🌲 100% Offline & Private: Runs entirely on your local machine using open-weight vision models (llava, moondream…

View on GitHub

How I Built It

The application is built in Python with Streamlit for the frontend and powered by local open-weight vision-language models via Ollama.

Architecture: The app processes images locally using the open-weight llava (or moondream) vision model through Ollama's local inference runtime.
Pipeline: Streamlit ingests images (JPEG/PNG), converts them directly into byte streams, and sends them to the local model endpoint along with a targeted botanical prompt to extract structured taxonomy and ecological details.
Resilience: The tool includes clean fallback handling to notify users if the Ollama daemon or model weights need to be initialized.

Why Does Open Innovation Matter?

Open-source AI and local inference are uniquely suited for an outdoor application:

True Offline Utility: Trails, botanical gardens, and campus perimeters frequently suffer from weak cellular reception and dead zones. Running open-weight models locally ensures the identification pipeline works without an internet connection.
Zero Cost and High Accessibility: Cloud-hosted multimodal APIs incur continuous token and image ingestion costs. Using open weights allows students and outdoor enthusiasts to scan hundreds of specimens without subscription barriers or API fees.
Data Privacy: Exploration photos and metadata stay entirely on the local device rather than being uploaded to third-party corporate servers.

My Agent Session

Scaffolded the Streamlit interface and image byte-stream pipeline using an IDE coding assistant to quickly test prompt structure and local inference speed.

Building an Un-Cheatable AI Mentor for Competitive Programming

Shreshth Khetan — Mon, 05 Oct 2026 01:11:52 +0000

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

What I Built

Technical placement season is here, and a close friend of mine has been grinding data structures and algorithms for upcoming recruitment drives. But they hit a massive roadblock: standard AI chatbots are terrible teachers.

When they got stuck on a Dynamic Programming problem and asked for a hint, commercial AI tools just spat out the entire 50-line C++ solution. It ruined the learning process. My friend didn't want the answer; they wanted to build algorithmic intuition.

So for this challenge, I built them the Competitive Programming Hint Engine—a strict, Socratic AI mentor that is programmatically barred from writing code.

The CLI works seamlessly locally. You paste a problem description and where you are stuck, and it guides you without spoiling the solution.

Code

shreshth2906 / Competitive-Programming-Hint-Engine

🧠 Competitive Programming Hint Engine

A strictly Socratic, 100% local AI mentor designed to help students master Data Structures and Algorithms without the temptation of copy-pasting code.

🌟 The "Why"

This project was built for the Hacktoberfest 2026 Weekend Challenge under the theme "Build for a Friend" When preparing for technical placements, the biggest trap students fall into is relying on AI to write the code for them. True learning happens when you struggle with the logic, not when you copy-paste the syntax. I built this tool for a friend to provide guidance, suggest data structures, and analyze time complexities—all while strictly refusing to write the actual implementation.

✨ Key Features

Socratic Mentorship: Analyzes your approach and asks guiding questions instead of spoon-feeding answers.
Constraint Pre-Parser: Automatically reads problem constraints (e.g., $10^5$) and suggests the target time complexity before passing context to the AI.
Regex Interceptor…

View on GitHub

How I Built It

The CP Hint Engine is a local, CLI-based AI agent built in Python around an open-weight model (gemma2:2b or llama3.2:1b) running locally via Ollama.

It features a custom agent harness with two key components:

Constraint Pre-Parser: It reads problem constraints using RegEx (e.g., $10^5$) and automatically suggests the target time complexity (e.g., $O(N \log N)$) before passing context to the LLM.
The "Un-Cheatable" Harness Interceptor: To prevent the LLM from hallucinating and outputting code, I built a deterministic regex interceptor. If it detects a markdown code block in the LLM's output, it intercepts and replaces it with: > [Harness Intercept: Code generation blocked to preserve learning].

Why Does Open Innovation Matter?

Building this with open-source AI was the only way this project could succeed for three main reasons:

Absolute Control: Commercial, closed-source APIs frequently ignore negative system instructions like "do not write code." By using an open-source model running locally, I could wrap it in a custom Python harness that gives me ultimate, programmatic control over the output. I own the intercept layer.
Offline Capability: Campus Wi-Fi can be notoriously spotty. Running open-weight models locally means my friend can practice anywhere, completely offline.
Privacy and Cost: Placement prep requires hundreds of problems. My friend can run this locally without worrying about API token limits, subscription costs, or sending their learning struggles to a corporate server.

My Agent Session

I mapped out the architecture and built the core regex harness alongside the Antigravity IDE assistant (using skills from the Google AI Agents intensive course).

Prize Categories

Best Use of Gemma

Initialization...

Shreshth Khetan — Fri, 02 Oct 2026 20:08:35 +0000

Hi everyone myself Shreshth, I'm new to this community.