This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.
What I Built
LedgerZero AI turns a folder of receipts into a ledger a freelancer can actually review. Its open-weight extraction engine runs through Ollama on the user's own machine, with a dashboard for checking records, spotting duplicates, and exporting the result.
A receipt is a tiny document with a surprisingly long afterlife. Someone has to identify the merchant, find the real total, choose a category, check whether it has already been entered, and hand the result to a bookkeeper. Repeat that across software subscriptions, equipment purchases, coworking bills, and client meetings, and a small administrative job becomes a recurring distraction.
LedgerZero brings those steps into one workflow:
- Extract the vendor, date, invoice reference, currency, amounts, and line items.
- Suggest expense categories with Schedule C references.
- Flag duplicate invoice numbers and matching vendor/date/amount combinations.
- Surface missing information and unusual transactions for review.
- Search, filter, and edit the ledger before exporting CSV or a printable audit pack.
The intended customer is a freelancer or independent contractor who wants help organizing business expenses while keeping control of the documents.
Why someone would pay
The product hypothesis is simple: charge for a convenient, supported desktop experience around an open core.
The repository proposes a free MIT community edition, a $49 one-time Pro desktop license, and a $149 agency edition. Those are proposed packages, not evidence of sales or shipped paid editions. Multi-client workflows and support would need further development and validation.
Local inference makes a one-time purchase more plausible because each additional receipt does not incur a metered cloud-model API charge. Hardware, electricity, maintenance, and support still have costs.
Demo
For a quick walkthrough:
- Open the dashboard and choose Load Sample Invoices.
- Inspect the extracted records and suggested categories.
- Open the IRS Schedule C Form view.
- Try the CSV export or Audit Pack.
The hosted demo and local installation have different privacy boundaries. The Vercel demo uses server API endpoints and currently reports the heuristic fallback engine. It is a preview of the workflow; it does not run Gemma inside your browser. Use synthetic sample documents there. To keep document processing on your own computer, run both the app server and Ollama locally.
Code
Source code on GitHub — released under the MIT license.
⚡ LedgerZero AI
-brightgreen){kind=icon}
100% Local, Air-Gapped AI Invoice, Receipt & Tax Sorter for Freelancers
Built with open-weight models at its core (Google Gemma 2, Meta Llama 3.2, Qwen 2.5). Client invoices, contracts, and financial receipts never leave your laptop.
📖 Table of Contents
- ✨ Why LedgerZero AI?
- 🎯 The Problem It Solves
- 💡 Why Open Innovation Matters Here
- 🛠️ Tech Stack & Architecture
- 🚀 Quickstart in 30 Seconds
- 💻 Command Line Interface (CLI)
- 🌐 Web UI Dashboard
- 📊 Tax Categorization & Schedule C Support
- 💼 Side Hustle Business Model & Pricing
- 🧪 Running Tests
- 🤝 Contributing & License
✨ Why LedgerZero AI?
Freelancers, independent software contractors, and boutique agencies handle sensitive financial documents daily: client invoices, subcontractor agreements, cloud hosting bills, and hardware receipts.
Existing tools fail freelancers:
- Cloud Accounting SaaS (QuickBooks, Expensify): Charge $20–$35/month recurring subscriptions and leak client billing telemetry to third-party cloud servers.
- Cloud AI APIs (ChatGPT,…
To try the local open-weight path:
git clone https://github.com/Gautam5514/hack_week3.git
cd hack_week3
npm install
# With Ollama installed:
ollama pull gemma2:2b
ollama serve
If Ollama is already running, skip the last command. In another terminal:
npm start
# Open http://localhost:3030
Choose Gemma in the dashboard. The repository also includes Node.js and Python command-line tools.
How I Built It
The stack is deliberately small: Node.js, Express, vanilla JavaScript and CSS, a JSON document store, and Ollama for local inference.
The processing flow is:
Document text
→ structured extraction with Ollama / Gemma
→ field normalization
→ rule-based expense categorization
→ duplicate and anomaly checks
→ editable ledger
→ CSV / summary / printable audit pack
Gemma does the extraction
The default local model is Gemma 2 (gemma2:2b). The extractor checks the local Ollama service, builds a prompt containing the document text and expected fields, then calls /api/generate with JSON output enabled.
The expected structure includes vendor, date, currency, subtotal, tax, total, payment method, client name, and line items. After generation, the code normalizes numeric values, dates, currency codes, and item arrays before passing the document onward.
The connector also supports other installed models, including Llama and Qwen. That is a configurable integration, not a claim that every model has been benchmarked equally.
Rules handle the repeatable work
Category mapping and duplicate checks live outside the model. Keeping those operations explicit makes the result easier to inspect: a user can see the assigned category and review warnings instead of relying on a paragraph of generated financial advice.
If Ollama is unavailable, times out, or returns unusable output, a deterministic parser supplies a fallback. That lets users explore the workflow before downloading a model, while preserving a separate open-weight extraction path for local use.
What still needs work
This is a working prototype with an editable review step, not unattended bookkeeping.
A verification run against the submitted source passed the categorizer tests but found failures in the extraction, multi-currency, and number-formatting suites. Those cases need improvement; I am not claiming production-level accuracy or a fully passing test suite. Image extraction also depends on choosing a suitable vision-capable model, and the bundled PDF parser has limitations.
The tax views are simplified organizational estimates. Suggested categories, deduction percentages, and the dashboard's assumed 25% tax rate need review against the user's actual circumstances; an audit score is an application heuristic, not a certification.
Why Does Open Innovation Matter?
For this product, where inference runs is part of the value.
With downloadable open weights and a local runtime, a freelancer can process documents on a machine they control after the software and model are installed. Document extraction does not require sending the contents to a third-party model API.
That architecture also gives the project room to evolve:
- Model choice: use a smaller model for limited hardware or test another model against difficult document formats.
- Inspectability: the prompts, normalization code, category rules, and duplicate logic are available in the repository.
- Portable deployment: users can run their own copy instead of depending on one hosted application.
- Different economics: local processing avoids per-request model API billing, making a supported one-time license worth exploring.
The open pieces are central to the intended product: they make user-controlled inference possible. The heuristic fallback is useful for onboarding, but it does not replace the model's role in extracting varied document text.
Prize Categories
- Overall challenge prize
- Best Use of Gemma — Gemma 2 is the default model in the local Ollama extraction connector. The hosted demo uses the fallback; judges can follow the local setup above to exercise the Gemma path.
Built by Gautam Pandit. The next milestone is improving extraction reliability and testing the workflow with freelancers before treating the proposed pricing as validated demand.
AI assistance was used to prepare this submission and its cover artwork.
Top comments (0)