DEV Community: Sahil desai

BillWise Local: Build a Private AI-Powered Invoice Manager That Runs Locally

Sahil desai — Sun, 18 Oct 2026 14:49:52 +0000

BillWise Local: Private AI-Powered Invoice Processing on Your Own Machine

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

What I Built

BillWise Local is a local-first AI invoice processing and expense management application designed for freelancers, small businesses, and individuals who want to simplify bookkeeping without relying on hosted AI services.

Manually entering invoice details is repetitive and error-prone. BillWise Local helps automate this workflow by extracting information from invoice images and PDFs, identifying line items, checking financial calculations, and storing invoice records locally.

Key Features

Invoice extraction: Extract text from invoice images using Tesseract OCR and from text-based PDFs using pypdf.
Local AI analysis: Use SmolLM2 through llama-cli to generate structured invoice data.
Financial validation: Check totals and line-item calculations before saving.
Expense management: Store invoices in SQLite, detect duplicates, and categorize expenses.
Spending dashboard: Review spending summaries and export invoice records to CSV.
Privacy-focused design: Keep invoice processing and AI inference local rather than depending on a hosted LLM API.

The goal is to make invoice processing more accessible and affordable for people who don't need a complicated accounting platform.

Demo

Watch the demo video to see BillWise Local in action:

▶ Watch the BillWise Local Demo

The demo showcases the invoice-processing workflow and application interface.

Code

GitHub repository: sahil1399m/BillWiseLocal

The repository contains the source code, setup instructions, OCR pipeline, extraction logic, validation module, local AI integration, and SQLite database implementation.

How I Built It

I built BillWise Local using Python and Streamlit, combining traditional document processing with open-weight AI.

The workflow is:

OCR and text extraction: Tesseract processes invoice images, while pypdf extracts embedded PDF text.
Structured extraction: Python extracts invoice fields and line items from the recognized text.
Local AI inference: SmolLM2 generates structured JSON from invoice text through llama-cli.
Validation: Financial checks identify inconsistencies and help prevent incorrect records from being saved.
Storage and analysis: SQLite stores invoice records, and Streamlit presents expense summaries and CSV exports.

I kept the architecture lightweight so it could run on a personal computer without requiring a cloud AI deployment.

One important lesson from this project was that valid JSON does not guarantee accurate extraction. Dates, quantities, and financial values still need validation and human review.

Why Does Open Innovation Matter?

Open innovation made it possible to build an AI-assisted application without making a proprietary hosted model the foundation of the product.

Using open-source tools and an open-weight model provides several benefits:

Privacy: Local inference avoids sending invoice text to a hosted LLM API.
Control: Developers can inspect, modify, and improve the extraction pipeline.
Reduced API dependence: The application does not require per-request hosted LLM API charges for local inference.
Accessibility: Python, SQLite, Streamlit, Tesseract, and local inference make experimentation possible without building a large cloud infrastructure.
Extensibility: The project can be adapted to different invoice layouts, models, and validation rules.

Open innovation makes it possible to experiment, learn, and build useful tools without surrendering control over the technology or data.

My Agent Session

Not included in this submission.

Prize Categories

No partner-specific category is claimed in this submission. The project uses open-weight AI and open-source tools as its core technology.

Built as part of Hacktoberfest 2026.

devchallenge #hf26challenge #hacktoberfest #opensource #ai #python #streamlit #localai

[Boost]

Sahil desai — Sat, 10 Oct 2026 14:07:07 +0000

Sahil desai

Oct 10

TrailMate AI: Turn Your Free Time into an Outdoor Adventure with Local AI

#devchallenge #hf26challenge

3 min read

TrailMate AI: Turn Your Free Time into an Outdoor Adventure with Local AI

Sahil desai — Sat, 10 Oct 2026 14:06:30 +0000

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

What I Built

I built TrailMate AI, a local AI-powered outdoor adventure planner that turns your free time into an outdoor mission.

The idea is simple: instead of spending your free time scrolling through your phone, use AI to help you get outside and explore the world around you.

Users enter their available time, preferred activity, intensity level, budget, and location. TrailMate generates a personalized adventure plan with a mission, route idea, packing checklist, outdoor challenge, and safety tips.

Whether you have 30 minutes for a quick walk or a few hours for a more challenging adventure, TrailMate helps you make the most of your time outdoors.

The goal is to make the screen the shortest part of the experience.

Demo

Video demo: Watch TrailMate AI in action

The demo shows TrailMate AI running locally, from entering adventure preferences to generating an outdoor plan using an open-weight AI model.

Code

GitHub repository: sahil1399m/trailmate-ai

The repository contains the frontend, FastAPI backend, and code for running the local AI inference pipeline.

How I Built It

TrailMate AI is built around a locally running, open-weight language model rather than a proprietary hosted AI API.

Tech stack:

AI model: SmolLM2 1.7B Instruct, quantized to Q4_K_M
Local inference: llama.cpp
Backend: Python and FastAPI
Frontend: React, Vite, and Tailwind CSS
Data validation: Pydantic

The application follows a straightforward architecture:

The user enters their preferences in the React frontend.
The frontend sends a request to the FastAPI backend.
The backend constructs a prompt using the user's available time, activity, intensity, budget, and location.
llama.cpp runs SmolLM2 locally to generate the adventure plan.
The backend validates and structures the response before returning it to the frontend.

I chose a relatively small, quantized model so the project could run on a regular laptop without a dedicated GPU. The model is downloaded separately rather than committed to the GitHub repository.

An important part of building TrailMate was making the output reliable. I added structured response validation, normalization of malformed text, and safeguards against inventing specific parks or trails.

Why Does Open Innovation Matter?

Open innovation made it possible to build an AI application that runs locally without depending on a paid, proprietary model API.

Using an open-weight model and llama.cpp gives developers the freedom to experiment with inference, prompting, and application architecture on their own hardware. It also reduces dependence on external AI services and helps keep users' preferences and location information within the local application workflow.

For a project designed to encourage people to spend less time on screens, I wanted the AI itself to be a lightweight tool rather than another service that requires constant cloud connectivity.

TrailMate AI demonstrates how accessible open AI models can be turned into practical applications that encourage real-world experiences.

My Agent Session

I built TrailMate AI individually, using Antigravity as my AI coding assistant throughout development. I used it to help implement the FastAPI backend, integrate SmolLM2 through llama.cpp for local inference, and build the React frontend.

Prize Categories

TrailMate AI uses SmolLM2 1.7B Instruct, an open-weight language model, with local inference through llama.cpp.

I built this project individually for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.