DEV Community: Ritik Ahirwar

PriceCraft AI: The 20-Minute eBay Listing, Cut Down to One Click

Ritik Ahirwar — Mon, 19 Oct 2026 06:59:19 +0000

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

What I Built

PriceCraft AI is a one-click appraisal and listing engine for people who flip vintage clothes, watches, refurbished tech, and collectibles on eBay, Etsy, Poshmark, Mercari, and Shopify.

That person is usually not a “startup.” They are a seller with a phone, a storage tote, and a side income that lives or dies on two numbers: what to ask, and how long it takes to write the listing.

Overprice, and the item sits. Underprice, and you donated margin to a stranger. Write a sloppy title, and search never finds you. Skip the condition note, and you eat a return plus a platform fee you already paid. A careful listing still takes 15–20 minutes: hunt comps, guess a price, squeeze keywords into eBay’s 80-character title, write specs, disclose flaws.

PriceCraft turns that into a single form: brand, category, condition, sourcing cost, a few attributes. It returns:

a suggested list price, a quick-sale floor, a patient ceiling, and a 14-day sell-through probability
live competitor min / average / max (when SerpApi is configured)
net after a typical marketplace fee blend, so “optimal” is not vanity revenue
an eBay-length title, an Etsy-style title, markdown specs, and a condition-honest description
optional 15-second promo narration for TikTok / Reels
a small inventory catalog and CSV export

Who would pay? Anyone listing more than a handful of items a week. The product is not “AI for shopping.” It is time and pricing discipline for a resale hustle, which is exactly the kind of small, specific, useful software this week asked for.

Demo

Live app: https://pricecraft-ai.onrender.com

Try a preset (vintage Nike windbreaker, etc.), or enter a real item you would actually sell. Appraisal, comps, copy, unit economics, and inventory live in the same dashboard. Health check: /api/health.

The public demo runs on Render’s free tier, so the first request after idle can take a moment to wake. That is the honest cost of shipping something judges (and sellers) can click without cloning a repo.

Code

ritikahirwar8168-dev / pricecraft-ai

PriceCraft AI

Intelligent resale pricing, live market comps, and listing generation for online sellers.

Live demo: https://pricecraft-ai.onrender.com

Built for Hacktoberfest 2026 (Week 2 — Side Hustle) with open-source AI at the core.

Overview

Solo sellers on eBay, Etsy, Poshmark, Mercari, and Shopify spend too much time on two jobs that should be fast: pricing and listing copy.

Guessing a price too high leaves inventory sitting. Guessing too low gives away margin.
Writing an 80-character eBay title, specs, and an honest condition note often takes 15–20 minutes per item.

PriceCraft AI turns item specs and sourcing cost into a valuation, competitor snapshot, marketplace listing, and optional short-form promo voiceover in one request.

Features

Capability	What you get
Tabular valuation (Prior Labs TabPFN)	Suggested list price, quick-sale floor, collector ceiling, and 14-day sell-through probability
Liquidity curve	Chart.js view of sell probability across price tiers
Listing copy (Google Gemma 2)	eBay-length title,

…

View on GitHub

Repo: github.com/ritikahirwar8168-dev/pricecraft-ai

Stack: Python 3.11, FastAPI, SQLite, Tailwind, Chart.js. Blueprint: render.yaml. Tests: python -m unittest tests/test_pricecraft.py -v.

How I Built It

Every listing follows the same path: seller input in, priced listing out, with Sentry wrapping each engine so latency is measurable instead of guessed.

flowchart TD
    Seller["Seller"] -->|"Item specs, condition, sourcing cost"| UI["Dashboard on Render"]
    UI -->|"POST /api/analyze"| API["FastAPI pipeline"]

    subgraph Traced["Sentry-traced agent steps"]
        TabPFN["TabPFN<br/>price, floor, ceiling, 14-day sell-through"]
        SerpApi["SerpApi<br/>live Google Shopping comps"]
        Gemma["Gemma 2<br/>80-char title, specs, description"]
        Econ["Unit economics<br/>fees, shipping, net profit"]
    end

    API --> TabPFN
    API --> SerpApi
    TabPFN --> Gemma
    TabPFN --> Econ
    SerpApi --> Econ
    Gemma --> Out["Priced listing + copy"]
    Econ --> Out
    Out --> UI
    Out -->|"Save / CSV export"| DB["SQLite inventory"]

    UI -->|"POST /api/voiceover"| Voice["ElevenLabs promo clip"]
    Voice --> UI

The open pieces are not a badge on the README. They are the two jobs a closed chatbot is bad at: numbers on a small table, and copy that obeys a marketplace rule.

Valuation is TabPFN, not an LLM. Prior Labs’ tabular foundation model is trained to do Bayesian-style inference on small tabular sets in a forward pass. Resale data looks like that: condition score, brand tier, rarity, age, demand, original retail, sourcing cost. I fit TabPFNRegressor on sold price and TabPFNClassifier on “sold within 14 days,” then score the item. From that I derive floor, ceiling, days-on-market, and a factor breakdown. A general chat model will sound like it priced the jacket. TabPFN is actually doing tabular prediction.

Copy is Gemma 2. Google’s open-weight gemma-2-9b-it writes the listing: 80-character eBay title, warmer Etsy title, bullets, markdown description, tags, social hook. Inference can go through Groq or Hugging Face; GEMMA_MODEL_ID is swappable. Temperature is low. The output is JSON, not a paragraph you have to edit twice.

Live comps are SerpApi (Google Shopping), so the price is not floating in a vacuum.

ElevenLabs turns the social hook into a short voiceover. Resellers already film phone videos; they should not also write and record a script for every SKU.

Sentry agent tracing wraps each step (tabular_valuation, market_comps, listing_generation, voiceover_synthesis) with latency and metadata. The UI has a telemetry tab; the same spans go to Sentry when SENTRY_DSN is set. For a multi-engine pipeline, “it feels slow” is useless. You need to know whether TabPFN, search, or copy ate the budget.

Render is the runtime: FastAPI on 0.0.0.0:$PORT, health check at /api/health, env keys marked sync: false in the blueprint. The side hustle only exists if a seller can open a URL.

Fallbacks are intentional. Keys are optional. Without them, built-in priors still produce a valuation and listing so the app never dead-ends. That matters more for a $0–small-budget hustle than a demo that 500s when a vendor is down.

One POST /api/analyze run: TabPFN valuation → SerpApi comps → Gemma 2 listing → unit economics (price − cost − ~13.25% + $0.30 fee − shipping). Voiceover is a separate POST /api/voiceover so you do not pay for audio on every appraisal.

Why Does Open Innovation Matter?

A reseller’s margin is thin. If every listing calls a closed frontier API, the tool can cost more than the extra dollars it finds. Open weights change the unit economics of the product, not just the philosophy.

Tabular work is a poor fit for a closed chat API. Pricing is rows and columns: condition, rarity, age, comps. Forcing that through a general LLM is the expensive way to get a confident wrong number, with no real posterior and no cheap way to refit on your own sold-history CSV. TabPFN is built for that shape of data. That is where open innovation is not a slogan; it is the correct model class.

Gemma lets me constrain and swap. eBay’s title limit is 80 characters. I need a model I can prompt strictly, pin to JSON, and replace (2b vs 9b, Groq vs Hugging Face vs local later) without rewriting the app or renegotiating a vendor. Closed copy APIs are fine until the price per 1K tokens moves, the model is deprecated, or the policy dislikes “used goods with stains disclosed.” Open weights keep the listing writer under my control.

Seller data is not abstract. Sourcing cost and true margin are the most sensitive fields in this workflow. A hosted closed API means sending that to a third party on every click. Self-hosting FastAPI + TabPFN on CPU, or running Gemma through a provider you chose, is a better default for a hustle that should not leak wholesale.

Closed tools fail the “would someone pay” test in a different way. ChatGPT can draft a description. It will not fit a tabular prior, subtract eBay fees, pull shopping comps, and emit File Exchange-shaped CSV in one path. The open stack is what made it one product instead of five tabs.

Open here does not mean “no internet, always.” It means the intelligence that makes the hustle work — tabular valuation and constrained listing copy — is not locked to a single closed SKU. Render hosts it. Partners add live search, voice, and traces. The core still runs with fallbacks if those keys are empty.

Prize Categories

Best Use of Render — production runtime at pricecraft-ai.onrender.com, render.yaml, /api/health
Best Use of TabPFN — regressor + classifier on resale attributes: price, 14-day sell-through, floor/ceiling, factor breakdown, inside a wider valuation agent
Best Use of Gemma — Gemma 2 as the listing writer (80-char titles, specs, condition copy)
Best Use of Sentry Agent Tracing — per-engine spans (latency, price, title length, competitor count) in-app and via sentry-sdk
Best Use of SerpApi — live Google Shopping comps grounding the price
Best Use of ElevenLabs — short-form listing promo narration

TerraPulse 🌿 — The Screenless Outdoor & Trail Agent

Ritik Ahirwar — Sun, 11 Oct 2026 05:58:15 +0000

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

What I Built

Most outdoor and recreation apps encourage users to spend more time looking at screens—reading trail reviews, comparing weather data, and navigating cluttered GPS interfaces before taking a single step outside.

I built TerraPulse around a simple design philosophy: the screen should be the shortest part of the experience—ideally under 30 seconds.

TerraPulse is an AI-powered field guide for hikers, trail runners, foragers, and gardeners. Instead of studying charts, users can:

Select an outdoor mission: Hiking, Trail Run, Foraging, or Gardening.
Explore environmental inputs such as temperature, humidity, soil moisture, elevation, canopy density, and recent rainfall.
Get a composite Grass Score (0–100), an assessment of trail traction and frost risk, and a concise spoken field briefing.
Receive a physical nature micro-quest—for example, observing different fungi growing on shaded tree trunks.
Listen to the briefing, put the phone away, and focus on the outdoors.

The goal is simple: make environmental information useful without keeping people glued to their screens.

Demo

🌐 Live Application: TerraPulse on Render
📖 Interactive API Documentation: Explore the API
💻 Source Code: GitHub Repository

Try the live demo by selecting an available trail preset, such as Pine Ridge Trail or Alpine Ridge, then using Synthesize Briefing & Touch Grass if that option is available. Listen to the briefing and explore the generated outdoor guidance.

How I Built It

TerraPulse combines environmental data analysis, an AI-guided outdoor experience, audio narration, and observability.

1. Environmental Analysis with TabPFN

Trail conditions can depend on multiple interacting variables, including temperature, humidity, soil saturation, and time since rainfall.

I integrated Prior Labs' TabPFN (tabpfn.TabPFNClassifier) to analyze tabular environmental observations.

Historical observations are stored in data/trail_microclimate.csv.
The analysis supports trail-condition assessments such as dry, muddy or slippery, and frost or ice risk.
The resulting predictions provide structured input for the outdoor briefing.

2. Outdoor Reasoning with Google Gemma 2

Environmental predictions become more useful when translated into practical, understandable guidance.

TerraPulse integrates Google's open-weight Gemma 2 (gemma-2-9b-it) as its naturalist-style reasoning agent.

It turns environmental analysis into a concise field briefing.
It can generate a nature micro-quest and a sensory observation prompt.
The project supports configurable inference paths, including local Ollama integration (USE_LOCAL_GEMMA=true), Google AI Studio endpoints, and deterministic fallback behavior.

Actual model availability and inference requirements depend on the selected runtime and configuration.

3. Screen-Free Audio with ElevenLabs

TerraPulse supports ElevenLabs Turbo v2.5 for spoken narration, helping users listen rather than continually check their screens.

When the required voice API configuration is unavailable, the frontend can use the browser's native Web Speech API (window.speechSynthesis) as a fallback.

4. Observability with Sentry

The project uses sentry-sdk to instrument parts of the agent pipeline with custom spans, including:

ai.tabpfn.tabular
ai.gemma.llm
ai.elevenlabs.tts

The interface includes an agent-tracing and latency-waterfall view intended to make the processing pipeline easier to inspect.

5. Deployment with Docker and Render

TerraPulse includes a Dockerfile and a render.yaml configuration for deployment on Render.

The live deployment makes it possible to explore the application through a browser without setting up the project locally.

Why Open Innovation Matters

Outdoor environments often have unreliable connectivity. A useful field tool should be designed with those constraints in mind.

Open-weight models and flexible deployment options offer several potential benefits:

Local inference options: Models such as Gemma 2 can be run locally when the required hardware and software are available.
More control over data: Local processing can reduce the need to send certain inputs to external services, depending on the configuration.
Flexible experimentation: Open-weight models and open-source tooling make it easier for developers to inspect, adapt, and extend a system.
Practical fallback behavior: Deterministic fallbacks and browser-based speech can help the experience remain useful when optional integrations are unavailable.

TerraPulse explores how these approaches can support a more focused, screen-conscious outdoor experience. Cloud-backed features still depend on connectivity, credentials, and service availability.

My Agent Development Workflow

TerraPulse was developed with AI-assisted pair programming and an emphasis on making the system easier to inspect.

Agent tracing and performance spans can be explored through the application's tracing interface, where available.
The source repository contains the implementation and project history.
The modular architecture separates environmental analysis, reasoning, voice generation, and observability.

Prize Categories

TerraPulse is intended for consideration in the following challenge and sponsor categories, subject to each category's official eligibility requirements.

Featured Categories

Best Use of Render: The application is deployed on Render, with deployment configuration included in the repository.
Best Use of TabPFN: TabPFN is integrated for tabular environmental analysis and trail-condition assessment.
Best Use of Gemma: Gemma 2 is integrated into the outdoor reasoning workflow to help turn structured information into field guidance.

Partner Categories

Best Use of ElevenLabs: ElevenLabs integration supports spoken outdoor briefings.
Best Use of Sentry Agent Tracing: Sentry instrumentation supports inspection of the agent pipeline and its performance.

Campus Copilot — AI Academic Assistant for a College Student

Ritik Ahirwar — Sun, 04 Oct 2026 21:00:02 +0000

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

What I Built

College students often have information scattered across attendance, assignments, exams, notes, and to-do lists. A generic chatbot can give advice, but it does not necessarily understand the student's actual academic situation.

I built Campus Copilot, an AI-powered academic assistant designed around that problem.

It combines deterministic academic logic with an open-weight AI workflow to turn campus context into concrete actions.

What it does

Dashboard — attendance ring, warnings, deadlines, and today's recommended actions
Attendance — subject-level attendance, 75% warnings, and skip/attend simulation
Academics — assignments, exams, and notes CRUD
Productivity — tasks and study plans ranked by risk and due dates
Assistant — contextual chat with structured actions such as:
- create_task
- start_study_block
- flag_attendance
Daily Priorities — personalised academic priority planning
Summarize — converts study material into concise bullet points
Quiz Generator — generates interactive MCQs with explanations
Flashcards — generates tap-to-flip Q&A cards
AI Study Plan — enhances the deterministic study plan with AI recommendations

The key idea is simple: instead of saying "study DSA today", the assistant can use actual attendance risk, deadlines, tasks, and academic context to recommend what the student should do next.

All AI features have graceful rule-based fallbacks when Ollama is unavailable, so the core application remains functional without a GPU.

Demo

Live Demo

Frontend:

https://campus-chatbot-kbkdt49ms-ritikahirwar8168-dev.vercel.app

Backend API:

https://campus-chatbot-bzk0.onrender.com

Demo Login

Field	Value
Username	`demo`
Password	`campus`

The seeded demo student is Ritik, a B.Tech CSE semester 5 student with subjects, assignments, exams, notes, and tasks.

Code

GitHub Repository:

https://github.com/ritikahirwar8168-dev/campus-chatbot

The repository contains both the FastAPI backend and React/Vite frontend:

campus-chatbot/
├── backend/
└── frontend/

How I Built It

Campus Copilot is built around Gemma 3 4B, Google's open-weight model, served locally through Ollama during development.

AI stack

Model: Gemma 3 4B
Inference: Ollama
Backend: FastAPI + SQLAlchemy + SQLite
Frontend: React 18 + Vite 6 + Tailwind CSS 3
Authentication: JWT + bcrypt
Deployment: Render + Vercel

The backend keeps the AI integration in a dedicated service:

backend/app/services/ollama_service.py

Prompt templates are separated into:

backend/app/services/prompts.py

The assistant and AI endpoints then use the shared AI service rather than exposing model calls directly to the browser.

Deterministic + AI architecture

I deliberately kept academic calculations deterministic.

For example:

attendance calculations are handled by application logic
deadlines and risk ranking are handled by application logic
study-plan structure is generated deterministically
AI is used for contextual language generation, summaries, quizzes, flashcards, priorities, and enhanced recommendations

This prevents an LLM from becoming the source of truth for calculations that should be exact.

Graceful fallback

The project is designed to work even when the local model is unavailable.

If Ollama is offline:

the assistant can fall back to rule-based responses
AI tools can return fallback behavior
attendance, academics, productivity, and other core workflows continue to work

This also makes the application practical to demo without requiring a GPU.

Why Does Open Innovation Matter?

Using an open-weight model made the AI layer more transparent and controllable during development.

With Gemma + Ollama, I could:

run the model locally
keep the inference architecture under my control
develop without requiring a hosted proprietary AI endpoint
isolate the model behind my own FastAPI service
design deterministic fallbacks instead of making the entire application dependent on an external model API

For an academic assistant, this architecture is particularly useful because the application works with structured student context. The AI is an enhancement on top of the application logic rather than the entire application itself.

The result is a hybrid design:

Student Context
      ↓
Deterministic Academic Logic
      ↓
AI Context + Prompts
      ↓
Gemma via Ollama
      ↓
Personalised Assistance

My Agent Session

Optional: Add your DevRelay / agent session link here if you have one.

The project was developed with an AI-assisted coding workflow, while keeping the application architecture, deterministic logic, deployment setup, and integration under project control.

Deployment

Frontend — Vercel

The React/Vite frontend is deployed on Vercel.

Root directory: frontend
Framework: Vite
Environment variable:

VITE_API_URL=https://campus-chatbot-bzk0.onrender.com

Live frontend:

https://campus-chatbot-kbkdt49ms-ritikahirwar8168-dev.vercel.app

Backend — Render

The FastAPI backend is deployed on Render.

Root directory: backend
Build command:

pip install -r requirements.txt

Start command:

uvicorn app.main:app --host 0.0.0.0 --port $PORT

Production configuration includes:

OLLAMA_ENABLED=false
CORS_ORIGINS=https://campus-chatbot-kbkdt49ms-ritikahirwar8168-dev.vercel.app

Backend:

https://campus-chatbot-bzk0.onrender.com

Production AI note

The production Render deployment currently has:

OLLAMA_ENABLED=false

because the deployed Render service does not run a local Ollama/Gemma instance.

The application therefore uses its graceful fallback behavior in production. Gemma + Ollama is fully supported for local development and is the open-weight AI technology used to build the AI layer.

Prize Categories

🏆 Best Use of Render — $200

Why this project fits:

Campus Copilot uses Render to host the production FastAPI backend.

The backend is responsible for:

authentication
student context
attendance logic
academic data
productivity workflows
assistant actions
AI endpoints
fallback behavior

Render deployment:

Repository: ritikahirwar8168-dev/campus-chatbot
Root Directory: backend
Build: pip install -r requirements.txt
Start: uvicorn app.main:app --host 0.0.0.0 --port $PORT

Live backend:

https://campus-chatbot-bzk0.onrender.com

🏆 Best Use of Gemma — $200

Why this project fits:

Campus Copilot uses Gemma 3 4B, Google's open-weight model, as its primary AI model during local development.

Gemma powers the project's AI-oriented features, including:

contextual academic assistance
daily priorities
summarization
quiz generation
flashcard generation
AI-enhanced study plans

The model is served through Ollama, with the AI integration isolated in:

backend/app/services/ollama_service.py

This keeps the model layer replaceable and prevents direct AI calls from the frontend.

Local setup:

ollama pull gemma3:4b
ollama serve

Architecture

Local / AI-enabled

┌─────────────────────┐        ┌──────────────────────┐
│   React Frontend    │        │    Ollama Server     │
│   Vite + Tailwind   │        │    gemma3:4b         │
└────────┬────────────┘        └──────────┬───────────┘
         │                                │
         │ HTTP                           │ HTTP
         ▼                                │
┌────────────────────────────────────────────────────┐
│                  FastAPI Backend                   │
│                                                    │
│  Routers → Services → ollama_service.py           │
│      │          │                                  │
│      ▼          ▼                                  │
│   Models      Prompts                              │
│      │                                             │
│      ▼                                             │
│   SQLite                                           │
└────────────────────────────────────────────────────┘

Production

┌──────────────────────────┐
│     Vercel Frontend      │
│     React + Vite         │
└────────────┬─────────────┘
             │ HTTPS
             ▼
┌──────────────────────────┐
│     Render Backend       │
│     FastAPI + SQLite     │
│                          │
│  Deterministic logic    │
│  + AI fallback logic    │
└──────────────────────────┘
             │
             └── OLLAMA_ENABLED=false

Key Design Decisions

AI calls are never exposed directly to the frontend — they go through the backend.
Ollama configuration lives in environment variables, not hard-coded application logic.
The AI provider is isolated in ollama_service.py.
Deterministic logic such as attendance calculations and deadlines is never delegated to AI.
Every AI endpoint has a graceful fallback when Ollama is offline.
The application remains usable for core academic workflows without a GPU.
Frontend and backend are deployed separately using Vercel and Render.

API Highlights

Area	Endpoint	Purpose
Auth	`POST /api/auth/login`	Login and JWT
Attendance	`GET /api/attendance`	Subject attendance
Attendance	`POST /api/attendance/simulate`	What-if simulator
Dashboard	`GET /api/dashboard`	Academic dashboard
Academics	`GET /api/academics/assignments`	Assignments
Productivity	`GET /api/productivity/study-plan`	Study plan
Assistant	`POST /api/assistant/chat`	Contextual chat
Assistant	`POST /api/assistant/apply`	Apply recommended action
AI	`POST /api/ai/summarize`	Summarization
AI	`POST /api/ai/quiz`	Quiz generation
AI	`POST /api/ai/flashcards`	Flashcard generation
AI	`GET /api/ai/daily-priorities`	Daily priorities

What I Learned

Building Campus Copilot reinforced an important lesson about AI applications:

The best AI feature is not always the part that generates the answer. It is the system that gives the model the right context and knows when not to use the model.

For this project, deterministic academic logic provides the reliable foundation, while Gemma adds natural-language reasoning and personalised assistance on top.

That combination made it possible to build an academic assistant that is useful, explainable, and still functional when the model is unavailable.

Future Improvements

If I continue developing Campus Copilot, I would like to add:

persistent production database storage
hosted Gemma inference for production AI features
richer student-context retrieval
calendar integration
notifications for attendance and deadlines
more personalised study analytics
stronger evaluation of AI-generated quizzes and study plans

DEV Community: Ritik Ahirwar

PriceCraft AI: The 20-Minute eBay Listing, Cut Down to One Click

What I Built

Demo

Code

ritikahirwar8168-dev / pricecraft-ai

PriceCraft AI

Overview

Features

How I Built It

Why Does Open Innovation Matter?

Prize Categories

TerraPulse 🌿 — The Screenless Outdoor & Trail Agent

What I Built

Demo

How I Built It

1. Environmental Analysis with TabPFN

2. Outdoor Reasoning with Google Gemma 2

3. Screen-Free Audio with ElevenLabs

4. Observability with Sentry

5. Deployment with Docker and Render

Why Open Innovation Matters

My Agent Development Workflow

Prize Categories

Featured Categories

Partner Categories

Links

Campus Copilot — AI Academic Assistant for a College Student

What I Built

What it does

Demo

Live Demo

Demo Login

Code

How I Built It

AI stack

Deterministic + AI architecture

Graceful fallback

Why Does Open Innovation Matter?

My Agent Session

Deployment

Frontend — Vercel

Backend — Render

Production AI note

Prize Categories

🏆 Best Use of Render — $200

🏆 Best Use of Gemma — $200

Architecture

Local / AI-enabled

Production

Key Design Decisions

API Highlights

What I Learned

Future Improvements