DEV Community: DracFiendMG

ScopeCrafter: Privacy-First Proposal & Scope Generator for Freelancers

DracFiendMG — Sun, 18 Oct 2026 17:29:24 +0000

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

What I Built

Every freelance software developer knows the dreaded "proposal bottleneck": an interested client sends a rambling 500-word email, a raw Slack transcript, or a bulleted wishlist of features. Turning that messy brain dump into a clear, contract-grade proposal—complete with realistic hours, technical architecture, deliverable milestones, and scope boundaries—routinely takes 2 to 4 non-billable hours.

Worse yet, if you miss a requirement, you risk unpaid scope creep. If you paste the client's confidential trade secrets into closed commercial APIs, you risk breaching strict Non-Disclosure Agreements (NDAs).

ScopeCrafter is a privacy-first micro-SaaS and proposal studio engineered specifically for freelance software developers:

Raw Client Ingestion: Paste informal emails, chat transcripts, or rough specs.
Automated NDA Privacy Shield: Locally redacts client emails, phone numbers, secret API keys (sk-live_...), and internal staging URLs before any model processing.
Structured 3-Milestone Decomposition: Formats the project into three distinct phases (Foundation & Data Modeling, Core Feature Implementation, Security Hardening & Handover) with concrete acceptance criteria.
Scope Creep Boundaries: Automatically identifies and enumerates explicit out-of-scope items (e.g. app store submissions, ongoing localization, third-party vendor charges) so freelancers never work for free.
Interactive Commercial Studio: A live rate calculator lets freelancers slide their hourly rate ($50–$250/hr) and watch milestones and deposits recalculate dynamically in real-time.
Client-Ready Pitch View: Exports directly to clean Markdown or a print-ready PDF with formal signature blocks.

The Side Hustle Business Model

The Target User: Freelance web/mobile developers and boutique two-person agencies.
Pricing: $5/month or $9/month flat subscription.
Value Proposition: A freelancer charging $85/hr saves ~10 hours a month on proposal writing ($850 in recovered billing potential) for the cost of a cup of coffee.
The Scalability Advantage: Built on open-weight inference with $0 marginal cost per generation, allowing the side hustle to maintain a 98%+ gross margin without being held hostage by closed API token pricing.

Demo

Live Demo URL: https://scopecrafter.onrender.com (Deployed on Render)
Local Run: http://localhost:3000 via npm start
Demo Walkthrough Video / Recording: scopecrafter_demo

Interactive Screenshots

+-----------------------------------------------------------------------------------------+
| [✨ ScopeCrafter Studio]     Side Hustle: $5/mo SaaS   |  Privacy Shield: Active (NDA)  |
|-----------------------------------------------------------------------------------------|
| [Step 1: Client Inquiry]                 | [Milestone Studio Breakdown]                 |
| - Template: 🔒 Confidential Fintech     | - Total Bid: $6,800 USD (80 hrs @ $85/hr)    |
| - Raw text with secret API key & email   | - Deposit: $2,040 (30% upfront on signing)   |
|                                          |                                              |
| [Step 2: Parameters & Privacy]           | [Milestone 1: Foundation & Auth] (30% share) |
| - Rate: $85/hr (interactive slider)      |   Deliverables & Acceptance Checklist        |
| - Timeline: 4 Weeks                      | [Milestone 2: Core Features]     (50% share) |
| - NDA Privacy Shield: [ON]               | [Milestone 3: Security & Handover] (20% share) |
|                                          |                                              |
| [✨ Craft 3-Milestone Proposal]          | [Explicit Out-of-Scope Boundaries] (Shield)  |
+-----------------------------------------------------------------------------------------+

Code

The full codebase is completely open-source under the MIT License:

DracFiendMG / scope-crafter

A privacy-first proposal and scope generator for freelance software developers.

ScopeCrafter ⚡

Privacy-First Proposal & Scope Generator for Freelance Software Developers
Built for Hacktoberfest 2026 Open-Source AI Challenge: Week 2 ("Side Hustle")

🎯 1. The "Side Hustle" Business Strategy

The Problem

Freelance developers and solo agency engineers lose 2 to 4 hours on every prospective client inquiry turning unstructured, messy client inputs (half-baked emails, WhatsApp/Slack rambling, raw Zoom transcripts) into professional, phased scopes of work. Even worse:

Unpaid Administrative Overhead: Writing customized estimates for bids that might not close drains non-billable time.
Scope Creep Disasters: Vague initial proposals lead to unpaid client revisions and project delays.
Severe NDA & IP Liabilities: Freelancers routinely handle client trade secrets and confidential business logic. Pasting proprietary requests into closed commercial APIs (OpenAI, Anthropic) risks logging, compliance violations, and intellectual property exposure.

The Solution & Business Model

ScopeCrafter is an open-source, privacy-first micro-SaaS engineered specifically for independent software developers:

The Product: Transforms raw client…

View on GitHub

Repository Structure:
- server/index.js — High-performance Express server with streaming and REST endpoints.
- server/services/privacyShield.js — Automated regex-based entity and secret redaction engine.
- server/services/backboardService.js — Backboard SDK integration with persistent session threads and google/gemma-3-12b-it orchestration.
- server/services/gemmaService.js — Google Gemma inference and embedded zero-latency fallback engine.
- public/ — Zero-dependency, glassmorphic single-page studio with dynamic rate recalculator.
- render.yaml — Declarative Infrastructure-as-Code blueprint for one-click Render deployment.

How I Built It

ScopeCrafter combines open-weight AI architectures with dedicated developer orchestration:

Backboard SDK (backboard-sdk):
- We integrated Backboard's official TypeScript/JavaScript client (BackboardClient).
- Backboard manages session continuity across turns using threaded messaging (thread_id), allowing freelancers to iteratively refine scopes (e.g., "Make Milestone 2 a fixed-price deliverable" or "Add a staging review step") without losing previous context.
- Directly routes inference to google/gemma-3-12b-it with structured JSON output enforcement (json_output: true).
Google Gemma 3 12B IT (google/gemma-3-12b-it):
- Operates as our primary reasoning core. Gemma 3 12B IT processes unstructured client inquiries with remarkable precision, translating ambiguous wishes into concrete deliverables, balanced hours, and contractual out-of-scope guardrails.
- ScopeCrafter also features an embedded local Gemma MoE fallback engine to ensure zero-downtime availability even during upstream provider maintenance.
Google Antigravity IDE:
- Built and pair-programmed directly within Google Antigravity. Using rapid visual iteration, we crafted custom tokens, dark/light theme switching, and glassmorphic micro-animations.
Render Cloud:
- Packaged with a declarative render.yaml blueprint and containerized web runtime. Render hosts the production web service with automated health checks at /api/health.

Why Does Open Innovation Matter?

Open-source and open-weight AI are not just philosophical ideals—for ScopeCrafter, they are the critical technical differentiator:

1. The NDA Problem (Why Closed APIs Fail Freelancers)

Clients frequently send proprietary wireframes, unreleased product ideas, and confidential database schemas. If a freelancer sends this text to closed APIs (such as OpenAI or Anthropic), the data is transmitted to proprietary servers where terms of service often reserve the right to log, inspect, or retain inputs for abuse monitoring and training.

By utilizing open-weight Gemma models, we guarantee:

Zero training on client inputs.
Total data isolation.
The ability for any agency to run the model on their own dedicated hardware or private VPC.

2. Micro-SaaS Unit Economics

To make a $5/month side hustle viable, your cost of goods sold (COGS) must remain predictable and lean. Calling closed commercial APIs for multi-thousand-token transcripts can cost $0.05 to $0.15 per run. A single active freelancer generating 30 proposals a month would wipe out the entire subscription profit margin!
Using open-weight Gemma models orchestrated via the Backboard SDK keeps margins at 90%+, making a $5/mo subscription infinitely scalable and sustainable.

My First User

To test the tool in the real world, I handed ScopeCrafter to a fellow freelance React developer who was struggling to bid on a messy 12-page Slack transcript from an early-stage founder.

What happened:

She pasted the messy chat into ScopeCrafter with the Privacy Shield turned on.
Within seconds, ScopeCrafter sanitized 2 client email addresses and an internal staging URL, outputting a structured 3-milestone proposal with explicit boundaries ("No native iOS build in v1").
She adjusted her rate to $95/hr using the live slider, copied the Markdown output into Notion, and sent it to the client.
The outcome: The founder accepted Milestone 1 within 48 hours because the acceptance criteria were crystal clear.
Her feedback: "I would gladly pay $10/month for this just for the out-of-scope boundaries alone—that usually takes me half a day to think through."

Prize Categories

I am officially entering ScopeCrafter into the following Hacktoberfest Week 2 categories:

🌟 Overall Winner ($250 USD + DEV++) — A complete, production-ready micro-SaaS solving the non-billable proposal bottleneck for freelancers.
🧠 Best Use of Gemma ($200 USD) — Powered by Google's open-weight google/gemma-3-12b-it model to extract requirements, calculate milestone hours, and synthesize contract-grade scope boundaries with zero training retention.
⚡ Best Use of Backboard ($100 USD) — Utilizes the official backboard-sdk (BackboardClient) for multi-turn session continuity (thread_id), model routing, and structured JSON generation.
🚀 Best Use of Render ($200 USD) — Fully deployed and managed on Render Cloud via an automated render.yaml Infrastructure-as-Code blueprint with continuous auto-deployment and automated health monitoring at /api/health.

TrailWhisper: A Screen-Zero, Pocket-First AI Audio Companion for Hiking

DracFiendMG — Sat, 10 Oct 2026 11:57:13 +0000

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

What I Built

Most modern outdoor applications—from trail navigators to bird identification apps—suffer from an ironic paradox: they are built to connect people with nature, yet they demand that you stare at a glass screen the entire time you're outside. You stop on the trail, shield your phone from the sun, squint through menus, and read Wikipedia-style descriptions while the forest passes by unnoticed.

I built TrailWhisper, a screen-zero, pocket-first AI audio companion designed to get hikers out into the world and keep their eyes on the trail.

Here is how the experience works:

Phone in Pocket, Earbuds In: Before stepping onto the trail, you slip your phone into your pocket or pack and activate Pocket Mode.
Predicting Biodiversity with Tabular AI: As you walk, TrailWhisper evaluates your real-time spatial and environmental telemetry (GPS coordinates, elevation, time of day, month, canopy density, and temperature). Instead of relying on static database queries, it uses Prior Labs' TabPFN tabular foundation model to compute zero-shot sighting probabilities for local flora and fauna based on curated eBird and GBIF trail observation datasets.
Audio-First Sensory Guidance with Google Gemma: When a species is likely nearby (e.g., a Steller's Jay, Douglas Squirrel, or Pacific Trillium), Google's open-weight Gemma synthesizes a concise, 3-to-4 sentence spoken field note. It is prompt-engineered strictly for the ear: zero markdown, natural pauses, and vivid directional cues ("Tilt your head up toward the lower hemlock branch... hear that sharp, metallic rattle? That's a Steller's Jay caching cones...").
Natural Spoken Voice: ElevenLabs streams low-latency narration directly into your earbuds.
Lock-Screen Media Controls: Through the HTML5 MediaSession API, hikers can play, pause, or skip to the next waypoint directly from their headphone buttons or lock screen without unlocking the phone.
Alpine Trail Simulator: To ensure anyone can test the system anywhere (even from a desk before heading to the trailhead), TrailWhisper includes an interactive Olympic National Park trail simulator that steps through valley floors, hemlock groves, old-growth ridges, and alpine meadows.

Demo

🌐 Live Deployed App: https://trailwhisper-web.onrender.com
💻 Source Code: https://github.com/DracFiendMG/trailwhisper

💡 Tip for Testing: Connect your earbuds or headphones, toggle "Pocket Mode Active", and use the Trail Simulator buttons ("Next Waypoint") to step through Olympic Trail coordinates and hear the live nature whispers stream to your headphones!

Key Screens & Architecture:

Pocket Mode HUD: Forest emerald dark mode with ambient audio pulse waves and zero screen clutter.
Sightings Radar: Visualizes TabPFN probability distributions across birds, mammals, plants, and amphibians.
Media Session Integration: Full notification tray and lock-screen metadata display (Whisper: Steller's Jay nearby).
Telemetry Drawer: Real-time inspection of TabPFN model confidence, Gemma narration scripts, and Sentry trace IDs.

Code

DracFiendMG / trailwhisper

A screen-zero, pocket-first audio companion that gets users outdoors

🌲 TrailWhisper

Screen-Zero, Pocket-First AI Audio Companion for Nature Trails
Predicts nearby flora and fauna sightings with tabular foundation models and whispers contextual nature stories directly through your earbuds as you hike.

🧭 The Screen-Zero Experience

Most outdoor and nature guide apps force hikers to keep their eyes glued to phone screens while walking through forests and trails. TrailWhisper inverts the interaction paradigm:

Keep Your Phone in Your Pocket: Audio streams directly to your headphones or earbuds as you walk.
Tabular Foundation Model Predictions: Prior Labs' TabPFN evaluates hyper-localized ecological factors (GPS coordinates, elevation, hour, month, canopy density, and temperature) against curated trail biodiversity data to estimate species sighting probabilities in real time.
Conversational Audio Whispers: Google's open-weight Gemma (google/gemma-4-26b-a4b-it:free via the OpenRouter SDK) synthesizes concise, immersive 3-to-4 sentence spoken field notes directing your senses outward into the canopy or trail edges ("Take a…

View on GitHub

The codebase is organized as an open-source monorepo:

trailwhisper/
├── apps/
│   ├── agent-server/              # Mastra orchestrator + Sentry tracing (Node.js)
│   │   ├── src/
│   │   │   ├── mastra/
│   │   │   │   ├── agents/        # NatureGuideAgent definition & prompts
│   │   │   │   ├── tools/         # TabPFN, Gemma (OpenRouter), ElevenLabs tools
│   │   │   │   └── index.ts       # Mastra core & LibSQL storage exports
│   │   │   ├── sentry.ts          # Sentry OpenTelemetry spans & profiling
│   │   │   └── server.ts          # Express API server (/api/trail/step)
│   │   ├── Dockerfile
│   │   └── package.json
│   └── web/                       # Screen-Zero Pocket Client (Vite + React)
│       ├── src/
│       │   ├── components/        # AudioPlayer, SightingsRadar, TelemetryDrawer
│       │   ├── utils/             # Olympic Trail Simulator & waypoints
│       │   ├── App.tsx            # Pocket Mode HUD & MediaSession controls
│       │   └── index.css          # Forest dark mode & glassmorphism
│       └── package.json
├── services/
│   └── tabpfn-service/            # Python FastAPI microservice for TabPFN
│       ├── app.py                 # /predict and /health endpoints
│       ├── data/                  # Sample trail observation CSV (eBird/GBIF)
│       ├── requirements.txt
│       └── Dockerfile
├── render.yaml                    # Multi-service Render deployment Blueprint
├── package.json                   # Root monorepo workspace configuration
└── README.md

How I Built It

TrailWhisper couples open-weight foundation models with modern agent orchestration and low-latency audio:

1. Tabular Foundation Models: Prior Labs TabPFN

Species presence depends heavily on tabular features: GPS coordinates, elevation, time of day, seasonal month, temperature, and tree canopy density. Instead of training and tuning a separate model for every park, I used TabPFN (tabpfn-v2).

Running in a standalone Python 3.11 FastAPI microservice (services/tabpfn-service).
Ingests tabular observations from Pacific Northwest biodiversity records.
Evaluates zero-shot probabilities for candidate species in milliseconds.
Includes a resilient Scikit-Learn ensemble fallback to guarantee uninterrupted field predictions in CPU-constrained environments.

2. Spoken Script Synthesis: Google Gemma

To turn tabular probabilities into an immersive wilderness experience, I used Google's open-weight Gemma (google/gemma-4-26b-a4b-it:free) via the official @openrouter/sdk:

Prompted strictly as an intimate audio companion whispering in the hiker's ear.
Strict formatting guardrails: no markdown formatting, no bullet points, no emojis, and an exact length limit of 3 to 4 sentences (45–60 words).
Directs attention outward into physical space: describing bark textures, lighting angles, mossy edges, and bird calls.

3. Agent & State Orchestration: Mastra & LibSQL

The agent pipeline is orchestrated using Mastra (@mastra/core):

Coordinates the multi-tool workflow: predictSightings (TabPFN) ➔ generateFieldGuide (Gemma) ➔ synthesizeAudio (ElevenLabs).
Uses Mastra's official persistent storage adapter (@mastra/libsql) with an embedded LibSQL/SQLite database (file:trailwhisper.db), ensuring conversation state, memory, and trail history persist across server restarts.

4. Low-Latency Voice: ElevenLabs

Spoken scripts stream directly via the ElevenLabs Turbo v2.5 engine with the warm storyteller voice (JBFqnCBsd6RMkjVDRZzb - George).
Graceful client-side Web Speech API fallback if an API key is unconfigured, ensuring the screen-zero experience works out of the box.

5. Observability: Sentry Agent Tracing

Full distributed tracing using @sentry/node with OpenTelemetry instrumentation.
Every trail step creates an ai.agent.trail_step transaction with sub-spans for ai.tool.tabpfn.predict, ai.tool.gemma.generate, and ai.tool.elevenlabs.tts, capturing duration, token counts, and model metadata.

6. Cloud Deployment: Render Blueprint

A multi-service declarative render.yaml deploys the Python ML microservice, Node.js agent server, and React static PWA in a single click.

Why Does Open Innovation Matter?

Open innovation is what made TrailWhisper technically and philosophically possible:

Open-Weight Models Enable Specialized Physical Interfaces: Closed commercial APIs are predominantly optimized for chat interfaces, code generation, and markdown-heavy text boxes. With open-weight models like Google Gemma, developers have the freedom to steer the model towards non-traditional interfaces—in this case, audio-first, screen-zero cadence designed for the ear rather than the eye.
Tabular Foundation Models Democratize Domain AI: Prior Labs' TabPFN represents a major breakthrough: applying transformer-based foundation models to tabular data. Historically, predicting ecological events required training bespoke machine learning pipelines on massive labeled datasets. TabPFN's zero-shot capabilities allow hyper-localized predictions out of the box with zero fine-tuning overhead.
Extensibility & Privacy for the Outdoors: Outdoor tech needs to function everywhere, eventually transitioning to edge devices and offline trail kits. Open-source frameworks like Mastra paired with local storage like LibSQL mean that the orchestrator isn't locked behind a proprietary cloud walled garden.
Community Biodiversity Data: TrailWhisper relies on open science data from eBird and GBIF. Combining open datasets with open AI creates software that respects users' attention while fostering a deeper connection with the physical planet.

My Agent Session

TrailWhisper was architected, scaffolded, and debugged in pair-programming sessions with Google Antigravity IDE, orchestrating multi-service Docker builds, TabPFN ensemble fallbacks, OpenRouter Gemma toolchains, and Mastra LibSQL persistent storage integrations.

Prize Categories

I am entering TrailWhisper into the following partner prize categories:

Best Use of TabPFN: Used Prior Labs' TabPFN tabular foundation model inside a FastAPI microservice to perform real-time, zero-shot biodiversity sighting probability predictions on hiking trail features (GPS, elevation, canopy density, hour, temperature).
Best Use of Gemma: Powered by Google's open-weight Gemma (google/gemma-4-26b-a4b-it:free along with a fallback google/gemma-3-12b-it and google/gemma-3-4b-it via OpenRouter SDK), tailored with custom prompts to produce markdown-free, audio-first field notes directing hikers' senses into the wild.
Best Use of Mastra: Agent orchestration, tool pipeline dispatch (predictSightings, generateFieldGuide, synthesizeAudio), and persistent state storage using @mastra/core and @mastra/libsql.
Best Use of ElevenLabs: Low-latency voice streaming using ElevenLabs Turbo v2.5 to deliver hands-free audio narration directly to the hiker's headphones.
Best Use of Render: Complete multi-service production deployment managed declaratively with a render.yaml Blueprint covering the Python ML worker, Node.js agent orchestrator, and Vite static PWA.
Best Use of Sentry: Integrated @sentry/node agent tracing with OpenTelemetry spans tracking end-to-end execution, tool latencies, and model tokens across the multi-model pipeline.

RasoiVault: Preserving My Mom's Unwritten Recipes with Gemma 3 & Ancient Millets

DracFiendMG — Sun, 04 Oct 2026 20:52:22 +0000

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

What I Built

My mother has cooked incredible traditional meals for our family for decades, but her recipes have never existed on paper. Like millions of home cooks, her kitchen runs entirely on intuition and sensory memory: "fry until the aroma fills the room," "a gooseberry-sized ball of tamarind," and "a small fistful of roasted jeera."

Whenever anyone asks her for a recipe, it's impossible to follow or replicate accurately. On top of that, we've recently been focusing on everyday family wellness at home—trying to incorporate nutrient-dense ancient millets (like foxtail, barnyard, and little millet) and lighter cooking techniques without turning beloved comfort food into sterile "diet food" or ruining the sacred tadka. But every time we searched mainstream apps for "healthy Indian recipes," the suggestions were culturally clueless: swapping lentils for cold kale salads, stripping away mustard seeds, or replacing regional spices with bland Western substitutes.

I built RasoiVault for her.

RasoiVault is an open-source heritage culinary engine. It takes oral cooking fragments, unmeasured notes, and festival recipes, standardizes them into structured measurements, and adapts them for everyday wellness (substituting refined grains with ancient millets and optimizing cooking oils) while strictly preserving traditional tempering order, aroma cues, and mouthfeel. It also features a permanent Family Vault so her recipes are digitized, preserved, and searchable on her kitchen tablet.

Demo

Live Web Application: https://rasoivault-web.onrender.com
FastAPI Backend: https://rasoivault-api.onrender.com/api/health

Code

The entire codebase is open-source under the MIT License:

DracFiendMG / rasoivault

Family recipe ingestion and loved one's health profile dashboard

🍲 RasoiVault

An open-source heritage culinary engine built for family kitchen sovereignty, powered by Google Gemma 3 and Backboard.io.

Built for the Hacktoberfest Weekend Challenge: Build for a Friend.

💡 The Core Problem

Traditional home cooking runs on oral shorthand and sensory memories ("fry till aroma changes", "a gooseberry of tamarind"), making cherished recipes impossible to pass down or scale. Mainstream recipe apps provide culturally tone-deaf Western substitutes (swapping lentils for raw kale salads or removing essential tadkas).

RasoiVault bridges traditional intuition with everyday wellness:

Standardizes messy oral notes into exact metric recipe cards.
Intelligently swaps refined grains for ancient millets (foxtail, barnyard, kodo) while preserving tempering and texture.
Maintains persistent household culinary preferences using Backboard.io.
Archives every adapted dish in a sovereign Family Vault.

🛠️ Tech Stack

AI Core: Google Gemma 3 12B (google/gemma-3-12b-it) via OpenRouter
Memory & Orchestration: Backboard.io (Assistant &amp…

View on GitHub

Repository: https://github.com/DracFiendMG/rasoivault

Architecture:

/backend: FastAPI microservice enforcing Pydantic validation schemas, dynamic model configuration, and persistent Backboard memory sessions.
/frontend: Responsive React + Vite + Tailwind dashboard with side-by-side substitution diffs, wellness tagging, and the persistent Family Vault.

How I Built It

RasoiVault is built around open-weight intelligence and sovereign infrastructure:

Open-Weight Core (Google Gemma 3 12B):
We leverage Gemma 3 12B via OpenRouter as our culinary ethnographer and nutritional transformation brain. Open-weight Gemma was prompted with deep culinary domain constraints—treating traditional Indian tempering sequences (tadka / talimpu) and roasting methods as vital cultural assets while calculating proper grain hydration and starch ratios.
Persistent Context Layer (Backboard.io):
Family pantry preferences shouldn't need re-entering every morning. We integrated Backboard's persistent memory layer to create an active assistant thread. Backboard retains her culinary profile, preferred cold-pressed oils, and regional spice tolerances across conversations without prompt drift.
Backend & Architecture (FastAPI + Pydantic v2):
The backend strictly validates responses using Pydantic models to guarantee that every recipe returns structured substitutions, health impact breakdowns, and preserved heritage notes without hallucinated formatting.
Production Runtime (Render):
Both the FastAPI web service and the React static site are hosted on Render, communicating over an automated environment pipeline with zero downtime.

Why Does Open Innovation Matter?

When building tools for family heritage and daily life, proprietary closed APIs present real trade-offs:

Preserving Heritage Without Cultural Sanitization:
Most commercial chatbots are tuned toward Western dietary paradigms. When prompted with traditional regional dishes, they tend to strip out authentic spices or suggest irrelevant Western staples like quinoa and chia seeds. Open weights like Gemma allow us to instruct the model without corporate guardrail bias eroding authentic culinary traditions.
Data Sovereignty for Family Heirlooms:
Decades-old family recipes and personal dietary habits belong to the family, not corporate model-scraping pipelines. Open-source architectures let us keep our data sovereign and self-contained.
No Subscription Fatigue for Loved Ones:
Tools built for parents and relatives shouldn't stop working because an API credit limit was hit or an expired card locked them out. With open models, this engine can be hosted permanently on sovereign infrastructure or run locally on a home device using Ollama.

Prize Categories

Overall Challenge: Weekend Challenge: Build for a Friend
Best Use of Render: Full-stack deployment on Render (FastAPI web service + Vite static frontend) with automated environment variable linking.
Best Use of Gemma: Powered by Google's open-weight Gemma 3 12B for low-latency culinary ethnography and nutritional adaptation.
Best Use of Backboard: Integrated Backboard's Assistant and Thread management with memory persistence to maintain long-term household culinary profiles.