Manage Your Tasks: a local Gemma assistant that keeps freelance designers out of scope creep

Tony — Mon, 19 Oct 2026 06:36:14 +0000

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

What I Built

A client asks for "one small extra screen" in a call. Two days later they send a reference image in WhatsApp. A week after that, an email casually says "so we're still on for Friday?" Each message looks harmless. Together they are new scope and a new deadline that nobody agreed to.

For an independent designer this is unpaid work hiding in plain sight. The hard part isn't writing tasks down. It's reconstructing what was actually asked, where, and whether it was ever approved.

Manage Your Tasks is a bilingual (English / 中文), local-first workspace for exactly that. You drop in client feedback. Google's open-weight Gemma 3 1B, running on your own machine through Ollama, flags likely requests and explicit dates, and every suggestion stays pinned to the original sentence it came from. You decide:

Confirmed request → becomes a task, with a suggested due date pre-filled.
Scope or delivery change → goes through a separate approval path, recorded against the project baseline.

The AI never creates a task or moves a deadline on its own. It points at the evidence. A human signs off.

Who Would Pay For It

Customer: freelance designers and 2–5 person studios juggling several clients, who lose billable hours to "wait, when did they ask for that?"

Business model: free core + one-time Pro purchase. No subscription.

Free: projects, tasks, timeline, source-file storage, rule-based request & date detection.

Pro (one-time purchase): everything in Free, plus local Gemma semantic understanding (indirect asks, mixed EN/中文), scope-change approval records & baseline history, and add-ons (more import sources, client export/reports).

This pricing only works because the model is open and local. A hosted LLM bills per token, forever, so a feature that reads every client message has to become a subscription. With Gemma running on the user's laptop, our marginal inference cost is $0, so we can sell it once and let it keep working, offline, for as long as the user wants. Freelancers are subscription-fatigued. "Pay once, own it" is a selling point.

To be honest about where we are: this is a business hypothesis. We haven't validated pricing or landed a paying customer yet. The project came from one of our team's own day-to-day coordination problem as a designer, and getting it into other freelancers' hands is our next step.

Demo

Because the app runs entirely on your machine, the video is the public demo. It shows the local model status, a real Gemma response with its source evidence, a suggested date filled into the task form, and the separate review a formal scope change requires.

Code

Run it locally: start START_LOCAL_AI.cmd, which launches Ollama with gemma3:1b plus the local parsing endpoints, then open the app.

Team: TonySama-BoiledCabbage (@tony_0bff21a994dcd2b693b3) and DD998855 (@yundiguo).

Built during the challenge window in two parallel workstreams. One of us designed and built the ScopeCheck V2 prototype. The other wired its existing HTML/CSS into the Frame local project store, parser and domain rules through a small adapter. We don't claim every underlying Frame service was written for this entry. The candidate tag is frozen, and later fixes live in the PR.

How I Built It

From real pain to prototype. Project info arrived through documents, Outlook, WhatsApp, calls and meetings. Requests got lost or confused with approved changes. Prototype iterations V1 → V4 refined how requests, dates and review status fit together. We then connected it to local storage and domain rules without changing the page structure or interaction style.

Gemma's job is deliberately narrow. A 1B model can misread things, so we don't ask it to "manage the project". The pipeline is:

Split source material into segments.
Gemma 3 1B (local, via Ollama) classifies each segment as a possible request or not. When it sees a date, it must return the exact phrase from the text.
A deterministic resolver checks that the phrase really exists in the source, then turns it into a calendar date relative to the message date. It handles full dates and limited relative forms like "within three days" / "三天内". Anything ambiguous stays blank for manual entry.
Schema checks reject unsupported model output.
A person reviews. Only then does a task exist, and scope or deadline changes still need their own approval.

Everything stays on the machine. Project metadata lives in browser localStorage, original files in IndexedDB, and parsing and inference run on local HTTP endpoints. There is no cloud database. If Ollama isn't running, the app says so. The rule-based mode is a separately labelled option, never a silent fallback that pretends to be AI.

Known limits, stated plainly:

Indirect requests can still be missed.
Date and relative-date coverage is intentionally limited.
We haven't measured AI precision or recall on a representative dataset. Our automated tests cover app behavior, not model accuracy.
Creating a task by clicking or dragging on an empty timeline is still unreliable, and we don't claim it's done.

Why Does Open Innovation Matter?

Privacy is the product. Client feedback contains unreleased designs, pricing and commercially sensitive decisions. Many freelancers are under NDA. Sending that to a hosted API is a real risk. With an open-weight model running locally, the material never leaves the designer's laptop, and the app even works offline on a train.

Open is also what makes the business work. Zero per-request inference cost is why we can offer a one-time Pro purchase instead of another monthly subscription. A closed API would force recurring pricing and lock us into someone else's price changes.

And it's inspectable. Gemma's role, the prompts, the resolver and the checks are all in the repo. When the request selector gets something wrong, anyone can reproduce the failure, swap in a different open model, or fine-tune for design-studio language, all behind the same evidence-and-approval boundary.

Prize Categories

Best Use of Gemma: Gemma 3 1B runs locally through Ollama as the semantic layer that classifies client feedback and extracts date phrases, constrained by deterministic validation and human review.

DEV Community: Tony