DEV Community: Rimsha

CraveCast: Stop Guessing Batch Sizes & Burning Cash — AI Demand Forecasting for Home Food Side Hustles

Rimsha — Fri, 16 Oct 2026 21:03:55 +0000

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

What I Built

If you’ve ever run a home food business—whether baking custom cakes, prepping weekly tiffin boxes, or running a late-night cloud kitchen—you know the Margin Trap:

Over-prep by 15 portions, and your entire profit margin for the day goes straight into the trash as spoiled ingredients.
Under-prep by 15 portions, and you turn away hungry customers while leaving guaranteed money on the table.

Most home food entrepreneurs make daily prep decisions based on pure gut feeling. They don't have access to enterprise demand planning software, nor do they have time to manually analyze weather forecasts, mid-month wallet slumps, or temperature spikes.

CraveCast changes that. It is a specialized, open-source AI operational co-pilot built specifically for micro food side-hustles.

Local Inputs
│
▼
┌──────────────────┐
│ TabPFN Engine │ ──► Zero-Shot Portion Demand & Waste Risk %
└──────────────────┘
│
▼
┌──────────────────┐
│ Dish Procurement │ ──► Dynamic Grocery Matrix (Flour, Butter, Meat, Boxes)
└──────────────────┘
│
▼
┌──────────────────┐
│ Gemma Synth │ ──► Pre-Order Broadcast (1-Click WhatsApp Launch)
└──────────────────┘

What CraveCast Actually Does:

Predicts Exact Prep Batches: Uses a zero-shot tabular AI model to calculate optimal portion targets based on hyper-local operational signals (weekday vs. weekend, ambient heat, rain forecasts, and payday cycles).
Explains the "Why" (TabPFN Decision Matrix): Breaks down the reasoning into clear drivers (e.g., +15 Weekend Surge, -8 Rain Impact, +10 Payday Boost) so the cook understands the logic.
Generates a Dish-Specific Grocery Matrix: Type any custom dish—like "Belgian Fudge Chocolate Cake", "Steamed Beef Momos", or "Spicy Szechuan Hotpot"—and CraveCast dynamically calculates the raw material shopping list down to kilograms, liters, and packaging units.
Locks in Pre-Orders Before Cooking (Gemma Synthesis): Drafts an optimized pre-order campaign with a direct 1-click WhatsApp launch button so sellers capture upfront orders before buying ingredients.
Real-Time Profit Guard: Detects when cost per portion exceeds selling price and warns the user before they lock in a deficit.

Demo

🔗 Live Application: https://crave-cast-seven.vercel.app/

Try It Yourself in 30 Seconds:

Open the live link and pick your local currency (PKR ₨, USD $, EUR €, AED 🇦🇪, etc.).
In the Dish / Menu Item field, test different items like "Belgian Chocolate Cake" vs. "Steamed Beef Momos".
Toggle the weather forecast to Rainy or temperature to 35°C.
Click Run CraveCast Agent ✨.
Watch the dashboard calculate portion counts, swap ingredient matrices, highlight spoilage risk, and generate a WhatsApp broadcast caption ready to send!

Code

rimshacodes5 / CraveCast

Created for Hacktoberfest 2026 🎃 An AI agent pipeline combining zero-shot tabular demand forecasting, dish-specific grocery procurement, pre-order social synthesis, and full Sentry telemetry tracing.

CraveCast 🥐🍱 — Predictive Demand & Waste Prevention Engine for Home Food Entrepreneurs

Created for Hacktoberfest 2026 🎃

An AI agent pipeline combining zero-shot tabular demand forecasting, dish-specific grocery procurement, pre-order social synthesis, and full Sentry telemetry tracing.

📌 Project Overview

CraveCast is a culinary-themed AI decision dashboard designed for home-based food entrepreneurs, cloud kitchens, meal preppers, and artisanal bakers. By analyzing hyper-local environmental factors—such as day of the week, weather forecasts, ambient temperature, and payday cycles—CraveCast predicts exact batch prep requirements, estimates food spoilage risks, and calculates protected capital.

Additionally, CraveCast automatically synthesizes dish-specific raw ingredient shopping lists and generates high-converting pre-order broadcasts for WhatsApp and Instagram to lock in orders before cooking starts.

✨ Key Features

🧠 TabPFN Zero-Shot Demand Engine: Predicts optimal batch sizes and calculates waste risk percentages based on real-time operational factors.
📊 TabPFN Decision Matrix Breakdown: Explains the exact reasoning behind portion…

View on GitHub

How I Built It

I designed CraveCast around a fast, modern full-stack TypeScript stack styled in a custom Dark Chocolate & Cream aesthetic (#1C100D background with warm terracotta accents):

1. TabPFN (Tabular Demand Engine)

Food demand forecasting isn't an NLP problem—it's a tabular pattern matching problem. Standard LLMs struggle with precise numerical reasoning across multi-variable tables. I used TabPFN as a zero-shot tabular engine inside the backend route (src/app/api/forecast/route.ts). It evaluates environmental features in milliseconds without needing an expensive, heavy training pipeline.

2. Gemma (Pre-Order Broadcast Synthesis)

Once TabPFN outputs the recommended portion count, Gemma formats that numerical state into compelling, action-oriented pre-order copy designed for social broadcasts (Instagram stories & WhatsApp status updates).

3. Sentry Agent Telemetry & Instrumentation

AI pipelines fail silently if you don't trace them properly. I instrumented the backend with Sentry startSpan tracking across every step:

agent.pipeline (Parent execution wrapper)
ai.tabpfn (Tabular demand & decision matrix calculation)
ai.gemma (Social caption synthesis)

Every execution passes back a real-time sentryTraceId to verify pipeline health and monitor response latency directly on the dashboard.

4. Next.js 16 & Tailwind v4

Built using Next.js 16 (App Router + Turbopack) for fast server route evaluation, paired with Tailwind CSS v4 and Lucide React icons for a responsive mobile layout.

Why Does Open Innovation Matter?

When building tools for micro-entrepreneurs, software cost is everything.

A solo home baker making $150 a week cannot afford a $49/month SaaS subscription or pay-per-token API bills that spike unexpectedly. Open-source models like TabPFN and open-weight models like Gemma democratize enterprise-grade intelligence.

Open innovation lets us embed sophisticated prediction logic directly into lightweight web apps that any small business owner can use for free—keeping privacy intact and operating costs near zero.

My Agent Session

I built CraveCast through interactive human-AI pair programming inside Cursor IDE. Using iterative terminal agent runs, we resolved PostCSS configuration setups for Tailwind v4, constructed dynamic ingredient mapping logic for custom dish inputs, and linked Sentry spans across the backend route.

My First User

I put CraveCast to the test with a friend running a home-based bakery side business.

The Before:

On hot mid-month weekdays, she used to bake a standard batch of 50 portions based on habit. On slow days (35°C heat + mid-month wallet slumps), up to 15 portions remained unsold, burning over Rs 8,000 ($30+) in wasted butter, cream, and packaging every single week.

The Test Run:

We plugged her parameters into CraveCast. The TabPFN matrix flagged a high spoilage risk day (35% risk index) and recommended cutting the prep batch down to 40 portions. She clicked Launch WhatsApp, blasted the Gemma-generated pre-order text to her customer broadcast list, and locked in 32 pre-orders before turning on the oven.

Result? Zero wasted inventory for the day and protected profit margins!

Prize Categories

Primary Track: Hacktoberfest Week 2 — Side Hustle
TabPFN Track: Best use of TabPFN for zero-shot tabular demand prediction & waste risk evaluation
Sentry Track: Full multi-span agent pipeline instrumentation and telemetry tracing (agent.pipeline → ai.tabpfn → ai.gemma)

GROQ & Dagger 🕵️‍♂️⚡: Unraveling Cyber-Noir Cold Cases with Graph Relational Queries

Rimsha — Wed, 30 Sep 2026 16:35:13 +0000

This is a submission for the Sanity Challenge, Path Two: Vibe-Code Something Strange

What I Built

Imagine stepping into a neon-soaked, retro-terminal precinct where every suspect dossier, physical evidence locker, and conflicting testimony is bound together in a live graph database.

GROQ & Dagger is an atmospheric cyber-noir interactive crime investigation board. Designed for digital detectives, mystery enthusiasts, and developers exploring structured content, it replaces static corkboards with a dynamic terminal desk.

Instead of running heavy client-side loops or complex database joins, GROQ & Dagger leverages Sanity’s GROQ (Graph Relational Object Queries) engine to dereference deeply linked document references in a single query payload. Click on any suspect, and the entire desk dynamically isolates every piece of tied physical evidence, alibi flaw, and testimony contradiction in real time.

Demo

🌐 Live Application: https://groq-and-dagger.vercel.app/

⚡ Key Features & Interface Highlights

🚨 CRT Terminal & Cyber-Noir Aesthetic: Dark mode grid overlay, glowing scanlines, and neon caution indicators (⚠️ CRIME SCENE DO NOT CROSS).
🕵️️ Suspect Dossier Vault: Inspect suspect profiles, aliases, alibis, and real-time status badges (PRIME SUSPECT, CLEARED, UNDER WATCH).
🔍 Interactive Evidence Locker: High-resolution physical and digital evidence assets fetched from Sanity CDN.
⚡ Contradiction Matrix: Automated flags highlighting conflicting alibis cross-referenced directly against physical evidence.
⏳ Chronological Timeline Engine: Sequential step-by-step breakdown of verified factual crime scene events.
🎯 One-Click Cross-Referencing: Selecting any suspect dynamically highlights and isolates their connected evidence and contradictions across the entire dashboard.
📊 Live Case Metrics Bar: High-visibility header counters tracking total suspects, evidence items, contradictions, and timeline events on file.

Code

📁 GitHub Repository: https://github.com/rimshacodes5/groq-and-dagger

My Build Process

Building GROQ & Dagger was an experiment in vibe-coding an immersive retro-tech interface using Next.js (App Router with Turbopack), Tailwind CSS, and Sanity Studio v3.

1. Vibe-Coding the UI & Interactivity

I wanted the dashboard to feel like a high-stakes investigation terminal. Iterating with AI prompts, we focused on:

Designing custom Tailwind CSS utilities for CRT scanline overlays and glowing neon status badges (Amber for suspects, Cyan for evidence, Red for contradictions, Emerald for verified facts).
Building responsive React state logic for multi-directional cross-filtering—clicking a suspect highlights their connected evidence cards seamlessly without breaking the layout.

2. Obstacles & Course-Corrections

During the build and deployment pipeline, we navigated three key engineering hurdles:

Git Index Cache Cleanup: Build artifacts (.next and node_modules) were initially tracked in git history. We updated .gitignore and purged the index using git rm -r --cached . to ensure a clean commit repository.
The .next Output Directory Build Fix: The initial Vercel deployment failed because package.json was executing "build": "sanity build". Re-routing the script to "build": "next build" allowed Next.js to compile production bundles cleanly on Vercel edge servers.
Sanity CORS Whitelisting: Production deployment required authorizing the live Vercel domain (https://groq-and-dagger.vercel.app) inside the Sanity Management Dashboard under API settings with credentialed access enabled.

Sanity Project Details

Sanity Project ID: ur1wyqmd
Dataset: production

Structured Content Schema

The content model comprises 4 interconnected schema types linked via reference arrays (type: 'reference'):

suspect: Name, alias, alibi, status, background notes, and photo asset.
evidence: Title, type (physical/digital), location found, description, photo asset, and connectedSuspects reference array.
contradiction: Title, description, severity score, suspectInvolved reference, and evidenceInvolved reference array.
timelineEvent: Timestamp, title, description, and verification status.

Querying the Web of Clues with GROQ

GROQ’s -> dereferencing operator allowed us to resolve multi-level document graphs effortlessly in a single request:


groq
// Dereferencing Suspects & Linked Evidence inside Contradictions
*[_type == "contradiction"] {
  _id,
  title,
  description,
  severity,
  suspectInvolved-> {
    _id,
    name,
    alias
  },
  evidenceInvolved[]-> {
    _id,
    title
  }
}

// Resolving Connected Suspect Profiles for Physical Evidence
*[_type == "evidence"] {
  _id,
  title,
  type,
  description,
  locationFound,
  "imageUrl": image.asset->url,
  connectedSuspects[]-> {
    _id,
    name,
    status
  }
}

We Built an AI Agent That Intentionally Breaks Code to Fix It Before Hackers Do

Rimsha — Sun, 27 Sep 2026 13:39:56 +0000

We just wrapped up our submission for the IBM Bob 2.0 Hackathon!

Our team, Syntax and Synergy, built Resilix—an autonomous adversarial agent that tests code resilience and auto-generates defensive security patches before code hits production.

🚨 The Problem

Developers and AI models are writing code faster than ever. However, security testing tools are often built for slow, late-stage pipeline audits rather than active development. Unhandled null pointers, string overflows, and SQL injections frequently slip through under hostile edge cases.

🛡️ What Resilix Does

Resilix acts as a real-time defensive assistant:

Multi-Vector Payload Fuzzing: Analyzes code against SQLi, null pointer exceptions, buffer overflows, and malformed structures.
Dynamic Resilience Score: Deducts severity weights to calculate a instant 0–100 safety score.
Automated Defensive Patching: Generates copy-pasteable fixed code snippets alongside detailed risk breakdowns.
Chaos Dashboard: A clean, dark-mode web UI for instant local testing.

🧰 How We Built It with IBM Bob 2.0

The entire application was built inside the IBM Bob 2.0 environment:

Plan Mode: Structured our microservice architecture, API endpoints (/api/fuzz), and scoring formulas.
Agent Mode: Generated our Flask server logic (app.py) and single-page interactive UI (index.html).
Workspace Context: Maintained rules across .bob/rules-* and tracked all execution logs in bob_sessions/.

🔗 Links & Resources

🎥 Video Demo: https://youtu.be/F5wpFuI9aHM

We'd love to hear your thoughts and feedback from the DEV community! 🚀

Ripple 💧 – Transform Spare Time into Micro-Missions of Generosity

Rimsha — Mon, 07 Sep 2026 10:25:35 +0000

This is a submission for the DEV Weekend Challenge: Generosity Edition.

Prize Category Targeted: Best use of Google AI 🤖

💧 What I Built

Most people genuinely want to help others, but traditional volunteering often demands fixed multi-hour commitments, and charity donations require spare capital. Many everyday acts of generosity go unperformed simply because people don't know what small action they can take with the 15 minutes or $0 budget they have right now.

Ripple is an AI-powered micro-mission engine designed to eliminate that friction.

By inputting basic constraints—such as 20 minutes of free time, a laptop, basic digital skills, or a $0 budget—Ripple generates immediate, tailored, step-by-step acts of kindness that can be executed on the spot.

🌐 Live Demo & Code

🚀 Live Application: https://ripple-ecru.vercel.app/
🐙 GitHub Repository: https://github.com/rimshacodes5/Ripple

🤖 How Google AI Powers Ripple

Ripple relies on Google Gemini 3.6 Flash (@google/genai) to dynamically translate raw user constraints into actionable missions.

1. Strict Schema Validation

Rather than receiving unstructured text, our Node.js serverless backend enforces a strict Type.OBJECT JSON schema via the Gemini SDK. This ensures Gemini returns predictable data structures containing a title, estimatedTime, cost, whyItFits rationale, and an array of 3 execution steps.


javascript
const missionSchema = {
  type: Type.OBJECT,
  properties: {
    title: { type: Type.STRING },
    estimatedTime: { type: Type.STRING },
    cost: { type: Type.STRING },
    whyItFits: { type: Type.STRING },
    steps: { type: Type.ARRAY, items: { type: Type.STRING } }
  },
  required: ["title", "estimatedTime", "cost", "whyItFits", "steps"]
};

---

### 2. High-Demand API Spike Resilience
To guarantee seamless reliability during high traffic, the backend incorporates an automated exponential backoff retry loop. If Google's API returns a temporary `503 High Demand` spike, the serverless handler automatically retries up to 3 times before returning the output to the user.

---

## ✨ Features & User Experience

* **Interactive Water Reservoir:** A custom CSS glassmorphism liquid tank that fills up as you complete missions, giving immediate visual feedback for your impact.
* **Synthesized Audio Interactions:** Built with the browser's native **Web Audio API** to generate organic water-drop sound effects upon marking tasks complete without external audio assets.
* **Persistent Impact Tracker:** Uses browser `localStorage` to preserve your total impact level and complete mission history across sessions.
* **Serverless Architecture:** Decoupled deployment with static assets served via Vercel's global CDN and API requests routed through Node.js serverless functions.

---

## ❤️ Relevance to the Theme

Inspired by the theme of **Technology-Driven Giving**, Ripple reimagines generosity not as a grand, occasional event, but as a continuous daily habit. By using AI to make micro-volunteering accessible to anyone regardless of age, income, or location, Ripple proves that even the smallest action creates a lasting impact.

---

*Built with Node.js, Express, Google Gemini 3.6 Flash, HTML/CSS/JS, and deployed on Vercel.*