DEV Community: Jay Dosi

InvoiceFlow: local-first invoice & receipt sorter for freelancers

Jay Dosi — Tue, 13 Oct 2026 19:50:15 +0000

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

What I Built

InvoiceFlow turns a folder of receipts, invoices, and PDFs into a clean
CSV your accountant can actually use — 100% locally, with zero cloud API
costs, zero token bills, and zero data leaving your laptop.

It is built for the freelancer who keeps a shoebox of receipts, the Etsy
seller who loses track of material spend, and the consultant whose
accountant emails every March asking for "the CSVs."

What it does, end-to-end

Drop files — PDFs (text layer + OCR fallback), images (local Tesseract OCR), or plain text.
Parse — hand-tuned regexes extract vendor, date, invoice number, subtotal, tax, total, currency, and line items in ~50 ms/receipt.
Classify — a local TF-IDF + LinearSVC classifier (trained on a 400+ example seed corpus that ships in the repo) assigns a category (Software, Travel, Supplies, etc.). No model download, no tokens, no rate limits.
Deduplicate — fuzzy vendor + amount + month matching catches double-scanned receipts before they inflate your totals.
Export — CSV (QuickBooks/Gusto/Xero column order via config.yaml), JSON, JSONL, or a self-contained printable HTML report.
Answer questions — optional local LLM via Ollama on 127.0.0.1 lets you ask "how much did I spend on software in September?" and get an answer with an anti-hallucination check against the actual ledger numbers.

Why someone would pay for this

$20–$50/month saved vs. QuickBooks Online / Expensify / Dext / Shoeboxed SaaS tiers — no subscription ever.
Privacy by architecture — your vendor list, amounts, and client names never hit a server you don't control. A cloud API cannot make that claim; it is the server.
Works on an airplane — offline-first means it runs on a laptop in economy with no Wi-Fi.
Extensible without code — add your own categories, tax rules, and vendor synonyms in config.yaml.

Demo

git clone https://github.com/Jay-Dosi/DEV-Challenge-3
cd invoice-flow
pip install -r requirements.txt
python -m invoice_flow.cli parse ./examples/receipts --out ./parsed
python -m invoice_flow.cli report --month 2026-09 --format html
# open ./parsed/report_2026-09.html

Or launch the dashboard:

python -m invoice_flow.cli serve
# open http://127.0.0.1:8000

Code

Repo: github.com/Jay-Dosi/DEV-Challenge-3

Key modules:

invoice_flow/parser.py — regex-first parser with EU/US money handling
invoice_flow/classifier.py — local TF-IDF + LinearSVC, ships trained
invoice_flow/offline_guard.py — OS-socket-layer proof of no outbound calls
invoice_flow/llm.py — optional local-LLM features with hallucination guard
invoice_flow/web.py — FastAPI dashboard, zero external dependencies

How I Built It

Open-source AI used:

scikit-learn — TF-IDF vectorizer + LinearSVC classifier. The model is fit from a bundled seed corpus (data/seed_corpus.py) in ~200 ms on a laptop CPU, pickled to models/expenses.pkl, and reused. No download, no API, no tokens.
Tesseract OCR (via pytesseract) — local image-to-text for scanned receipts. Pure native binary, no cloud vision API.
Ollama (optional) — loopback HTTP to a local open-weight model (llama3.2:3b by default) for the two features where a small LLM genuinely beats regex: natural-language ledger questions and one-sentence expense descriptions. The loopback guard enforces 127.0.0.1 only.

Why open-weight / open-source matters here:

Cost structure — a cloud API at $0.002/request would cost a freelancer with 2,000 receipts/year ~$4/month just in token calls. The local classifier is free forever.
Data never leaves — a SaaS receipt parser sends your banking, vendor, and client data to their servers. InvoiceFlow's Offline Guard patches socket.socket.connect at the OS layer, counts every attempt, and refuses anything that isn't loopback. You get a verifiable line at the end of every run: Verified fully on-device: 0 network call(s) blocked.
No lock-in — the model, the parser, the database (SQLite), and the config are all plain files you can copy, audit, or fork. If the project stops, your data and your tool still work.
Determinism for taxes — an LLM summarizer is non-deterministic and hallucinates totals. InvoiceFlow's classifier is deterministic (same input → same category) and the parser never invents numbers. The optional LLM answers are validated against the actual parsed totals and fall back to the deterministic report if any figure doesn't match.

My First User

A freelance designer friend who files Schedule C every year. They ran it on
their 2025 receipts folder (347 files):

"Took 4 minutes. Found 12 duplicates I would have double-counted. The
HTML report printed to PDF and my accountant didn't ask a single follow-up
question. I cancelled my $28/mo Expensify subscription."

They asked for: recurring vendor auto-categorization (added via the label
store), and CSV column reordering (already in config.yaml).

Prize Categories

Open Source AI — built entirely on scikit-learn, Tesseract, and optionally Ollama; no closed APIs.
Privacy / Local-First — Offline Guard enforces and proves zero outbound traffic.
Side Hustle / Small Business — targets freelancers, Etsy sellers, consultants; saves real subscription money.
Best Use of Open-Source Models — the TF-IDF classifier and optional Ollama hook demonstrate practical local inference.

TrailEar: identify birds offline, with your phone in your pocket — plainest, most descriptive

Jay Dosi — Sat, 10 Oct 2026 14:24:21 +0000

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

What I Built

TrailEar is an offline, screen-last birding companion. It listens to the sounds of a walk, identifies bird calls entirely on-device with no internet, and at the end writes a short field journal using a local open-weight LLM. You tap "Start Walk," put the phone in your pocket, and just listen — a soft chime tells you when a new species is heard, so you never need to look. The screen only comes back out at the end.

It's for beginner birders who want to know "what was that sound?" without staring at a phone, hikers and runners in low- or no-signal areas, and privacy-minded people who don't want their recordings and location living on someone else's server.

The piece that makes it genuinely a get-off-the-screen, stay-private tool is the Offline Guard: while a walk is running, TrailEar hard-blocks every non-loopback network socket at the OS layer and counts any attempt. The local LLM is still reachable over 127.0.0.1; everything else is refused. Each walk ends with a tamper-evident proof line like:
Verified fully on-device: 0 network call(s) blocked. Offline proof: a1b2c3d4e5f6a7b8.

Demo

Jay-Dosi / DEV-Challenge-2

🐦 TrailEar

An offline, screen-last birding companion powered by open-source AI.

Put your phone away, go outside, and let open-source AI keep the field notes.

TrailEar listens to the sounds of a walk, identifies bird calls entirely on-device with no internet, and at the end writes a short field journal using a local open-weight language model. The screen stays in your pocket during the walk — it's the shortest part of the experience.

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

Why this is different

Most nature apps need a signal (trails rarely have one), keep you staring at a screen, and ship your recordings and location to a server you don't control TrailEar inverts all three — and proves it:

🔒 Offline Guard (our signature feature). During a walk, TrailEar hard-blocks every non-loopback network socket at the OS layer and…

View on GitHub

Code

Jay-Dosi / DEV-Challenge-2

🐦 TrailEar

An offline, screen-last birding companion powered by open-source AI.

Put your phone away, go outside, and let open-source AI keep the field notes.

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

Why this is different

🔒 Offline Guard (our signature feature). During a walk, TrailEar hard-blocks every non-loopback network socket at the OS layer and…

View on GitHub

How I Built It

Bird ID: BirdNET via birdnetlib, running locally on CPU over 3-second audio chunks. If it isn't installed, TrailEar falls back to a clearly-labelled simulated detector so the whole pipeline runs anywhere with zero downloads.
Journal: A local open-weight model (Llama 3.2 1B) served by Ollama, reached only over loopback. If no LLM is running, a deterministic offline template writer produces the journal instead — so a journal always gets written, fully offline.
Guardrail: The model only ever receives the detection list. After generation I post-validate the text and strip any bird it names that wasn't actually detected, with a visible correction note — so it can't hallucinate species.
Offline Guard: A context manager monkeypatches the socket layer for the duration of the walk, blocking and counting non-loopback connections, then emits a hashed proof.
Storage: SQLite, everything local. Raw audio isn't stored by default — only detections.
Config: The bird model, the LLM, thresholds, location filter, and even the journal's tone are all swappable by editing config.yaml — no code changes.

Mic → Chunker → BirdNET (local) → Detections DB → Local LLM → Walk Journal (.md/.html)
                      ▲                                   (loopback only)
              lat/lon + week filter

(whole walk wrapped in the Offline Guard — all non-loopback traffic blocked)

Why Does Open Innovation Matter?

It works where closed APIs can't: A cloud service can't identify a bird in a canyon with no signal. TrailEar runs with the network physically blocked.
Privacy by construction: Audio and location never leave the device, and the Offline Guard proves it per walk — a closed API is the thing being blocked.
No cost, no API key, no account.
Control & longevity: I can swap the bird model or the LLM and change the journal's tone with a one-line config edit. No vendor can deprecate it or change the terms underneath me.

Recipe Keeper: Turning Nani's Voice Memos into a 100% Local AI Cookbook

Jay Dosi — Fri, 02 Oct 2026 17:15:56 +0000

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

What I Built

Recipe Keeper is an application that turns rambling voice memos from home cooks into a clean, searchable, and printable family cookbook.

I built this for my grandmother (Nani). Like many experienced home cooks, her recipes live entirely in her head. She cooks by feel, describing measurements as "a fistful of jeera," "enough water to cover plus two fingers," or "a good dollop of ghee." Asking her to type out recipes is a non-starter, and generic recipe apps demand precise metrics she doesn't use.

This app solves that by letting her simply talk into her phone while cooking. We upload the audio, and the app transcribes and extracts the recipe while preserving her exact phrasing, highlighting estimated quantities, and saving all her tips and stories.

Demo

Since this is a 100% offline, privacy-first desktop application designed to protect family data, there is no hosted live demo. You can test and demo it locally on your own machine by checking out the GitHub repository below!

Code

Jay-Dosi / DEV-Challenge-1

Recipe Keeper

Turn a loved one's rambling voice memos about their cooking into a clean, searchable, printable family recipe book, entirely on a laptop, with no internet and no cloud.

Built for Nani, who cooks from memory.

Features

100% Local: Uses open-weight models (faster-whisper, Ollama). No cloud APIs.
Fidelity First: Keeps the cook's original phrasing (e.g. "a fistful of jeera"). Approximations are flagged.
Exportable: Print a beautiful PDF cookbook, or export to Markdown/ZIP.

Quick Start

Install Ollama and Python 3.10+.
Run make setup (or bash scripts/setup.sh). This installs dependencies and pulls the default LLM model (qwen2.5:7b).
Run make run to start the server.
Visit http://127.0.0.1:8000.

Hardware & Model Swapping

16GB+ RAM: The default qwen2.5:7b is excellent.
8GB RAM: Change model: "qwen2.5:7b" to model: "llama3.2:3b" in config.yaml.
Whisper defaults to small.

Personalizing

Edit config.yaml to change the…

View on GitHub

How I Built It

The stack is built entirely around 100% open-source, locally run AI:

Speech-to-Text: faster-whisper (running the open-weight Whisper small model) to handle multilingual offline transcription (e.g., mixing English and Hindi).
LLM Extraction: Ollama serving open-weight models (like qwen2.5:7b or llama3.2:3b for lower-RAM laptops).
Backend/Frontend: Python 3.10+, FastAPI, SQLite, and vanilla HTML/CSS/JS (no build steps).

The core of the project relies on heavily engineered prompts that enforce strict "fidelity rules" on the LLM. The agent is instructed to never invent ingredients, to map vague quantities to an approx_metric flagged strictly as an is_estimate, and to pull out exact quotes for an original_phrase field.

Why Does Open Innovation Matter?

Family voices, stories, and recipes are incredibly personal and intimate. A cloud-based solution would require uploading my grandmother's private voice memos to third-party servers and paying per minute for transcription/extraction.

Open-weight models make this project possible because they guarantee absolute privacy. The app runs completely offline, binding only to 127.0.0.1. It costs nothing to run, and because the weights are open, the app won't suddenly break when an API gets deprecated. It ensures this cookbook tool will work forever on a standard laptop.

My Agent Session

Prize Categories

Open-Source Innovation
Best Use of AI / Local Models

HacktoberFest 2026

Jay Dosi — Fri, 02 Oct 2026 16:26:20 +0000

Participating in HacktoberFest 2026, already a open source contributor into multiple orgs.