DEV Community: Jatin Vishwakarma

I Built an AI Invoice Assistant That Runs Locally (No API Keys, No Expiring Credits) 💸

Jatin Vishwakarma — Fri, 16 Oct 2026 06:57:22 +0000

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

What if you could use AI to manage your invoices without paying for every API request or uploading your financial documents to someone else's server?

That question inspired me to build InvoiceMate AI, a local-first AI assistant designed for freelancers, independent developers, consultants, and small business owners.

Because sometimes, the best AI tool isn't the one with the biggest model. It's the one you can actually afford to run.

What I Built

InvoiceMate AI helps automate one of the most repetitive tasks in running a small business: managing invoices and receipts.

Upload an invoice or receipt, extract its important details, review the results, and organize everything in one place.

The goal is to make everyday financial administration simpler without making users dependent on paid AI APIs.

Here's what I'm building into it:

Invoice and receipt text extraction using local OCR.
AI-powered extraction of vendor names, dates, totals, taxes, and expense categories.
An expense dashboard with spending summaries and trends.
A natural-language assistant for querying recorded expenses.
Searchable invoice records with filters.
CSV exports for further analysis.
Local storage and privacy-first document processing.

Who would actually use this?

A freelancer managing dozens of client invoices. An independent developer tracking project expenses. A small business owner tired of entering receipt details manually.

These are the people I want to build for.

Demo

Code

GitHub Repository: https://github.com/coddingjatin/InvoiceMate-AI-Week-2-Hacktoberfest-Challenge

The project is designed around a modular architecture, with a React and TypeScript frontend, a Python and FastAPI backend, SQLite for local storage, and local AI inference through Ollama.

I'd love to make this useful for people beyond my own machine, so contributions and feedback are welcome.

How I Built It

The central design decision was to make local AI a core part of the application rather than simply adding an AI API to a conventional expense tracker.

Here's the intended stack:

Ollama + an open-weight language model: Structured invoice extraction and natural-language understanding.
Tesseract OCR: Reading text from scanned receipts and image-based documents.
Python + FastAPI: Document processing, validation, and backend APIs.
SQLite: Persisting invoice and expense records locally.
React + TypeScript: Building the interactive dashboard and document review experience.
Pydantic: Validating extracted data before it is stored.

The workflow looks like this:

A user uploads a PDF or image.
Local OCR or PDF parsing extracts the text.
A locally running language model converts the text into structured fields.
Validation logic checks the output, while deterministic code handles financial calculations.
The user reviews the extracted information.
Verified records are stored locally and become available for search, analysis, and export.

The review step matters. Language models can misread amounts or dates, especially when documents are scanned poorly. I don't want an AI-generated number silently becoming a financial record.

And here's the part I'm most excited about:

No paid AI inference API. No expiring inference credits. No mandatory cloud AI dependency.

After the required dependencies and model have been downloaded, the core workflow is designed to run offline.

Why Does Open Innovation Matter?

For this project, open innovation isn't just about using a different model. It changes the economics and privacy assumptions behind the product.

1. The economics actually make sense.

If every invoice consumes paid API credits, the cost of running the product grows with usage.

Local inference removes mandatory per-request AI billing. Users still need hardware, storage, electricity, and maintenance, but they aren't forced to pay a cloud AI provider for every extraction.

2. Financial data deserves privacy.

Invoices can contain client information, addresses, transaction details, and other sensitive business records.

Running OCR and inference locally means these documents don't need to be sent to a third-party AI service. That gives users more control over where their information goes.

3. No dependence on expiring API credits.

I don't want a basic expense workflow to stop working because an API key expires, a free quota runs out, or a provider changes its pricing.

A locally installed model makes the core AI workflow independent of those external inference quotas.

4. Freedom to experiment.

Open-weight models let developers experiment with compatible models, prompts, extraction strategies, and domain-specific customization.

A small-business tool doesn't always need the most expensive general-purpose model. It needs a model that performs well enough for its specific task, with proper validation and human review.

5. Offline access becomes possible.

Once the model and dependencies are installed, the main workflow can operate without an internet connection.

That opens the door to users who prefer local tools, have unreliable connectivity, or simply don't want every document-processing task to depend on a remote service.

For me, that's the real value of open-source AI: making useful AI workflows more accessible, customizable, and independent.

Prize Categories

Best Use of Render
Best Use of GitHub Copilot
Best Use of SerpApi

Submitted By: @jatin_vishwakarma

What's Next?

The next step is getting InvoiceMate AI into the hands of an actual freelancer or small business owner.

I want to learn whether the extraction workflow genuinely saves time, which document formats cause problems, and whether users would pay for installation, customization, or ongoing support.

The best validation isn't another feature on the roadmap. It's watching someone use the product to solve a real problem.

That's what I want to focus on next.

GoLocal AI: An AI That Helps You Touch Grass, Literally

Jatin Vishwakarma — Fri, 09 Oct 2026 14:06:52 +0000

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

What I Built

What if we built an AI application whose ultimate goal was to make you stop using it?

We live in a world where almost every free moment turns into another scroll. We open our phones to take a short break, only to realize that an hour has disappeared. Meanwhile, the world outside our screens is full of little things we rarely notice: the sound of birds, a quiet street we've never explored, the shape of a leaf, or a sunset we were too busy scrolling to see.

I wanted to explore a different side of AI. Instead of building another tool that demands our attention, what if we used AI to help us take our attention back?

That idea became GoLocal AI, an open-source AI-powered outdoor companion that turns everyday walks into small, meaningful adventures.

The concept is simple: tell GoLocal AI how much time you have, choose the kind of activity you're interested in, and get a personalized outdoor mission designed around your preferences.

Maybe it's a 10-minute nature observation challenge. Maybe it's exploring a new route, discovering five things you have never noticed in your neighborhood, or taking a quiet walk without checking your phone.

The goal isn't to travel somewhere extraordinary. It's to experience ordinary places a little differently.

More Than Just Generating Outdoor Ideas

GoLocal AI is designed around the complete journey, not just the moment when AI generates a response.

Personalized Outdoor Missions: Turn your available time, activity preferences, and difficulty level into a real-world challenge.
Phone Down Mode: Once your mission is ready, step away from the screen and focus on the experience instead of the app.
Explore, Observe, Discover: Get prompts that encourage you to notice your surroundings, explore mindfully, and interact with the world around you.
Reflection Journal: After returning, capture what you experienced, what surprised you, and the little things you might otherwise forget.
A Calmer Digital Experience: Keep the interface focused on helping you get outside rather than encouraging endless engagement.

Demo

Code

GitHub Repository: https://github.com/coddingjatin/GoLocal-AI-Week-1-Hacktoberfest-Challenge

GoLocal AI is being built with the idea that meaningful AI experiences should be open to experimentation, customization, and community-driven improvement.

The project explores how open-weight AI can be used for something beyond productivity dashboards, chat interfaces, and content generation: helping people engage more deeply with their physical surroundings.

How I Built It

I approached GoLocal AI with one guiding principle: Build an experience that rewards people for leaving the app, not staying in it.

The application brings together a responsive, nature-inspired interface, personalized mission generation, a focused outdoor experience, and a reflection-based journal.

The planned technology stack includes React, TypeScript, Vite, and Tailwind CSS for the frontend. For AI-powered mission generation, Ollama with a compatible open-weight model such as Gemma can support local inference, with an optional Python FastAPI backend to manage AI requests.

The mission-generation flow can use structured inputs such as activity type, available duration, difficulty, and environment to create practical outdoor challenges. Rather than producing generic suggestions, the aim is to make each mission specific enough that a user can actually step outside and complete it.

After completing a mission, users can record their observations and reflections in an exploration journal. This creates a simple but intentional cycle:

Choose a mission → Step outside → Explore the real world → Reflect on the experience.

An important design consideration is that the experience should remain useful even when a local AI model is unavailable. A clearly identified demo mode can help users explore the interface, while keeping sample responses distinguishable from live AI-generated results.

The interesting engineering challenge isn't simply connecting an AI model to a frontend. It's designing the whole experience around a different measure of success: helping users turn a digital interaction into an offline activity.

The final technology and implementation details should reflect the features and integrations available in the submitted version.

Why Does Open Innovation Matter?

For me, open innovation is about giving developers the freedom to question the default way technology is built.

AI applications are often designed to keep users inside a platform. More prompts, more recommendations, more interactions. But what happens when we use the same underlying technology to encourage fewer interactions and more real-world experiences?

Open-weight models create room to experiment with that question.

They allow developers to explore different models, adapt prompts, run inference locally where supported, and build experiences without necessarily depending on a closed, hosted AI API for every interaction. Depending on the implementation, local inference can also offer greater control over where personal reflections are processed.

For a project like GoLocal AI, these possibilities are especially relevant. The application is intended to encourage people to step away from their screens, so a flexible and potentially local AI setup fits the broader philosophy of the project.

Open innovation also makes the idea easier for other developers to explore and extend. Someone could experiment with accessibility-focused missions, nature-learning challenges, walking activities for different age groups, or community-created outdoor adventures.

The project is a small exploration of a much bigger question:

Can we build AI that helps people live better offline, rather than simply do more online?

I believe that's a direction worth exploring.

Prize Categories

Best Use of GitHub Copilot
Best Use of Gemma

Submitted By: @jatin_vishwakarma

Final Thoughts

GoLocal AI started with a simple thought: we have built incredible technology to connect us to the world, but sometimes we need a little help reconnecting with the world right in front of us.

A short walk doesn't need to become a productivity goal. Exploring your neighborhood doesn't need a complicated plan. And spending time outdoors doesn't need another app fighting for your attention.

Sometimes, all you need is a small idea that gets you through the door.

If GoLocal AI can help someone notice a beautiful sunset, discover a new walking route, put their phone away for a while, or appreciate a place they have passed a hundred times before, then it has done something meaningful.

Less scrolling. More exploring. More living.

GoLocal AI: Get out of the algorithm. Get into the real world.

BuddyOS: An AI Copilot for the Friend Who Always Has Too Much Going On.

Jatin Vishwakarma — Fri, 02 Oct 2026 06:27:51 +0000

What I Built

I built BuddyOS for a friend who somehow manages to have five deadlines, three projects, a hackathon, two meetings, and still asks:

"Bhai, deadline kab hai?"

I wanted to build something small, but genuinely useful for one person.

BuddyOS turns the messy information my friend deals with every day into a simple, actionable plan.

They can give it:

Assignment PDFs
Hackathon problem statements
Screenshots containing deadlines
Meeting notes
Random text reminders
Project requirements
Personal to-do lists

BuddyOS extracts the important information, identifies deadlines and priorities, breaks larger tasks into smaller actions, and builds a realistic plan for what they should work on next.

Instead of another chatbot saying "How can I help?", BuddyOS tries to answer a much more useful question:

"What should you actually do next?"

The project was built around one real person, one real problem, and one goal:

Make their chaotic workload a little easier to manage.

And yes, I actually gave it to my friend to try.

Their first reaction was basically:

"Okay... this is actually useful."

That was the moment this stopped feeling like just another hackathon project.

Demo

How I Built It

The main idea behind BuddyOS was simple:

The AI should be part of the product, not just a chatbot sitting next to it.

The application uses an open-weight model running through local inference to understand the user's documents and notes.

The pipeline looks roughly like this:

Why Does Open Innovation Matter?

This project is personal, which is exactly why privacy matters.

My friend's assignments, project documents, schedules and personal notes are not things I wanted to blindly send to a third-party AI service just to generate a to-do list.

With a local open-weight model,**BuddyOS **can process that information on the user's own machine.

That changes what I can build.

I can:

Run the model without an internet connection
Keep personal documents local
Experiment with different models
Change the agent's behaviour
Inspect the workflow
Customize the system for one specific person's needs
Build without every interaction becoming another API call

That's what open innovation made possible here.

Prize Categories

Best Use of Gemma: Gemma is the open-weight model powering the core understanding and planning workflow.
Best Use of GitHub Copilot: Used during development to accelerate implementation, debugging and iteration.
**Best Use of Sentry Agent Tracing: **Used to inspect agent behaviour, latency and failures during development.

Submitted by: @jatin_vishwakarma

My Submission

Jatin Vishwakarma — Fri, 27 Dec 2024 17:14:01 +0000

This is a submission for Frontend Challenge - December Edition, Glam Up My Markup: Winter Solstice

What I Built

I have Created just a basic and simple page in that i had created a different different components that are integrated in a single page with images and all, This is my first time participation in this Challenge. Actually i was facing the issue while creating this don't know why..😅😓 But just created a simple page

Demo

Journey

Building this project was an exciting experience:

I started by diving into the theme, researching the winter solstice's scientific and cultural aspects.
I started designing the pages.
Add a finishing touch just to keep it simple using HTML, CSS, and JavaScript.

Submission

This Submission was Created by : @jatin_vishwakarma While creating this project, I learned a lot about designing and creating a engaging web pages while exploring the fascinating theme of the winter solstice.

Github Link: https://github.com/coddingjatin/Dev-Frontend