CrumbDesk: AI Can Read the Cake Order. It Doesn’t Get to Run the Bakery

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

What I Built

A customer orders a 500g cake. The baker accepts it, buys ingredients, and starts preparing it.

Then a message arrives: “Can we make that 1kg instead?”

An AI model can understand that message. The difficult question is what happens next.

A larger cake can affect ingredient quantities, preparation time, packaging, price, and other orders already promised. Quietly changing 500g to 1kg would erase the decision that matters.

That is why I built CrumbDesk: a local-first AI order-management tool for independent home bakers and small cottage bakeries.

CrumbDesk turns manually copied customer messages into structured, reviewable order details using Gemma 3 4B through local Ollama inference. It helps surface missing details, draft clarification replies, record change proposals, and preserve the baker’s authority over accepted orders.

The principle behind the project is simple:

Let the model interpret the message. Let deterministic code enforce the rules. Let the baker make the decision.

Home bakers often manage orders through WhatsApp, Instagram, SMS, and calls. A single message can mix flavour, quantity, weight, dietary preference, pickup time, payment statements, and special notes. Once more chats arrive, those details become difficult to find and easy to overlook.

CrumbDesk gives those details one dedicated workspace: orders needing review, confirmed orders, upcoming fulfilments, filters, local model status, and CSV export.

CrumbDesk’s dashboard gives the baker one local view of order status, schedules, and payment context.

The workflow starts with a deliberate boundary: the baker copies a customer message into CrumbDesk. The app does not automatically read WhatsApp or Instagram messages.

The baker pastes an informal customer message and requests structured extraction with local Gemma 3 4B.

Gemma helps identify the product, quantity, weight, date, time, dietary preference, fulfilment method, notes, and payment context. But its output is only a draft, never an accepted order.

For example, “Sunday” is not silently converted into a specific calendar date without enough information. “I paid via GPay” is recorded as a customer-reported claim, not proof that money cleared in a bank account. And one cake remains separate from one kilogram.

The review panel keeps extracted information editable and flags details that need baker clarification before confirmation.

If information is missing, CrumbDesk can generate an editable reply draft for the baker to copy into their chat app. This is intentionally deterministic: it uses known missing details instead of asking the model to make another unnecessary decision.

CrumbDesk prepares a polite, editable clarification reply without sending a message automatically.

Demo

The demo shows the complete flow: importing a customer message, reviewing the extracted order, confirming it, recording a later change request, and preserving the result in the order history.

Watch the CrumbDesk demo on YouTube

Code

The project is available here:

CrumbDesk on GitHub

CrumbDesk is built with Next.js and TypeScript, local Ollama inference, validation and order-management logic, browser storage, and automated tests.

How I Built It

The AI path is intentionally narrow.

A baker pastes a message into CrumbDesk, and a Next.js route sends it to Gemma 3 4B running locally through Ollama. The model returns structured order data, which is then parsed, normalized, and reviewed before the baker confirms anything.

The important work happens around the model output.

CrumbDesk validates the distinction between quantity and weight, preserves unresolved date wording rather than guessing, and prevents payment claims from becoming payment verification. A model can extract plausible information, but it cannot know whether a baker is available, whether “Sunday” means the intended date, or whether a payment has actually cleared.

Once an order is confirmed, its important details are protected. A customer change becomes a proposal, not a silent edit. The baker sees a field-level comparison and chooses whether to approve or reject it.

The requested change from 500g to 1kg is visible as a proposal, while the accepted order remains protected.

The change policy is enforced by deterministic application logic. CrumbDesk calculates a deadline only when a fulfilment date and time are resolved. Once preparation starts, ordinary changes are locked. Older proposals cannot overwrite newer accepted information.

A late or in-preparation request can still be considered, but it must be treated as an exception. The baker must deliberately approve it, provide a meaningful reason, and acknowledge the production risk.

Late changes require deliberate exception approval, a written reason, and clear acknowledgement of the production risk.

Every important action is recorded locally: creation, confirmation, change requests, decisions, and field differences. The history is not a cryptographic ledger; it is an operational record that helps the baker understand what changed and why. Orders can also be exported as CSV for kitchen preparation or record-keeping.

The order history preserves the journey from creation to confirmation and change request.

Finally, the baker can configure the change cutoff. The policy is visible rather than buried inside a prompt, making the workflow inspectable and adaptable.

The policy screen makes change cutoffs, preparation locks, local inference status, and baker approval rules visible.

Why Does Open Innovation Matter?

CrumbDesk uses Gemma 3 4B through Ollama because local, open-weight inference is a practical fit for this workflow.

Customer messages can contain personal details, delivery information, dietary requirements, and payment claims. A local inference path means CrumbDesk does not need a hosted AI API for extraction. It also keeps the prompt, validation rules, and post-processing logic inspectable and adaptable.

Open-weight models give builders room to specialize a workflow without committing the whole product to one remote AI vendor. The model can be replaced or adjusted later, while the deterministic safeguards remain visible and testable.

Local inference has trade-offs. It requires compatible hardware, Ollama installation, and a running local model. Performance depends on the machine. Browser storage still needs backups. Local inference also does not guarantee perfect extraction, absolute privacy, or universal offline operation.

The point is not that local AI is always better. It is that, for this use case, the model can assist without becoming an unaccountable decision-maker.

Who Would Pay for This?

CrumbDesk is intended for independent home bakers and small cottage bakeries handling custom orders through informal chats.

Today, a baker may rely on chat search, notebooks, spreadsheets, or tools designed for much larger businesses. A focused product could be valuable if it reduces missed details, makes accepted commitments easier to inspect, and prevents confusing last-minute changes.

A modest subscription, paid local setup, or customization service could be a possible business model. That is a hypothesis, not a proven outcome.

CrumbDesk does not yet have verified paying customers, revenue, or a completed commercial bakery pilot. Representative test messages and community conversations are useful design signals, but they do not establish commercial demand.

The project currently has 67 passing automated Vitest tests, plus successful TypeScript and production-build checks. The repository also contains seven live Gemma/Ollama integration cases, but they were not successfully run in the latest environment because no local app was reachable.

CrumbDesk is an honest prototype with a specific idea: AI can make a messy order easier to understand, but the person responsible for the kitchen should remain responsible for the decision.

AI can read the cake order. It does not get to run the bakery.

Prize Categories

Best Use of Gemma

CrumbDesk uses Gemma 3 4B through local Ollama inference to turn informal customer messages into structured order details. By combining the model with deterministic validation, order-change policies, and human review, the project demonstrates how open-weight AI can support a real-world workflow without taking control away from the person running the business.