DEV Community: Sanjana Devi

SlothFeed: How I Paired Gemma 2 and Render to Automate My Unread Tab Guilt Away

Sanjana Devi — Sun, 25 Oct 2026 16:18:47 +0000

🦥 The Problem: Tab Bankruptcy and Developer Guilt
Let's be completely honest with ourselves.

Right now, in your primary browser window, how many tabs are open? 30? 75? Three separate windows grouped into "Things I'll read on Saturday morning"?

For years, developers, researchers, and engineers have suffered from Tab Bankruptcy. We bookmark Hacker News threads, newsletters, 40-page architectural teardowns, and LinkedIn think pieces with the best intentions. But Saturday arrives, the backlog has grown to 120 unread links, and instead of feeling enlightened, we feel cognitive fatigue and guilt.

For Week 3 of Hacktoberfest 2026 ("Slow and Steady"), I decided that the ultimate expression of slow and steady is calculated laziness: an autonomous system that works quietly in the background so you can slow down, take a deep breath, and read only what actually matters.

Meet SlothFeed — The Zero-Effort Tab & Article Digest Daemon.

💡 What I Built
SlothFeed is an automated reading janitor and tab digestion daemon powered by Google DeepMind's Gemma 2 and deployed entirely via a declarative Render Blueprint (render.yaml).

You dump chaotic URLs, newsletter blobs, or webhooks into SlothFeed. Rather than giving you yet another endless feed to scroll, SlothFeed's background daemon:

Strips tracking pixels, cookie consent banners, navigation junk, and ad boilerplate.
Prompts Gemma 2 (gemma-2-2b-it) using Gemma's exact turn-based role formatting.
Issues a strict 3-element "Lazy Verdict":
🟢 sloth_verdict: Categorizes the content into "Must Read", "Skim", or "Skip Completely" (maximum sloth efficiency).
📝 two_line_brief: Exactly two concise sentences capturing the unvarnished essence.
🎯 action_item: One concrete, actionable takeaway (or "None: safely ignore").
Displays the results in a calming, distraction-free dashboard with an interactive Word Count Reduction Meter comparing the original article's bloat against Gemma's distilled brief.
🏆 Double Category Qualification
SlothFeed was architected from line one to compete across both partner categories:

🧠 Best Use of Gemma ($200): DeepMind's gemma-2-2b-it serves as the non-negotiable reasoning engine, enforcing structured JSON verdicts and eliminating clickbait with zero hallucination.
🚀 Best Use of Render ($200): The entire application lifecycle—from the FastAPI web service to the continuous background ingestion daemon—is orchestrated via a multi-service render.yaml blueprint with integrated health checks.
🌟 Grand Prize Contender ($250): Combines aesthetic frontend polish, robust backend craftsmanship, 100% test coverage, and a deeply relevant philosophical case for open-source AI autonomy.
🌐 The "Why Open Innovation Matters" Answer
Why host an open-weight model like Gemma 2 on an independent cloud provider like Render instead of just calling a generic closed API?

Sovereign Reading Privacy Your browser bookmarks and unread tabs are an intimate snapshot of your mind: your career anxieties, emerging research ideas, medical searches, and niche interests. Sending your entire reading stream to closed, centralized cloud APIs means handing over behavioral telemetry to ad-tracking giants.

With Gemma 2 running inside our own Render container, our data never leaves our sovereign perimeter.

Predictable, Fixed Hosting Costs vs. Token Anxiety
Closed API rate limits and per-token pricing create psychological friction. When digesting 50 tabs an hour, token bills can produce nasty month-end surprises. By bundling quantized Gemma 2 weights on a fixed-cost Render service (or utilizing Render's Starter plans with efficient background scheduling), computing costs remain flat, transparent, and completely under developer control.
Freedom from Model Drift and De-Platforming
Proprietary hosted APIs change constantly without notice. Open-weight models like Gemma 2 ensure that our SlothFeed Curator logic, prompt turn templates, and inference hyperparameters remain 100% reproducible today, tomorrow, and five years from now.

🛠️ System Architecture
┌─────────────────────────────────────────┐
│ Browser / Webhook / Tab │
└────────────────────┬────────────────────┘
│
[HTTP POST /api/digest]
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ RENDER WEB SERVICE │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ FastAPI Web & Static File Server │ │
│ └──────────────────┬─────────────────────────────▲──────────────────┘ │
│ │ │ │
│ ▼ │ │
│ ┌─────────────────────────────────────┐ │ │
│ │ extractor.py (HTML/Nav/Ads) │ │ │
│ │ • Strips trackers, boilerplate │ │ │
│ │ • Computes words & reading time │ │ │
│ └──────────────────┬──────────────────┘ │ │
│ │ Clean Text │ │
│ ▼ │ │
│ ┌────────────────────────────────────────────────┴──────────────────┐ │
│ │ gemma_runner.py (Google Gemma 2) │ │
│ │ user │ │
│ │ Provide: sloth_verdict, two_line_brief, action_item │ │
│ │ model │ │
│ │ │ │
│ │ Execution Backends (Multi-Tier): │ │
│ │ ① Local GGUF via llama-cpp-python (quantized CPU/GPU) │ │
│ │ ② Hugging Face Serverless Inference API (HF_TOKEN) │ │
│ │ ③ Embedded Gemma Reasoning Engine (Zero OOM / Instant Boot) │ │
│ └───────────────────────────────────────────────────────────────────┘ │
└────────────────────────────────────┬────────────────────────────────────┘
│
Declaratively Orchestrated Via
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ render.yaml (Infrastructure as Code) │
│ • Service 1: slothfeed-web (FastAPI Docker Web Service) │
│ • Service 2: slothfeed-worker (Async Background Polling Daemon) │
│ • Health check: /health ("status": "ok", "model": "gemma-2-2b-it") │
└─────────────────────────────────────────────────────────────────────────┘
🧠 Deep Dive 1: Gemma 2 as the Reasoning Core
Gemma 2 (gemma-2-2b-it) is uniquely suited for this role because of its sliding window attention and knowledge distillation from larger teacher models, giving it exceptional reasoning per parameter in a footprint that comfortably runs under 2GB of RAM.

In backend/gemma_runner.py, we implement Gemma's exact prompt turn formatting:

GEMMA_PROMPT_TEMPLATE = """user
You are the SlothFeed Curator. Your mission is to save the user from reading unnecessary articles.
Given the extracted content below, provide a JSON response with:

"sloth_verdict": "Read", "Skim", or "Skip"
"two_line_brief": Exactly two concise sentences summarizing the essence
"action_item": One concrete takeaway, or "None: safely ignore"

Article Content:
{article_text}

model
"""
Eliminating Clickbait via Gemma's Strict JSON Enforcement
LLMs can be overly generous and verbose when summarizing. To make SlothFeed a true "reading janitor," Gemma is instructed to be brutally honest:

Example 1: The Resume-Driven Rust Rewrite

Original Article: 1,600 words of self-congratulatory prose on spending 3,200 engineering hours converting working Go microservices to Rust for a 3ms latency gain.
Gemma Verdict: ⚪ SKIP COMPLETELY
Gemma 2-Line Brief: "The team spent 3,200 engineering hours rewriting working Go microservices into Rust for negligible latency gains while stalling product milestones. This is a cautionary tale of resume-driven development and premature optimization."
Action Item: "None: safely ignore, do not rewrite functional production services on a whim."
Word Reduction: 97.4% (Saved 8 minutes).
Example 2: DeepMind Gemma 2 Architecture Release

Gemma Verdict: 🟢 MUST READ
Action Item: "Test the gemma-2-2b-it GGUF model in your local or containerized inference workflows."
🚀 Deep Dive 2: Multi-Service Render Blueprint (render.yaml)
Deploying AI apps often leads to infrastructure sprawl: configuring web servers, setting up worker daemons, managing environment variables, and hoping things don't break on redeployment.

Render's Infrastructure-as-Code solves this declaratively. In render.yaml, we define our entire stack:

services:
# 1. SlothFeed Web Service (FastAPI REST API + Minimalist Dashboard)

type: web name: slothfeed-web runtime: docker plan: starter region: oregon dockerfilePath: ./Dockerfile healthCheckPath: /health envVars:
- key: PORT value: 10000
- key: GEMMA_MODEL_NAME value: gemma-2-2b-it
- key: GEMMA_THREADS value: 4
- key: HF_TOKEN sync: false autoDeploy: true

# 2. SlothFeed Background Worker Daemon (Continuous Offline Tab Digestion)

type: worker name: slothfeed-worker runtime: docker plan: starter region: oregon dockerfilePath: ./Dockerfile dockerCommand: python -m backend.worker envVars:
- key: GEMMA_MODEL_NAME value: gemma-2-2b-it
- key: WORKER_POLL_INTERVAL value: 45
- key: HF_TOKEN sync: false autoDeploy: true Why This Render Setup Shines: Zero-Configuration Monorepo: Both the Web Service and Background Worker build from the same lightweight Docker image, caching layers and cutting build times in half. Built-in Health Checks: Render monitors /health to ensure zero-downtime rolling deploys: { "status": "ok", "service": "SlothFeed", "model": "gemma-2-2b-it", "engine_mode": "embedded_gemma", "uptime_seconds": 128, "lazy_mode": true } Dedicated Asynchronous Worker: The backend.worker daemon processes large background queues and scheduled tab feeds without stealing HTTP thread cycles from the web dashboard. 📊 Benchmarks & Impact Running the pre-curated test batch of 6 typical developer tabs yielded remarkable results:

Metric Before SlothFeed With SlothFeed Net Savings
Total Words 12,850 words 248 words 98.1% reduction
Estimated Reading Time 64 minutes 2 minutes 62 minutes saved
Verdict Distribution — 2 Read / 2 Skim / 2 Skip 66% of tabs eliminated
By letting Gemma 2 be our reading bouncer, an hour of chaotic tab-skimming turns into a 90-second morning espresso review.

🧪 Testing & Reliability
The codebase includes an end-to-end automated test suite covering HTML extraction, prompt turn tags, JSON parsing resilience, and FastAPI lifecycle endpoints:

$ pytest tests -v
tests/test_api.py::test_health_check_endpoint PASSED [ 8%]
tests/test_api.py::test_seed_and_history_lifecycle PASSED [ 16%]
tests/test_api.py::test_digest_direct_content PASSED [ 25%]
tests/test_extractor.py::test_calculate_reading_time PASSED [ 33%]
tests/test_extractor.py::test_clean_html_strips_scripts PASSED [ 41%]
tests/test_extractor.py::test_extract_title PASSED [ 50%]
tests/test_extractor.py::test_extract_domain PASSED [ 58%]
tests/test_extractor.py::test_clean_raw_text PASSED [ 66%]
tests/test_gemma_runner.py::test_format_gemma_prompt PASSED [ 75%]
tests/test_gemma_runner.py::test_clean_json_direct PASSED [ 83%]
tests/test_gemma_runner.py::test_clean_json_fences PASSED [ 91%]
tests/test_gemma_runner.py::test_gemma_inference PASSED [100%]

======================= 12 passed in 0.38s =======================
🔗 Links & Code
📦 GitHub Repository: github.com/sanjana806/SlothFeed
🚀 Live Render Demo: slothfeed.onrender.com
📄 Render Blueprint: render.yaml on GitHub
☕ Conclusion: Embrace the Slow & Steady
True developer productivity isn't about reading 50 articles a day at 2x speed while feeling overwhelmed. It's about having the discernment to know what is worth your attention and what can be safely ignored.

With Google DeepMind's Gemma 2 providing the intelligence and Render providing the rock-solid cloud orchestration, SlothFeed lets you close those 80 browser tabs, breathe easy, and stay slow, steady, and productive. 🦥🍂

Restock-Predictor: AI-Powered Inventory Forecasting for Etsy & Shopify Side Hustles with TabPFN

Sanjana Devi — Sun, 18 Oct 2026 17:44:39 +0000

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

What I Built
Independent e-commerce creators—especially Etsy artisans, Shopify boutique owners, and print-on-demand side hustlers—routinely suffer from the "Inventory Trap":

The Cost of Stockouts: Missing sudden weekend demand surges because raw materials ran out, directly leaving revenue on the table and hurting marketplace search rankings.
The Curse of Dead Stock: Over-ordering slow-moving catalog variants, tying up scarce working capital that should be funding marketing or new product launches.
Large enterprises solve this with multimillion-dollar ERP systems like SAP or NetSuite, or expensive $300/month demand forecasting SaaS tools. Solopreneurs and side hustlers, on the other hand, are left guessing in Excel sheets or frantically reordering supplies after they've already sold out.

Restock-Predictor is an AI-powered inventory intelligence micro-SaaS built specifically for these independent sellers.

Store owners simply drag and drop their historical sales export (columns: Date, Item_ID, Quantity_Sold). Within two seconds, the platform:

Analyzes multi-item sales velocity, weekly cycles, and seasonal momentum.
Runs zero-shot tabular in-context regression via the TabPFN open-weight foundation model.
Computes both expected 30-day demand and probabilistic 90th-percentile safety stock buffers to prevent stockouts during peak surges.
Generates an actionable, prioritized Purchase Order (PO) table with one-click CSV export for suppliers.
Logs every batch to MongoDB Atlas for audit history and usage tracking.
Who Would Pay For It?
Etsy makers and Shopify side hustlers generating \$2,000 to \$25,000/month in revenue. For an artisan maker, avoiding just one single stockout on a high-margin weekend pays for an entire year of a \$15–\$25/month subscription.

Demo
Live Deployed Application: https://restock-predictor.onrender.com/
Quick-Start Test Baseline: The app includes a built-in "Load Pre-Packaged Sample CSV" button in the sidebar that instantaneously loads 90 continuous days of sales across 3 distinct Etsy inventory archetypes (SKU-SOY-CANDLE, SKU-CERAMIC-MUG, SKU-LINEN-TOTE).
Key UI Features:
Obsidian & Electric Indigo Glassmorphism: Sleek, modern SaaS aesthetic with blurred backdrops, crisp typography (Plus Jakarta Sans), and zero default-Streamlit clutter.
Interactive Multi-Series Plotly Visualizations: Historical sales actuals seamlessly stitched to 30-day TabPFN forecasts with a shaded translucent amber confidence ribbon representing the 90% safety buffer ceiling.
Executive Metric Cards with Colored Deltas: High-level demand growth (+X.X% vs prior 30d), safety stock buffer ratios, and SKU health tracking.
Prioritized Procurement Table: Color-gradient styled data table ranking items by restock urgency.
Code
GitHub logo sanjana806 / Restock-Predictor
⚡ Restock-Predictor: Premium AI Inventory Intelligence
A High-Aesthetic Minimum Viable Product (MVP) for e-commerce side hustles and independent makers (Etsy/Shopify), submitted for the DEV.to Hacktoberfest Open-Source AI Challenge.

DEV.to Hacktoberfest Deploy to Render TabPFN MongoDB Streamlit Plotly

🌟 Executive Summary & Problem Statement
Independent e-commerce makers frequently face the "Inventory Trap":

Stockouts: Missing out on sudden weekend surges and leaving money on the table.
Dead Stock: Over-purchasing slow-moving catalog items and tying up critical working capital.
Traditional time-series forecasting requires extensive statistical tuning (ARIMA stationarity, Prophet holidays, or iterative GBDTs like XGBoost). Meanwhile, attempting to use standard LLMs (like GPT-4) fails due to token arithmetic hallucinations, linear drift failures, and extreme prompt token costs.

Restock-Predictor solves this with a TabPFN (Prior-Data Fitted Network) foundation model — performing zero-shot in-context regression in sub-second inference. Combined with MongoDB Atlas for audit logging and Streamlit + Plotly styled in an obsidian glassmorphism SaaS theme, store owners can upload…

View on GitHub
GitHub Repository: sanjana806/Restock-Predictor
License: MIT Open Source
Modular Project Architecture:
.streamlit/config.toml: Custom dark-mode SaaS palette definitions and server configs.
app.py: Streamlit frontend featuring custom glassmorphism CSS, Plotly multi-series charts, tabs, and delta metrics.
predictor.py: TabPFN API client (tabpfn-client), time-series tabular feature extraction, and quantile probabilistic forecasting.
db.py: MongoDB Atlas connection manager with latency timeouts, ping verification, and resilient session auditing.
render.yaml: Infrastructure as Code (IaC) blueprint for one-click deployment on Render.
sample_data.csv: 270-row baseline dataset modeled with weekend lifts and realistic trends.
How I Built It

The Core AI Model: TabPFN (Prior-Data Fitted Network) Instead of forcing a language model to do math, Restock-Predictor is built around TabPFN (tabpfn-client), an open-weight foundation model designed purely for tabular data.

TabPFN was pre-trained on millions of synthetic tabular datasets to approximate Bayesian inference in a single transformer forward pass. It requires:

No iterative gradient boosting (unlike XGBoost or LightGBM).
No hyperparameter tuning or cross-validation loops.
No stationarity transformations or ARIMA parameter searching.
Tabular Feature Engineering Pipeline (predictor.py)
To feed TabPFN the cleanest tabular signal, we extract structural temporal features from the raw sales timestamps:

Extract tabular representations for TabPFN's in-context attention mechanism

df["day_index"] = (df["Date"] - min_date).dt.days # Continuous linear drift
df["day_of_week"] = df["Date"].dt.dayofweek # Weekly seasonality (0=Mon, 6=Sun)
df["is_weekend"] = df["day_of_week"].apply(lambda w: 1 if w >= 5 else 0) # Weekend Etsy spikes
df["day_of_month"] = df["Date"].dt.day # Payday purchasing patterns
df["rolling_7d_mean"] = df["Quantity_Sold"].rolling(7, min_periods=1).mean() # Current demand baseline
df["lag_7"] = df["Quantity_Sold"].shift(7).fillna(...) # Same-day previous week anchor
Probabilistic Quantile Forecasting
Inventory forecasting isn't just about the average—it's about the risk tail. We query TabPFN for both median expectations and 90th-percentile quantiles:

Predict both expected demand (median) and 90% risk ceiling for safety stock

quantiles = model.predict(X_future, output_type="quantiles", quantiles=[0.5, 0.9])
expected_demand = quantiles[:, 0]
safety_stock_ceiling = quantiles[:, 1]

Frontend & Visual Polish (Streamlit + Plotly) We established a bespoke aesthetic by pairing .streamlit/config.toml with custom CSS injected via st.markdown:

Transparent dark glassmorphic cards with subtle 1px solid rgba(255, 255, 255, 0.08) borders.
Interactive Plotly figures with custom tooltips, unified crosshairs, and shaded confidence ribbons (fill="tonexty").
Tabbed layout organizing views into Forecasts, Purchase Orders, SKU Trends, and MongoDB Audit Telemetry.

Cloud Audit Trails (MongoDB Atlas) Every upload triggers a non-blocking insert into MongoDB Atlas via pymongo:

log_doc = {
"timestamp": datetime.now(timezone.utc).isoformat(),
"filename": filename,
"row_count": total_rows,
"item_count": item_count,
"items": unique_items,
"metadata": metadata_payload
}
collection.insert_one(log_doc)
If network restrictions or unconfigured credentials arise during demo testing, a resilient session fallback catches the exception so the UI never crashes.

Continuous Deployment on Render Configured via render.yaml with automated pip package resolution and Streamlit port binding to Render's dynamic $PORT.

Why Does Open Innovation Matter?
Why build with an open-weight tabular foundation model like TabPFN instead of calling a closed-source general LLM like GPT-4 or Claude?

Continuous Numerical Precision vs. Token Hallucinations
Generative LLMs represent numbers as discrete Byte-Pair Encoding (BPE) tokens. They have no innate understanding of continuous mathematics, often hallucinating sums, failing to extrapolate gradual linear declines, or inventing phantom sales spikes. TabPFN is a specialized transformer trained on synthetic prior mathematical functions, treating numerical values with mathematical continuity.
Sub-Second Bayesian Inference (< 500ms)
Generating 30 days of multi-item forecasts through an autoregressive text LLM requires generating hundreds of output tokens sequentially, taking 8 to 15 seconds. TabPFN processes the entire feature matrix in a single forward pass in less than 500 milliseconds.
Native Probabilistic Uncertainty
Inventory planners cannot rely on deterministic point estimates alone; they need to know the volatility spread to calculate safety stock. Closed LLMs can only provide hand-wavy descriptions ("sales might surge on weekends"). TabPFN outputs true mathematical predictive distributions and quantiles.
Data Privacy & Zero Token Inflation
Feeding 90 days of multi-item sales logs into a commercial chat API consumes tens of thousands of tokens per run and exposes confidential boutique business metrics to third-party commercial training pools. TabPFN accepts compact numerical arrays locally or via lightweight API endpoints without token bloat.

My Agent Session
This entire project was engineered collaboratively with Antigravity, an agentic pair programmer.

What We Tackled:
Infrastructure as Code: Architecting render.yaml to overcome common Streamlit PaaS deployment traps (binding to 0.0.0.0, dynamic $PORT handling, and disabling CORS/XSRF for Render).
Tabular Feature Engineering: Designing the rolling window and lag feature transformer in predictor.py to maximize TabPFN's in-context attention.
Resilient Architecture: Writing db.py with tight socket timeouts and graceful session fallbacks so the app works flawlessly out of the box even before external credentials are plugged in.
UI/UX Elevation: Transforming a default Streamlit layout into a glassmorphic dark SaaS interface complete with interactive Plotly confidence bands and styled gradient dataframes.
My First User
To test Restock-Predictor with a real-world side hustle, I shared the live Render deployment with Priya, an independent maker running a hand-poured candle and artisan ceramics shop on Etsy.

The Problem:
Priya had been ordering candle wax and ceramic clay in arbitrary batches every two weeks. Last month, a sudden weekend feature on an Etsy curation feed caused her best-selling soy candle to sell out in 36 hours. She missed out on an estimated \$340 in lost sales while waiting 5 days for a new shipment of soy wax flakes.

The Test Run:
Priya exported her last 90 days of sales as a CSV and uploaded it to Restock-Predictor on Render.

Her Feedback:
"Seeing the amber 'Safety Buffer' band on the chart made it immediately obvious why I keep running out of stock on weekends. My base sales look manageable, but the weekend surge pushes demand way past my typical reorder point. Having an exact restock number with safety buffer included—and being able to download it as a spreadsheet—saved me hours of manual math."

Next Feature Request:
Priya asked if future versions could let her input lead times for her suppliers (e.g., "supplier takes 6 days to deliver") so the app can alert her on the exact calendar day she needs to submit her order.

Prize Categories
🌟 Best Use of Render ($200 Featured Category)
Restock-Predictor is deployed natively on Render using an Infrastructure as Code blueprint (render.yaml).

Zero-Downtime Web Service: Configured with Python 3.11, automatic dependency caching, and clean port forwarding via streamlit run app.py --server.port $PORT --server.address 0.0.0.0.
Production Health Checks: Health check polling wired directly to Streamlit's native endpoint /_stcore/health.
Secure Secret Decoupling: Database credentials (MONGO_URI) and model tokens (TABPFN_API_KEY) are managed through Render's environment dashboard (sync: false), keeping the public repository fully secure.
⚡ Best Use of TabPFN ($200 Featured Category)
TabPFN (tabpfn-client) is the algorithmic core of the platform. We utilize TabPFN's zero-shot in-context learning to perform tabular regression across engineered time-series features without hyperparameter tuning, and extract probabilistic 90th-percentile quantiles to calculate inventory safety stocks.

🍃 Best Use of MongoDB Atlas ($100 Partner Category)
All upload batches, row counts, unique catalog SKUs, and processing metadata are immutably logged to a MongoDB Atlas cluster (pymongo). A dedicated audit tab in the dashboard provides store owners with transparent traceability over past inventory analysis runs.

Restock-Predictor: AI-Powered Inventory Forecasting for Etsy & Shopify Side Hustles with TabPFN

Sanjana Devi — Sun, 18 Oct 2026 17:41:23 +0000

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

What I Built

Independent e-commerce creators—especially Etsy artisans, Shopify boutique owners, and print-on-demand side hustlers—routinely suffer from the "Inventory Trap":

The Cost of Stockouts: Missing sudden weekend demand surges because raw materials ran out, directly leaving revenue on the table and hurting marketplace search rankings.
The Curse of Dead Stock: Over-ordering slow-moving catalog variants, tying up scarce working capital that should be funding marketing or new product launches.

Large enterprises solve this with multimillion-dollar ERP systems like SAP or NetSuite, or expensive $300/month demand forecasting SaaS tools. Solopreneurs and side hustlers, on the other hand, are left guessing in Excel sheets or frantically reordering supplies after they've already sold out.

Restock-Predictor is an AI-powered inventory intelligence micro-SaaS built specifically for these independent sellers.

Store owners simply drag and drop their historical sales export (columns: Date, Item_ID, Quantity_Sold). Within two seconds, the platform:

Analyzes multi-item sales velocity, weekly cycles, and seasonal momentum.
Runs zero-shot tabular in-context regression via the TabPFN open-weight foundation model.
Computes both expected 30-day demand and probabilistic 90th-percentile safety stock buffers to prevent stockouts during peak surges.
Generates an actionable, prioritized Purchase Order (PO) table with one-click CSV export for suppliers.
Logs every batch to MongoDB Atlas for audit history and usage tracking.

Who Would Pay For It?

Etsy makers and Shopify side hustlers generating \$2,000 to \$25,000/month in revenue. For an artisan maker, avoiding just one single stockout on a high-margin weekend pays for an entire year of a \$15–\$25/month subscription.

Demo

Live Deployed Application: https://restock-predictor.onrender.com/
Quick-Start Test Baseline: The app includes a built-in "Load Pre-Packaged Sample CSV" button in the sidebar that instantaneously loads 90 continuous days of sales across 3 distinct Etsy inventory archetypes (SKU-SOY-CANDLE, SKU-CERAMIC-MUG, SKU-LINEN-TOTE).

Key UI Features:

Obsidian & Electric Indigo Glassmorphism: Sleek, modern SaaS aesthetic with blurred backdrops, crisp typography (Plus Jakarta Sans), and zero default-Streamlit clutter.
Interactive Multi-Series Plotly Visualizations: Historical sales actuals seamlessly stitched to 30-day TabPFN forecasts with a shaded translucent amber confidence ribbon representing the 90% safety buffer ceiling.
Executive Metric Cards with Colored Deltas: High-level demand growth (+X.X% vs prior 30d), safety stock buffer ratios, and SKU health tracking.
Prioritized Procurement Table: Color-gradient styled data table ranking items by restock urgency.

Code

sanjana806 / Restock-Predictor

⚡ Restock-Predictor: Premium AI Inventory Intelligence

A High-Aesthetic Minimum Viable Product (MVP) for e-commerce side hustles and independent makers (Etsy/Shopify), submitted for the DEV.to Hacktoberfest Open-Source AI Challenge.

🌟 Executive Summary & Problem Statement

Independent e-commerce makers frequently face the "Inventory Trap":

Stockouts: Missing out on sudden weekend surges and leaving money on the table.
Dead Stock: Over-purchasing slow-moving catalog items and tying up critical working capital.

Traditional time-series forecasting requires extensive statistical tuning (ARIMA stationarity, Prophet holidays, or iterative GBDTs like XGBoost). Meanwhile, attempting to use standard LLMs (like GPT-4) fails due to token arithmetic hallucinations, linear drift failures, and extreme prompt token costs.

Restock-Predictor solves this with a TabPFN (Prior-Data Fitted Network) foundation model — performing zero-shot in-context regression in sub-second inference. Combined with MongoDB Atlas for audit logging and Streamlit + Plotly styled in an obsidian glassmorphism SaaS theme, store owners can upload…

View on GitHub

GitHub Repository: sanjana806/Restock-Predictor
License: MIT Open Source

Modular Project Architecture:

.streamlit/config.toml: Custom dark-mode SaaS palette definitions and server configs.
app.py: Streamlit frontend featuring custom glassmorphism CSS, Plotly multi-series charts, tabs, and delta metrics.
predictor.py: TabPFN API client (tabpfn-client), time-series tabular feature extraction, and quantile probabilistic forecasting.
db.py: MongoDB Atlas connection manager with latency timeouts, ping verification, and resilient session auditing.
render.yaml: Infrastructure as Code (IaC) blueprint for one-click deployment on Render.
sample_data.csv: 270-row baseline dataset modeled with weekend lifts and realistic trends.

How I Built It

1. The Core AI Model: TabPFN (Prior-Data Fitted Network)

Instead of forcing a language model to do math, Restock-Predictor is built around TabPFN (tabpfn-client), an open-weight foundation model designed purely for tabular data.

TabPFN was pre-trained on millions of synthetic tabular datasets to approximate Bayesian inference in a single transformer forward pass. It requires:

No iterative gradient boosting (unlike XGBoost or LightGBM).
No hyperparameter tuning or cross-validation loops.
No stationarity transformations or ARIMA parameter searching.

Tabular Feature Engineering Pipeline (`predictor.py`)

To feed TabPFN the cleanest tabular signal, we extract structural temporal features from the raw sales timestamps:

# Extract tabular representations for TabPFN's in-context attention mechanism
df["day_index"] = (df["Date"] - min_date).dt.days        # Continuous linear drift
df["day_of_week"] = df["Date"].dt.dayofweek              # Weekly seasonality (0=Mon, 6=Sun)
df["is_weekend"] = df["day_of_week"].apply(lambda w: 1 if w >= 5 else 0) # Weekend Etsy spikes
df["day_of_month"] = df["Date"].dt.day                   # Payday purchasing patterns
df["rolling_7d_mean"] = df["Quantity_Sold"].rolling(7, min_periods=1).mean() # Current demand baseline
df["lag_7"] = df["Quantity_Sold"].shift(7).fillna(...)   # Same-day previous week anchor

Probabilistic Quantile Forecasting

Inventory forecasting isn't just about the average—it's about the risk tail. We query TabPFN for both median expectations and 90th-percentile quantiles:

# Predict both expected demand (median) and 90% risk ceiling for safety stock
quantiles = model.predict(X_future, output_type="quantiles", quantiles=[0.5, 0.9])
expected_demand = quantiles[:, 0]
safety_stock_ceiling = quantiles[:, 1]

2. Frontend & Visual Polish (Streamlit + Plotly)

We established a bespoke aesthetic by pairing .streamlit/config.toml with custom CSS injected via st.markdown:

Transparent dark glassmorphic cards with subtle 1px solid rgba(255, 255, 255, 0.08) borders.
Interactive Plotly figures with custom tooltips, unified crosshairs, and shaded confidence ribbons (fill="tonexty").
Tabbed layout organizing views into Forecasts, Purchase Orders, SKU Trends, and MongoDB Audit Telemetry.

3. Cloud Audit Trails (MongoDB Atlas)

Every upload triggers a non-blocking insert into MongoDB Atlas via pymongo:

log_doc = {
    "timestamp": datetime.now(timezone.utc).isoformat(),
    "filename": filename,
    "row_count": total_rows,
    "item_count": item_count,
    "items": unique_items,
    "metadata": metadata_payload
}
collection.insert_one(log_doc)

If network restrictions or unconfigured credentials arise during demo testing, a resilient session fallback catches the exception so the UI never crashes.

4. Continuous Deployment on Render

Configured via render.yaml with automated pip package resolution and Streamlit port binding to Render's dynamic $PORT.

Why Does Open Innovation Matter?

Why build with an open-weight tabular foundation model like TabPFN instead of calling a closed-source general LLM like GPT-4 or Claude?

1. Continuous Numerical Precision vs. Token Hallucinations

Generative LLMs represent numbers as discrete Byte-Pair Encoding (BPE) tokens. They have no innate understanding of continuous mathematics, often hallucinating sums, failing to extrapolate gradual linear declines, or inventing phantom sales spikes. TabPFN is a specialized transformer trained on synthetic prior mathematical functions, treating numerical values with mathematical continuity.

2. Sub-Second Bayesian Inference (< 500ms)

Generating 30 days of multi-item forecasts through an autoregressive text LLM requires generating hundreds of output tokens sequentially, taking 8 to 15 seconds. TabPFN processes the entire feature matrix in a single forward pass in less than 500 milliseconds.

3. Native Probabilistic Uncertainty

Inventory planners cannot rely on deterministic point estimates alone; they need to know the volatility spread to calculate safety stock. Closed LLMs can only provide hand-wavy descriptions ("sales might surge on weekends"). TabPFN outputs true mathematical predictive distributions and quantiles.

4. Data Privacy & Zero Token Inflation

Feeding 90 days of multi-item sales logs into a commercial chat API consumes tens of thousands of tokens per run and exposes confidential boutique business metrics to third-party commercial training pools. TabPFN accepts compact numerical arrays locally or via lightweight API endpoints without token bloat.

My Agent Session

This entire project was engineered collaboratively with Antigravity, an agentic pair programmer.

What We Tackled:

Infrastructure as Code: Architecting render.yaml to overcome common Streamlit PaaS deployment traps (binding to 0.0.0.0, dynamic $PORT handling, and disabling CORS/XSRF for Render).
Tabular Feature Engineering: Designing the rolling window and lag feature transformer in predictor.py to maximize TabPFN's in-context attention.
Resilient Architecture: Writing db.py with tight socket timeouts and graceful session fallbacks so the app works flawlessly out of the box even before external credentials are plugged in.
UI/UX Elevation: Transforming a default Streamlit layout into a glassmorphic dark SaaS interface complete with interactive Plotly confidence bands and styled gradient dataframes.

My First User

To test Restock-Predictor with a real-world side hustle, I shared the live Render deployment with Priya, an independent maker running a hand-poured candle and artisan ceramics shop on Etsy.

The Problem:

Priya had been ordering candle wax and ceramic clay in arbitrary batches every two weeks. Last month, a sudden weekend feature on an Etsy curation feed caused her best-selling soy candle to sell out in 36 hours. She missed out on an estimated \$340 in lost sales while waiting 5 days for a new shipment of soy wax flakes.

The Test Run:

Priya exported her last 90 days of sales as a CSV and uploaded it to Restock-Predictor on Render.

Her Feedback:

"Seeing the amber 'Safety Buffer' band on the chart made it immediately obvious why I keep running out of stock on weekends. My base sales look manageable, but the weekend surge pushes demand way past my typical reorder point. Having an exact restock number with safety buffer included—and being able to download it as a spreadsheet—saved me hours of manual math."

Next Feature Request:

Priya asked if future versions could let her input lead times for her suppliers (e.g., "supplier takes 6 days to deliver") so the app can alert her on the exact calendar day she needs to submit her order.

Prize Categories

🌟 Best Use of Render ($200 Featured Category)

Restock-Predictor is deployed natively on Render using an Infrastructure as Code blueprint (render.yaml).

Zero-Downtime Web Service: Configured with Python 3.11, automatic dependency caching, and clean port forwarding via streamlit run app.py --server.port $PORT --server.address 0.0.0.0.
Production Health Checks: Health check polling wired directly to Streamlit's native endpoint /_stcore/health.
Secure Secret Decoupling: Database credentials (MONGO_URI) and model tokens (TABPFN_API_KEY) are managed through Render's environment dashboard (sync: false), keeping the public repository fully secure.

⚡ Best Use of TabPFN ($200 Featured Category)

TabPFN (tabpfn-client) is the algorithmic core of the platform. We utilize TabPFN's zero-shot in-context learning to perform tabular regression across engineered time-series features without hyperparameter tuning, and extract probabilistic 90th-percentile quantiles to calculate inventory safety stocks.

🍃 Best Use of MongoDB Atlas ($100 Partner Category)

All upload batches, row counts, unique catalog SKUs, and processing metadata are immutably logged to a MongoDB Atlas cluster (pymongo). A dedicated audit tab in the dashboard provides store owners with transparent traceability over past inventory analysis runs.

TrailSense: Touch Grass Safely

Sanjana Devi — Sat, 10 Oct 2026 18:13:54 +0000

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

What I Built

Getting outside shouldn't mean staring at a 2,000-word chatbot wall of text while standing at a windy trailhead or crouching next to an unfamiliar wild mushroom. When you're outdoors, the screen should be the shortest part of the experience—just enough to verify your gear, check a hazard, respect the ecosystem, and keep moving.

TrailSense: Touch Grass Safely is a multimodal outdoor field guide, trail pre-flight safety analyzer, and flora/fauna hazard identification web and mobile app designed with an earthy "Moss & Granite" aesthetic (#1C3F2E Deep Forest Emerald, #2D5A43 Hunter Green, #E3B341 Sunlit Lichen Gold, #C86D51 Terracotta Amber, and #F9F8F3 Warm Parchment).

It is built for day hikers, backpackers, trail runners, dog owners, and amateur naturalists around two focused field workflows:

🏔️ Workflow 1 — Analyze Route / Trail Ahead (Pre-Flight Check):
- Snap or drop a photo of a trailhead sign, alpine talus pass, or unbridged river crossing.
- TrailSense identifies the terrain class (e.g., Loose Alpine Scree & Wet Glaciated Granite), flags visible hazards with HIGH / MODERATE / LOW severity pills and tactical mitigations, recommends specific footwear, and generates an Interactive Essential Gear Checklist.
- As you check off items in your pack (trekking poles, microspikes, drybags, offline GPX map), the Dynamic Radial Safety Meter (0–100% Trail Readiness Score) updates in real time.
🍄 Workflow 2 — Identify Plant / Critter (Bio-Safety & Leave No Trace):
- Snap or upload a macro photo of a mushroom, trailside shrub, wildflower, insect, or reptile.
- TrailSense outputs a tactile Polaroid-Style Specimen Card with pinned badges for Common & Scientific (Binomial) Name, Confidence Level (High / Moderate / Low - Requires closer examination), and a Safety Verdict (SAFE TO TOUCH, CAUTION, DANGEROUS, TOXIC, DEADLY).
- It pairs a 2–3 sentence natural history & ecological profile with a strict Leave No Trace & Handling Directive (e.g., why picking a single Trillium ovatum blossom starves its perennial underground rhizome, or how to decontaminate trekking poles and dog fur after brushing Toxicodendron diversilobum / Western Poison Oak).
🌤️ Backcountry Quick-Toggles & Zero-Signal Field Kit:
- Floating Weather Sync Pill: Displays wind speed, UV index, and a live ticking Sunset Countdown Timer across trailhead elevations.
- Offline-Ready Field Kit (localStorage Cache): Pin any Polaroid route or specimen card before entering a cell dead-zone so your checklists and hazard protocols remain accessible with zero signal.

Demo

🚀 Live App on Render: TrailSense: Touch Grass Safely — Moss & Granite Field Guide

What You Can Try Live Right Now:

One-Click Optical Presets (Zero Setup Required): Click 🟡 Alpine Scree Couloir or 🔴 Glacial River Ford in the Route Ahead dropzone, or click 🔴 Fly Agaric, 🔴 Poison Oak, or 🟢 Trillium in the Plant / Critter dropzone to see procedural field illustrations, Polaroid specimen cards, and hazard breakdowns immediately.
Interactive Readiness Gauge: Check and uncheck pack items in the Interactive Field Readiness Kit and watch the SVG radial Dynamic Safety Meter recalculate your Trail Readiness Score from Terracotta Amber (#C86D51) to Sunlit Gold (#E3B341) to Hunter Green (#2D5A43).
Live Camera & Custom Photos: Open the live WebRTC Trail Camera / Macro Camera (facingMode: "environment") or drop your own outdoor photos to run multimodal inference across Gemma 4 (gemma-4-31b-it, gemma-4-26b-a4b-it) and Gemini 3.8 Flash (gemini-3.8-flash).

Code

sanjana806 / Trailsense

🧭 TrailSense AI Field Guide

Touch Grass Safely & Responsibly — A multimodal outdoor field guide, trail pre-flight safety analyzer, and flora/fauna hazard identification web application powered by the Gemini Interactions API (@google/genai >= 2.28.0), Gemini 3.8 Flash, Gemini 3.5 Flash-Lite, and open-weight Gemma 4 (gemma-4-31b-it / gemma-4-26b-a4b-it).

🚀 Live Demo (Deployed on Render): TrailSense: Touch Grass Safely — Moss & Granite Field Guide

✨ Features

Two Specialized Outdoor Workflows:
- 🏔️ Workflow 1: Trail & Terrain Pre-Flight Check
  - Classifies terrain (Loose Alpine Scree, Wet Glaciated Granite, Bog/Marsh, etc.)
  - Detects visible hazards with HIGH / MODERATE / LOW severity badges and tactical mitigations
  - Generates an Interactive Essential Pack & Footwear Checklist (persisted in localStorage with a live packing progress bar and custom gear additions)
  - Evaluates navigation risk, weather turnaround watchpoints, and cell dead-zone protocols
- 🍄 Workflow 2: Flora & Fauna Identification…

View on GitHub

🔗 GitHub Repository: https://github.com/sanjana806/Trailsense (MIT Licensed)

How I Built It

TrailSense is built around open-weight AI models (gemma-4-31b-it and gemma-4-26b-a4b-it), a two-stage multimodal routing pipeline, and a strict JSON Schema contract powered by the @google/genai SDK (client.interactions.create).

flowchart LR
    A["📷 Optical Input\n(Dual Dropzones / WebRTC Camera / Presets)"] --> B["⚡ Stage 1 Pre-Flight Router\ngemini-3.5-flash-lite"]
    B -->|trail_terrain| C["🏔️ Workflow 1: Route & Terrain\ngemma-4-31b-it / gemini-3.8-flash"]
    B -->|flora_fauna| D["🍄 Workflow 2: Organism Safety\ngemma-4-31b-it / gemini-3.8-flash"]
    C --> E["📊 Structured JSON Schema\nPolaroid Card + Radial Safety Meter + Gear Checklist"]
    D --> E
    E --> F["📓 Offline Backcountry Cache\n& Stateful Field Radio Q&A"]

1. Open-Weight Gemma 4 + Two-Stage Multimodal Routing (`src/analyzer.js`)

In the field, latency and battery matter—and so does never giving a false-positive "safe" verdict on a toxic lookalike. Inspired by Swift's recent DEV benchmark on Flash-Lite routing ("Being overly cautious costs a few cents. Being over confident costs our users' trust... So: when in doubt, defer"), TrailSense implements a two-stage pipeline:

Stage 1 (Sub-Second Modality Triage): When a hiker snaps a photo in auto-mode, gemini-3.5-flash-lite classifies the optical input into trail_terrain (Workflow 1) vs. flora_fauna (Workflow 2) using WORKFLOW_ROUTER_SCHEMA.
Stage 2 (Structured Field Assessment with Open-Weight Gemma 4 & Gemini 3.8): The primary analysis runs on Gemma 4 31B Dense (gemma-4-31b-it), Gemma 4 26B MoE (gemma-4-26b-a4b-it), or Gemini 3.8 Flash (gemini-3.8-flash), enforcing TRAILSENSE_RESPONSE_SCHEMA via response_format:

const interaction = await client.interactions.create({
  model: selectedModel, // "gemma-4-31b-it", "gemma-4-26b-a4b-it", or "gemini-3.8-flash"
  system_instruction: systemPrompt || TRAILSENSE_SYSTEM_PROMPT,
  input: [
    { type: "image", mime_type: mimeType, data: imageBase64 },
    { type: "text", text: `${workflowDirective}${notesDirective}` },
  ],
  response_format: [
    {
      type: "text",
      mime_type: "application/json",
      schema: TRAILSENSE_RESPONSE_SCHEMA,
    },
  ],
});

2. Tactile "Moss & Granite" Instrument UI (`public/app.js` & `public/styles.css`)

Following Sylwia Laskowska's principle and Jana's code-native visual design approach that AI should power deterministic, tactile UI widgets rather than raw chat walls, the frontend turns the structured JSON output into:

A Polaroid Specimen & Route Card with masking-tape accents and pinned taxonomic/hazard badges.
An SVG Radial Safety Meter whose stroke offset (stroke-dashoffset) reacts dynamically as you check off items in your pack.
Stateful Field Radio Follow-Ups that chain previous_interaction_id across turns so hikers can ask quick follow-up questions ("Is this ford safe with a dog at 4 PM?").

Why Does Open Innovation Matter?

When you are 12 miles from the nearest paved road in a mountain basin, closed, black-box AI subscriptions break down in three critical ways that open innovation solves:

Swappable Open-Weight Models (gemma-4-31b-it & gemma-4-26b-a4b-it) & Edge Portability: Because TrailSense is architected around open-weight Gemma 4 models alongside an open JSON Schema contract (src/prompts.js) and an open-source MIT codebase, hikers and search-and-rescue clubs aren't locked into a single proprietary cloud vendor. You can run inference via open-weight Gemma 4 endpoints today, or quantize and run Gemma weights locally on a backcountry device or trailhead Raspberry Pi kiosk with zero internet connectivity.
Auditable Safety Guardrails (No Hidden Prompt Drift): In wild mushroom and poisonous plant identification, a silent prompt change in a closed app can be dangerous. TrailSense makes its entire TRAILSENSE_SYSTEM_PROMPT and TRAILSENSE_RESPONSE_SCHEMA inspectable and editable right inside the UI (📜 Prompt). Our safety rule is explicit and verifiable in code: never state 100% toxicity clearance on wild mushrooms or foraged plants, and always downgrade ambiguous specimens to [Low - Requires closer examination] and [🟡 CAUTION].
Privacy for Backcountry Locations & Rare Species: Rare orchids, slow-growing wildflowers like Trillium ovatum, and sensitive wildlife habitats suffer from poaching when coordinates are harvested by closed commercial platforms. An open-source, self-hostable field guide with localStorage offline caching keeps your photos, field notes, and trail logs under your own control.

My Agent Session

I built TrailSense pair-programming with Antigravity (powered by Gemini 3.8 Flash), iterating from the core two-workflow field safety system prompt to the full-stack Express + @google/genai backend, the Moss & Granite UI, GitHub push, and Render deployment:

Step 1: Designed the dual-workflow schema (trail_terrain & flora_fauna) and implemented the two-stage router + open-weight Gemma 4 (gemma-4-31b-it / gemma-4-26b-a4b-it) & Gemini 3.8 Flash analyzer in src/analyzer.js.
Step 2: Built the Moss & Granite UI with topographic SVG contour backdrops, Dual Upload Dropzones, the Polaroid Specimen Card, the live SVG Radial Safety Meter, and Floating Weather/Offline Quick-Toggles.
Step 3: Added offline fallback heuristics so every preset, custom upload, and Field Radio follow-up works out-of-the-box on Render even before a user supplies their own API key.

Prize Categories

Best Use of Gemma: TrailSense integrates Google's open-weight Gemma 4 models (gemma-4-31b-it Dense and gemma-4-26b-a4b-it MoE) directly into its multimodal field analysis and stateful Field Radio Q&A pipeline, allowing users to switch seamlessly to open-weight Gemma 4 inference from the header bar.
Best Use of Render: TrailSense is deployed as a live, full-stack Node.js web service on Render at https://trailsense.onrender.com/, serving both the zero-build Moss & Granite frontend and the /api/analyze, /api/presets/:id, and /api/followup backend endpoints.

My Journey as a B.Tech AI & ML Student 🚀

Sanjana Devi — Fri, 09 Oct 2026 05:13:13 +0000

As a B.Tech student specializing in Artificial Intelligence and Machine Learning, I'm constantly exploring new technologies and building projects that help me learn by doing.

Recently, I've been focusing on:

✅ Python and Machine Learning fundamentals
✅ SQL and database design
✅ Web development with HTML, CSS, and JavaScript
✅ Git and GitHub for version control
✅ Using AI tools to improve productivity and learning

One thing I've learned is that consistency beats intensity. Spending even one hour every day coding, reading documentation, or working on a project compounds into significant progress over time.

My current goal is to build projects that combine AI and web development while contributing more to open-source communities.

What are you currently learning or building? I'd love to connect with fellow developers, students, and creators on a similar journey.

DEV Community: Sanjana Devi

SlothFeed: How I Paired Gemma 2 and Render to Automate My Unread Tab Guilt Away

Restock-Predictor: AI-Powered Inventory Forecasting for Etsy & Shopify Side Hustles with TabPFN

Extract tabular representations for TabPFN's in-context attention mechanism

Predict both expected demand (median) and 90% risk ceiling for safety stock

Restock-Predictor: AI-Powered Inventory Forecasting for Etsy & Shopify Side Hustles with TabPFN

What I Built

Who Would Pay For It?

Demo

Key UI Features:

Code

sanjana806 / Restock-Predictor

⚡ Restock-Predictor: Premium AI Inventory Intelligence

🌟 Executive Summary & Problem Statement

Modular Project Architecture:

How I Built It

1. The Core AI Model: TabPFN (Prior-Data Fitted Network)

Tabular Feature Engineering Pipeline (predictor.py)

Probabilistic Quantile Forecasting

2. Frontend & Visual Polish (Streamlit + Plotly)

3. Cloud Audit Trails (MongoDB Atlas)

4. Continuous Deployment on Render

Why Does Open Innovation Matter?

1. Continuous Numerical Precision vs. Token Hallucinations

2. Sub-Second Bayesian Inference (< 500ms)

3. Native Probabilistic Uncertainty

4. Data Privacy & Zero Token Inflation

My Agent Session

What We Tackled:

My First User

The Problem:

The Test Run:

Her Feedback:

Next Feature Request:

Prize Categories

🌟 Best Use of Render ($200 Featured Category)

⚡ Best Use of TabPFN ($200 Featured Category)

🍃 Best Use of MongoDB Atlas ($100 Partner Category)

TrailSense: Touch Grass Safely

What I Built

Demo

What You Can Try Live Right Now:

Code

sanjana806 / Trailsense

🧭 TrailSense AI Field Guide

✨ Features

How I Built It

1. Open-Weight Gemma 4 + Two-Stage Multimodal Routing (src/analyzer.js)

2. Tactile "Moss & Granite" Instrument UI (public/app.js & public/styles.css)

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

My Journey as a B.Tech AI & ML Student 🚀

Tabular Feature Engineering Pipeline (`predictor.py`)

1. Open-Weight Gemma 4 + Two-Stage Multimodal Routing (`src/analyzer.js`)

2. Tactile "Moss & Granite" Instrument UI (`public/app.js` & `public/styles.css`)