QuoteForge: Messy Job Notes Customer-Ready Quotes, Powered by a Local Open-Weight Model

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

What I Built

QuoteForge is a zero-dependency Node.js CLI that turns the notes a solo tradesperson scribbles on a jobsite into a clean, priced, customer-ready quote or invoice:

Labor 2.5 hrs @ $85
Disposal unit 1/2 HP: $189
Trip charge $45
Remove and haul away old faucet

…becomes a formatted quote with a polished scope of work, line items, tax, total, and a deposit schedule — in one command, on the laptop they already own, with no cloud account and no per-quote cost.

Who pays for it: one-person handyman, cleaning, and repair businesses. They don't usually lose jobs on price — they lose them on speed and polish. The quote that goes out tonight, looking professional, beats the handwritten estimate that goes out Thursday. Their current options are quoting SaaS at $20–$50/month that wants their entire client list in someone else's cloud, or a notes app and hand math. QuoteForge is priced like a tool instead of a subscription — possible only because the AI costs $0 to run (see below).

Demo

QuoteForge running on the bundled example (examples/job-notes.txt), offline engine:

----------------------------------------------------------------
Payne Relief Handyman Services
QUOTE / ESTIMATE
----------------------------------------------------------------
Prepared for: Dana W. — kitchen faucet + disposal
Date: 2026-10-18
Job: Kitchen faucet replacement + disposal swap

SCOPE OF WORK
  - Remove and haul away old faucet and disposal unit
  - Install customer-supplied faucet, test for leaks

LINE ITEMS
  Labor  (2.5 hrs @ $85.00)  $212.50
  Disposal unit 1/2 HP  $189.00
  Supply lines and fittings  $36.00
  Trip charge  $45.00

Subtotal:        $482.50
Tax (9.5%):        $45.84
TOTAL:           $528.34
Deposit to book: $158.50
Balance on completion: $369.84

This quote is valid for 30 days. Work is scheduled on deposit receipt.
Prepared with QuoteForge · engine: deterministic parser (offline)
----------------------------------------------------------------

With a local model running (ollama pull gemma3 && ollama serve), the same command produces the same numbers, but the model does the extraction and rewrites the scope in customer language — "Remove and haul away old faucet" becomes "We will remove your old faucet and disposal and haul them away." Every quote's footer names the engine that produced it, so there's never a silent quality change. (Honesty note: QuoteForge was developed in an environment without a GPU, so the model path was exercised end-to-end against a local stub implementing Ollama's HTTP API with canned responses, and the client is unit-tested against stubbed responses — the code path is identical with a real model; npm test and the run above are fully real.)

Code

Repo: https://github.com/payne-muse/quoteforge — the code is complete, tested (24/24), and committed; the repo flips public tonight as the account email verification clears.

The project is four small modules with zero dependencies: src/parse.js (deterministic note parser), src/pricing.js (cent-exact money math), src/ollama.js (local-model client), src/render.js + src/cli.js (document + CLI). 24 tests, all passing, run with npm test (Node's built-in test runner — still zero dependencies).

How I Built It

QuoteForge is built around local inference with an open-weight model — Gemma 3 by default — served by Ollama:

1. The CLI reads job notes from a file or stdin, plus business defaults from flags or a quoteforge.config.json.
2. If a local Ollama server answers, the model gets two jobs: extract structured line items from the raw notes as JSON, and polish the scope lines into customer-friendly language.
3. Deterministic code — never the model — does the money: subtotals, tax, deposits, all rounded half-up to the cent at every step so the printed lines always add to the printed total. Financial math is not something I outsource to an LLM, even a local one.
4. If Ollama isn't there (no model pulled yet, working in a driveway with no signal), a built-in deterministic parser reads the common note shapes (Labor 2.5 hrs @ $85, Faucet: $189, 4 @ $6 outlet covers, Materials: section headers) and produces the same document. Every model call fails soft to this path.

The model is swappable with --model (llama3.2, qwen2.5, anything Ollama serves) and the host respects OLLAMA_HOST, because the point of open weights is that no vendor decision can break the tool.

Why Does Open Innovation Matter?

Three concrete reasons, not ideology:

• Privacy is the product. Job notes contain client names, addresses, and what's broken inside their homes. A closed API makes "paste your customers into our cloud" the default architecture. Local Gemma means that data never leaves the tradesperson's laptop — for a one-person business, that's the difference between a tool and a liability.
• The business model only works at $0 marginal cost. A side-hustle tool can sell for the price of a nice wrench because inference is free. Per-call API pricing would force SaaS pricing, and SaaS pricing is exactly what this user can't justify. Open weights are what make the business viable, not just the code.
• No lock-in at the worst moment. If a provider sunsets a model or changes pricing, a solo operator's quoting stops. With open weights and a model flag, the worst case is ollama pull something else and keep working.

My Agent Session

QuoteForge was designed and built in a single session with an AI coding assistant on October 18, 2026 — spec, implementation, test suite, and this write-up — which is itself the side-hustle pattern the tool is for: one operator, open tools, no team, no budget. (No DevRelay capture for this session.)

Prize Categories

• Best Use of Gemma — Gemma 3 is QuoteForge's default model and the core of the product: it performs the line-item extraction and scope polishing via local Ollama inference, and the project's privacy and unit-economics story depends specifically on running an open-weight model like Gemma on the user's own machine.