DEV Community: Atanu Barua

ReceiptVault: The 100% Local, Air-Gapped Bookkeeping & Tax Extractor for Freelancers

Atanu Barua — Mon, 19 Oct 2026 05:35:06 +0000

What I Built

Freelancers, contractors, and solo consultants share a universal headache: the shoebox of doom.

Every tax season or quarter-end, hundreds of PDF invoices, crumpled paper receipts, client reimbursements, and bank transaction screenshots sit unsorted in downloads folders. While cloud-based accounting platforms exist, many freelancers face two critical blockers:

Privacy & NDA constraints: Many client invoices contain proprietary rates, NDA-protected client names, and confidential project scopes. Uploading these documents to third-party cloud AI APIs is often a direct breach of contract.
Cost & Subscription Fatigue: Heavy per-page cloud OCR and vision API fees turn a micro-SaaS or side-hustle utility into a high-overhead money pit.

ReceiptVault is an offline, privacy-first desktop utility that watches a local folder, extracts line items, classifies tax deductible expense categories (Schedule C compliant), identifies client billable items, and reconciles everything into a clean CSV/JSON/SQLite ledger—running 100% locally on consumer hardware without an internet connection.

Who Would Pay For It?
Freelancers & Solopreneurs: Willing to pay a one-time license ($39) or low recurring fee ($9/mo) to save 10+ hours of tedious manual bookkeeping every tax quarter.
Freelance Bookkeepers & Solo CPAs: Professionals managing 10–20 small business clients who need fast batch extraction without violating client confidentiality or incurring thousands of dollars in cloud API tokens.
Demo

(Watch the 60-second walkthrough below showing batch OCR extraction and auto-categorization running completely in Airplane Mode!)

ReceiptVault Demo Video
(Demo video / Walkthrough link placeholder: receiptvault.local/demo
)

Code

Github link: Hacktoberfest
How I Built It

ReceiptVault is designed around a fully open-source, local-first architecture:

[ Local Drop Folder ]
│ (PDFs, PNGs, JPEGs)
▼
Local Ingestion & Pre-processing
│
▼
[ Open-Weight Vision Model ] ────► Llama 3.2-Vision (11B-Instruct / 3B-Vision)
│ Served via Ollama / llama.cpp
▼
[ Constrained JSON Decoding ] ───► Outlines / Instructor (Pydantic schema validation)
│
▼
[ Reasoning & Category Agent ] ──► Qwen 2.5-Coder (7B) for Schedule C tax line reconciliation
│
▼
[ Encrypted Local Ledger ] ──────► Local SQLite database + CSV export

Local Vision & Multimodal Extraction

Instead of relying on proprietary APIs, ReceiptVault uses Llama 3.2 Vision (11B) quantized to 4-bit (Q4_K_M) running locally via Ollama. It processes images of wrinkled paper receipts, thermal paper slips, and messy PDF invoices directly on a standard laptop GPU or Apple Silicon unified memory.

Guaranteed Structured Outputs

A common failure in generative agents is hallucinated JSON schemas. We integrated Outlines and Pydantic to enforce rigorous grammar-constrained decoding. The model can only emit valid JSON matching our ExpenseRecord schema:

Open Agent Harness for Discrepancy Matching

For ambiguous entries (such as a split bill or a receipt missing a date), an open-source agent harness powered by LangChain / Smolagents spins up a lightweight reconciliation loop using Qwen 2.5 (7B). It cross-references existing bank CSV statements against the extracted metadata, flagging matches and highlighting any anomalies.

Why Does Open Innovation Matter?

For ReceiptVault, open-source AI wasn’t merely a developer preference—it was the fundamental business enabler that makes this side hustle viable.

Zero Marginal Cost = Sustainable Pricing

With closed APIs (like GPT-4o or Claude 3.5 Sonnet), extracting a high-resolution, multi-page PDF invoice can cost between $0.02 and $0.06 per document. For a freelancer sorting through 2,000 backlogged receipts, API fees alone could exceed $100. With open-weight models running on consumer hardware:

Marginal inference cost is $0.00.
We can offer a flat one-time lifetime license ($39) with high gross margins, while avoiding runaway cloud bills.

Radical Privacy & NDA Compliance

Freelancers frequently sign NDAs preventing them from sending client contracts or invoice copies to third-party cloud servers. Because ReceiptVault runs completely on-device via llama.cpp and local weights, no data ever leaves the user’s machine. You can pull the Wi-Fi plug, run it on a plane, and never worry about terms of service changes or data retention policies.

Model Specialization & Swappability

Open innovation lets us swap model weights based on client hardware:

On an M-series Mac or dedicated RTX GPU, it runs Llama 3.2 11B Vision.
On low-spec laptops, it automatically falls back to Llama 3.2 3B Vision or a quantized Moondream2 variant without rewriting any backend application logic.
My Agent Session

During the development process, an agent session was used to scaffold the local pipeline, test Pydantic schema validation with Ollama, and benchmark quantized vision model throughput.

(Session link placeholder)

My First User

Before writing the final UI, I reached out to Sarah, an independent product designer and branding consultant who had 11 months of unlogged expenses heading into Q4 tax estimates.

She refused to use cloud-based receipt scanners because her invoices listed confidential client retainer details under active NDAs.

I installed ReceiptVault on her M2 MacBook Air, dropped a folder of 142 mixed PDF invoices and mobile receipt snaps into the watch folder, and ran the pipeline with Wi-Fi switched off.

The result:

Time taken: ~14 minutes total batch processing.
Accuracy: 138 out of 142 items correctly categorized and extracted with zero manual entry.
Feedback: "This is the first time I haven't dreaded doing my business expenses. The fact that it never touched the internet meant I didn't have to redact client names."
The Sale: She immediately paid $35 via Stripe for a lifetime beta key, becoming ReceiptVault's first paying customer!

# WILDR: What If AI Helped Us Spend Less Time Online?

Atanu Barua — Mon, 12 Oct 2026 05:04:44 +0000

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

We build AI tools to help us do more on our screens. But what if we built one that encouraged us to put the phone down?

That question inspired WILDR, an offline-first AI nature companion designed to turn an ordinary walk into an opportunity to explore, observe, and learn.

What I Built

WILDR is designed for curious beginners, students, nature enthusiasts, and anyone who wants to reconnect with the world beyond their screen.

The idea is straightforward: use technology to prepare for an outdoor experience, then let the real world take over.

🌿 Outdoor discovery missions: Find different leaf shapes, observe pollinators, explore habitats, or listen for bird sounds.

📷 AI-powered image identification: Photograph an observation and use a local image model to explore possible classifications, without sending the image to a hosted AI service.

📓 An offline field journal: Save observations, notes, and identification results locally so discoveries can be revisited later.

📴 Offline-first by design: After the necessary app resources and model have been downloaded, the core experience is intended to work without an internet connection.

WILDR isn't meant to become another app that demands constant attention. It should help users discover something interesting, then give them a reason to look up from their phones.

Demo

Live demo: [URL]

Video walkthrough: [URL]

The planned demo will show the complete experience: selecting an outdoor mission, identifying a photograph with local AI, saving the observation, and accessing the journal while offline.

The live demo and video links will be added once deployment and offline verification are complete.

Code

GitHub repository: https://github.com/gene707/WILDR

The project is being developed as a responsive Progressive Web App using React, TypeScript, and Vite.

The planned architecture includes:

IndexedDB for persistent local observations and mission progress.
ONNX Runtime Web for running image inference in the browser.
A service worker for caching application resources.
A versioned local model with documented licensing, provenance, and evaluation.
Automated tests for application behavior, model inference, and offline workflows.

The goal is to make the project understandable, reproducible, and open to contributions rather than hide its core functionality behind a proprietary service.

How I Built It

I approached WILDR as a sequence of engineering milestones instead of trying to build everything at once.

1. Build the experience first.

The foundation is a mobile-friendly interface with separate spaces for discovering missions, identifying images, and recording observations.

2. Make the outdoor activities useful on their own.

Missions are structured pieces of content, not AI-generated filler. They should remain accessible even when the user has no internet connection.

3. Bring AI onto the device.

The image-identification component is designed around a compact model that can run locally through ONNX Runtime Web and WebAssembly. This avoids making a remote inference API a requirement for the core experience.

4. Make offline operation a real requirement.

Caching a homepage is not enough. The intended acceptance test includes reopening the app without a network connection, completing a mission, running local inference, and saving an observation.

5. Verify before making claims.

Model licensing, image-classification performance, storage behavior, and offline compatibility need to be tested and documented. A model's prediction is a suggestion, not a definitive species identification.

The implementation is being organized into six milestones: foundation, missions and journal, local AI, offline PWA support, feature integration, and release verification.

Why Does Open Innovation Matter?

For me, open innovation is about more than making source code publicly available. It is about being able to inspect, understand, adapt, and improve the technology behind a product.

WILDR's local-first approach makes that especially important.

Privacy becomes an architectural decision. When inference runs on the device, a photograph does not need to be uploaded to a remote AI provider just to generate a prediction.

Connectivity becomes less of a barrier. Someone exploring a park, garden, or trail should not need a reliable connection every time they want to use the app.

The community can improve the project. Contributors can review the model integration, suggest better mission content, improve accessibility, test different devices, and help evaluate more appropriate nature-specific models.

The AI can be examined instead of treated as a black box. Documented model weights, label sets, and evaluation results help contributors understand what the system can and cannot recognize.

There is an important distinction here: open-source code does not automatically make pretrained model weights or training datasets freely redistributable. Verifying those licenses is part of building WILDR responsibly.

A closed API might offer a quick route to a prototype, but it would not provide the same degree of control over local inference, data handling, and model integration.

I am using AI coding tools to help implement the project in small, verifiable milestones. The aim is not simply to generate code quickly, but to inspect the implementation, run tests, and validate the important claims.

Prize Categories

[Add the applicable partner prize categories from the official challenge rules.]

I will select the categories that match the final implementation and the challenge's eligibility requirements.

The Bigger Idea

Technology doesn't always need to keep us connected to a screen. Sometimes, it can help us notice what we were missing while looking at one.

With WILDR, I want to explore how open-source AI can make that possible: not by replacing curiosity with automated answers, but by giving people a small nudge toward the world around them.

If you could build one AI-powered tool that encouraged people to spend more time outdoors, what would it help them discover?

🚀 I Built MAZ3R: An Open-Source AI Career Assistant for Resume Optimization & Cover Letters

Atanu Barua — Mon, 05 Oct 2026 04:10:32 +0000

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

What I Built

Job searching often means rewriting the same resume repeatedly for different positions, trying to understand ATS systems, and spending hours crafting cover letters.

To solve that problem, I built MAZ3R, an AI-powered platform that helps users:

Upload a resume (PDF or DOCX)
Paste a job description
Analyze ATS compatibility
Identify missing skills and keywords
Receive resume improvement recommendations
Generate a customized cover letter
Export reports and application documents

The project was designed for students, interns, fresh graduates, and job seekers who want to improve their applications without manually tailoring every document from scratch.

Demo

🔗 Live Demo: Coming Soon

📹 Video Demo: Coming Soon

Code

🔗 GitHub Repository: https://github.com/gene707/HacktoberFest-2026

How I Built It

MAZ3R is built around open-source AI technologies.

AI Stack

Qwen 2.5 1.5B Instruct
Sentence Transformers
all-MiniLM-L6-v2 Embeddings
Hugging Face Inference API

Backend

Flask
SQLite
PDF Processing
DOCX Processing

Frontend

HTML
CSS
Vanilla JavaScript

Core Workflow

User uploads a resume.
Resume text is extracted and processed.
ATS analysis compares the resume against the target job description.
Semantic similarity scoring evaluates alignment between

Backend Projs Loading...

Atanu Barua — Sun, 04 Oct 2026 10:10:12 +0000

Been building some foundational level backend projects. After completing, I will upload the github repo here. Look forward to it,
P.S : had to delete my prev acc due to some sign-up issue,