DEV Community: Atharv Kulkarni

I Built an AI Assistant That Helps Freelancers Get Their Finances Under Control 💸

Atharv Kulkarni — Wed, 14 Oct 2026 08:43:36 +0000

What if a freelancer could organize invoices, understand expenses, and prepare financial summaries without sending sensitive documents to a third-party AI service?

Freelancing gives people the freedom to work on their own terms, but it also comes with a less exciting responsibility: managing invoices, receipts, expenses, and payment records.

When you're handling multiple clients, even a small administrative task can interrupt your actual work.

I wanted to explore whether open-source AI could make this process simpler, more affordable, and more private.

That idea became InvoicePilot AI — a local-first financial document assistant built for freelancers and independent professionals.

💸 The Problem: Freelancers Shouldn't Need to Be Their Own Accounting Department

Imagine finishing a long day of client work.

You have invoices in one folder, receipts scattered across downloads, expense notes in a spreadsheet, and payment information buried in emails.

Before you can understand how much you earned or spent, you have to organize everything manually.

Existing financial tools can help, but some are unnecessarily complicated for individuals, while AI-powered services may require uploading sensitive financial documents to external platforms.

I wanted to build something focused on one specific user: a freelancer who wants to spend less time organizing paperwork and more time doing paid work.

🚀 Introducing InvoicePilot AI

InvoicePilot AI transforms unorganized financial documents into structured, searchable information.

The idea is to make routine financial administration less tedious without requiring freelancers to adopt a complicated accounting workflow.

The application brings together document processing, AI-assisted information extraction, and simple financial summaries in one interface.

What can it do?

Invoice and receipt processing: Extract relevant information from supported documents.
Structured data extraction: Organize details such as vendor, invoice date, amount, and currency into consistent fields.
Expense organization: Group extracted records into a format that's easier to review.
Financial summaries: Help users understand recorded expenses and invoice totals.
Review before saving: Allow users to check extracted information instead of blindly trusting an AI-generated result.
Local-first processing: Keep document processing local when using the local inference configuration.

The goal isn't to replace an accountant or a complete accounting platform. It's to reduce the repetitive work that happens before financial information becomes useful.

🧠 Why I Chose Open-Source AI

I used Python for document-processing logic and Ollama to integrate an open-weight language model into the application. The interface uses React and Tailwind CSS to keep the workflow simple and responsive.

The interesting engineering decision was not simply choosing an AI model. It was deciding where the model should fit into the workflow.

Traditional document-processing code is good at predictable tasks, such as validating required fields and calculating totals. Language models are useful for interpreting less structured text and mapping it into a consistent format.

Combining these approaches gives each component a specific responsibility.

For example, the model can help extract information from an invoice, while application code validates the resulting fields and calculates totals deterministically.

This distinction matters because financial data needs more than a response that merely sounds convincing.

Why not just use a proprietary AI API?

For this use case, a local inference option offers several advantages:

Privacy and control: Financial documents can contain client names, addresses, invoice numbers, and other sensitive information. Local processing can reduce the need to send these documents to an external inference provider.

Cost control: Once a compatible model is available locally, inference doesn't require a per-request fee from a hosted model API. Hardware, electricity, and maintenance still have costs.

Flexibility: Open-weight models make it possible to experiment with different models and runtimes rather than tying the entire application to one provider.

Accessibility for independent developers: A local development workflow makes experimentation possible without requiring a paid AI subscription.

These advantages depend on the actual configuration. Local inference alone doesn't guarantee that every component operates offline, and the model's license and capabilities still need to be considered.

But for a small tool serving independent professionals, having control over the AI layer can make the product more practical.

⚙️ How It Works

The workflow is designed around a simple sequence.

Step 1 — Import a document

The user selects a supported invoice or receipt.

Step 2 — Extract relevant information

The application reads the document and prepares its content for structured extraction.

Step 3 — Use AI to interpret the content

The model identifies relevant information and maps it into the application's expected structure.

Step 4 — Validate the result

Application-level checks help detect missing fields, invalid values, and inconsistent totals. The user can review the extracted information before saving it.

Step 5 — Generate useful summaries

Once the records are validated, the application can organize expenses and summarize invoice information.

The architecture separates AI-assisted interpretation from deterministic financial calculations. That makes the results easier to validate and helps prevent a generated response from being treated as authoritative financial data.

🛠️ The Engineering Challenges

Building this project made me think carefully about the difference between a convincing AI response and reliable application behavior.

1. Extracting structured information from messy documents

Documents don't always follow the same layout. Dates, totals, currencies, and vendor details may appear in different positions or formats.

The challenge was to make the extracted information consistent enough for the rest of the application to use.

2. Handling unreliable model output

Language models can return incomplete information, unexpected formats, or incorrect interpretations.

Instead of assuming every response is correct, the application needs validation, clear error handling, and a review step before the information becomes part of a financial record.

3. Keeping calculations deterministic

Financial calculations shouldn't depend on a language model doing arithmetic in free-form text.

The model helps interpret documents, but application code should calculate totals and validate numeric fields wherever possible.

4. Designing for a real user

A freelancer doesn't want to understand prompts, model parameters, or inference configuration just to organize a receipt.

The interface therefore needs to hide unnecessary complexity while still making extracted information easy to inspect and correct.

📊 Results: What the Project Is Designed to Improve

I evaluated the application around the practical workflow it is intended to support.

The most important outcomes are:

Less repetitive data entry: Supported documents can be converted into structured records instead of requiring every field to be entered manually.
More consistent records: A common output format makes invoices and receipts easier to organize and review.
Clearer financial information: Structured records provide a foundation for expense summaries and invoice totals.
Greater control over sensitive documents: A local inference setup offers a way to process supported documents without sending their contents to a hosted AI model.
A simpler workflow: Document processing, review, and organization happen within one application.

The key lesson is that useful AI isn't measured only by the sophistication of its output. It should also be measured by whether it removes a meaningful amount of repetitive work.

For a real-world evaluation, the next step is to measure extraction accuracy across a representative set of invoices, record processing time, compare the results with manual entry, and test how well the application handles unusual formats.

I would also validate the workflow with actual freelancers before making claims about time saved or willingness to pay.

💰 Could Someone Actually Pay for This?

This question was central to the Hacktoberfest Side Hustle theme.

InvoicePilot AI targets freelancers, consultants, independent developers, designers, and small service businesses that handle recurring financial paperwork.

A possible business model is a free local-first version with optional paid features, such as:

Batch processing for larger document collections.
Exportable expense and invoice reports.
Custom document templates.
Client-wise organization.
Additional workflow automation.

The basic product could remain accessible, while paid features could target people who process enough documents to justify paying for convenience.

I haven't assumed that the product already has paying customers. Validating demand would require putting it in front of freelancers, observing how they use it, and asking whether it solves a problem worth paying to eliminate.

That is the difference between building something technically interesting and building a sustainable side hustle.

🔓 Why Open Innovation Matters

Open-source AI makes this kind of experimentation more accessible.

Instead of depending entirely on a proprietary API, developers can select an appropriate open-weight model, experiment with local inference, and adapt the processing pipeline to their use case.

For InvoicePilot AI, that flexibility is particularly relevant because the documents may contain sensitive financial information.

A local-first architecture gives users more control over where their documents are processed. It also provides a path toward predictable inference costs without charging for every model request.

Of course, the entire application's privacy properties depend on its implementation, and local inference doesn't automatically make every dependency or network interaction private.

Still, open tooling gives developers more freedom to make those design choices themselves.

🚧 Limitations and Future Improvements

There is plenty of room to make InvoicePilot AI more robust.

My next priorities would be:

Testing extraction accuracy across different invoice layouts.
Improving handling of scanned documents and OCR errors.
Adding duplicate detection and stronger validation.
Supporting additional currencies and date formats.
Building accounting-software export integrations.
Adding more comprehensive privacy and data-retention controls.
Conducting usability tests with freelancers who manage real financial workflows.

The most important improvement would be validating the product with real users and using their feedback to prioritize the features that actually save them time.

🎯 Final Thoughts

Building InvoicePilot AI reinforced an idea I find increasingly important: AI becomes valuable when it solves a specific problem for a specific person.

A freelancer doesn't necessarily need another chatbot. They need fewer repetitive tasks, more organized records, and a reliable way to understand their financial information.

By combining open-weight AI with conventional application logic, I explored how a small, focused tool could make that workflow simpler while giving users more control over their data.

That is what makes the Side Hustle challenge interesting to me. It pushes us to think beyond whether we can build something with AI and ask a more practical question:

Would someone actually use it, and would it be worth paying for?

InvoicePilot AI is my attempt to explore that question through a practical application of open-source AI.

If you work independently, I'd love to know: What's the most repetitive administrative task you would pay to automate?

devchallenge #hf26challenge #opensource #ai #python #react

GreenQuest AI: I Built an AI That Tells You to Put Your Phone Away

Atharv Kulkarni — Sun, 11 Oct 2026 17:00:32 +0000

What if we used AI to spend less time with AI?

We build applications that answer questions, summarize documents, generate code, and keep us engaged with our screens. But what if we used the same technology to encourage people to step away from their devices and experience the world around them?

That question became the starting point for GreenQuest AI, my project for the Hacktoberfest 2026 Open-Source AI Challenge: Week 1 — Touch Grass.

Instead of building another chatbot that wants to keep you talking, I wanted to build something that gives you a reason to stop scrolling, step outside, and do something meaningful.

🌿 The Problem: Sometimes, We Just Need a Reason to Go Outside

Think about the last time you had 20 minutes free.

Maybe you opened Instagram, watched a few videos, switched to another app, and somehow spent the entire break looking at a screen.

I've noticed how easy it is to spend free time consuming content simply because deciding what to do feels like too much effort.

Going outside doesn't need to mean planning a trip or finding an exciting destination. It could be taking a different route on your evening walk, observing birds in a nearby garden, photographing interesting patterns in nature, or spending a few minutes with your plants.

The activities are simple. Getting started is the difficult part.

I wanted to build an application that makes the first step easier.

💡 Introducing GreenQuest AI

GreenQuest AI is an AI-powered outdoor companion that turns your available time and interests into small, actionable outdoor missions.

The idea is straightforward: tell the application what kind of experience you want, and it helps you find something you can actually do.

For example:

"I have 20 minutes free. I want to relax, get some fresh air, and avoid travelling far."

GreenQuest AI can turn that request into a short nature-observation challenge, a photography mission, or a simple walk with a purpose.

Instead of presenting users with an endless list of recommendations, the goal is to give them one useful idea and let them get on with their day.

What makes it different?

🌳 Personalized outdoor missions: Suggestions shaped around available time, interests, and preferences.
🚶 Small, achievable activities: Missions that don't require expensive equipment or extensive planning.
🌱 A practical purpose for AI: Generated recommendations lead to real-world activities rather than longer conversations.
🧭 A simple experience: The interface focuses on choosing and starting a mission, not keeping users engaged indefinitely.
♿ Accessibility-conscious design: Activities can account for user preferences and relevant accessibility needs.

The principle behind the design is simple: the application should help you leave the screen, not give you another reason to stay.

🧠 Building with Open-Source AI

One of the most interesting parts of this project was exploring how open-source AI could support an application designed around real-world experiences.

I used Python, React, Tailwind CSS, Ollama, and the Qwen2.5-1.5B-Instruct model to build the experience.

React and Tailwind CSS helped me create a responsive interface, while Python handled the application logic and AI integration. Ollama provided a practical way to run an open-weight language model locally instead of making every request dependent on a proprietary hosted AI service.

Qwen2.5-1.5B-Instruct was a deliberate choice for experimentation because I wanted to explore a relatively small model rather than assume that every useful AI feature needs a large cloud-hosted model.

The model's role is to turn user preferences into relevant, structured outdoor activity suggestions.

This architecture also made me think more carefully about the difference between generating an interesting response and generating something a person can realistically act on.

⚙️ How the Experience Works

The application follows a simple flow:

1. Tell GreenQuest what you need.

The user provides their available time, interests, and preferences.

2. Generate an outdoor mission.

The application passes the relevant context to the AI component, which generates a suitable activity.

3. Turn the suggestion into an action.

The result presents a mission the user can understand without needing to plan an entire outing.

4. Put the phone away.

This is the most important step. The application has done its job when the user no longer needs to interact with it.

I wanted the AI interaction to be short and purposeful. A successful experience shouldn't require a long conversation to decide what to do next.

🛠️ The Engineering Challenges

Building GreenQuest AI made me think beyond simply connecting a model to a user interface.

1. Making AI suggestions useful

Language models can generate creative ideas, but creativity alone doesn't guarantee usefulness.

A suggestion needs to fit the user's available time, preferences, and circumstances. A complicated activity isn't appropriate when someone has only 15 minutes free.

This made the quality of the input context and the structure of the generated response important parts of the design.

2. Working with a small model

Using a relatively small open-weight model creates an interesting engineering trade-off.

Smaller models can be more practical to experiment with on ordinary hardware, but their outputs still need to be evaluated for relevance, consistency, and clarity.

I had to think about how to make the application useful without assuming that every model response would be perfect.

3. Designing for a different kind of engagement

Most applications try to maximize the time users spend interacting with them.

GreenQuest AI has a different objective: help users decide what to do and then get out of their way.

That influenced the interface and the overall experience. The recommendation is the beginning of the activity, not the activity itself.

4. Keeping recommendations responsible

Outdoor activities depend on real-world conditions. An AI-generated suggestion should never be treated as proof that a location is safe, a route is accessible, or the weather is suitable.

This is an important limitation to acknowledge when designing AI systems that influence actions outside the digital environment.

🔓 Why Open Innovation Matters Here

For me, the most interesting aspect of open-source AI is the freedom it gives developers to experiment with how AI applications work.

Using an open-weight model with a local runtime creates opportunities for local inference, greater control over data flows, and experimentation without requiring a paid proprietary inference API for every interaction.

Of course, these benefits depend on the model's license, the actual deployment architecture, and the resources available on the user's machine. Running a model locally doesn't automatically make an entire application offline-capable, and model quality still matters.

But the ability to choose a model, run it in a controlled environment, and adapt the surrounding application is valuable.

It also changes how I think about AI product design.

We don't always need the largest model or the most complicated architecture. Sometimes, a smaller model that performs a focused task is a better starting point.

Open innovation makes it easier to experiment with AI that serves the user's goals instead of locking the experience into one provider's ecosystem.

For GreenQuest AI, that means exploring how AI can encourage people to spend more time in the physical world, with more control over the technology behind the experience.

🌍 The Bigger Idea: AI Doesn't Always Need More Screen Time

GreenQuest AI started with a simple thought: technology can help us disconnect from technology.

An outdoor mission doesn't have to be extraordinary. It could be noticing five different plants, finding an unfamiliar walking route, observing the sky, or spending a little time in a garden.

The value comes from doing something, not from generating the perfect recommendation.

That is what makes the Touch Grass theme interesting to me. It challenges us to think about AI beyond productivity, automation, and content generation.

What if one of the most useful things an AI application could do was give someone a good reason to close it?

🚀 What's Next for GreenQuest AI?

There is plenty of room to improve the experience:

Better personalization based on previous preferences.
Optional weather-aware suggestions using reliable weather data.
Support for different languages and local contexts.
More accessibility options and low-mobility activities.
Additional open-weight models for different hardware capabilities.
Privacy-conscious ways to track completed outdoor missions without encouraging excessive screen time.

I'd also like to explore ways to evaluate whether generated missions are genuinely practical, rather than judging their quality only by how convincing the text sounds.

🌱 Final Thoughts

Building GreenQuest AI gave me an opportunity to explore a different use of open-source AI: not creating more content for people to consume, but helping them discover something to do away from their screens.

The most important part of the idea isn't the model, the interface, or the number of features.

It's what happens after the recommendation.

A person closes the application, steps outside, and experiences something new.

And if the application can help make that happen, even in a small way, it has accomplished what I wanted it to do.

This was my exploration of the Hacktoberfest 2026 Open-Source AI Challenge: Touch Grass — using open technology to encourage a little more time in the real world.

Now I'm curious: if an AI gave you one 15-minute outdoor mission today, what would you want it to be? 🌿

devchallenge #hf26challenge #opensource #ai #python #react

GreenQuest AI: Turning Open-Source AI into a Reason to Touch Grass 🌱

Atharv Kulkarni — Sat, 10 Oct 2026 17:29:01 +0000

What if AI didn't ask you to spend more time in front of a screen, but helped you step away from it?

That's the idea behind GreenQuest AI — an AI-powered outdoor companion designed to turn free time into small, meaningful adventures outside.

Built for the Hacktoberfest 2026 Week 1 challenge, Touch Grass, this project explores how open-source AI can encourage people to reconnect with nature through simple, accessible activities.

🌿 The Problem

Our digital lives make it easy to spend hours sitting indoors. When we finally have some free time, we often don't know what to do with it.

Going outdoors doesn't have to mean planning an expensive trip, hiking a mountain, or visiting a famous destination. Sometimes, it can be as simple as taking a short walk, observing birds, exploring a nearby park, or spending a few minutes gardening.

The challenge is finding an activity that fits our available time, interests, energy, and surroundings.

That's where GreenQuest AI comes in.

💡 The Idea: GreenQuest AI

GreenQuest AI transforms a simple request into an actionable outdoor mission.

Instead of asking users to plan an entire day, it helps them discover something enjoyable they can do with the time they have available.

For example, a user might say:

"I have 20 minutes free, want to relax, and don't want to travel far."

GreenQuest AI could suggest a short nature walk, a five-senses observation challenge, or a small outdoor photography mission.

The goal isn't to make outdoor activities complicated. It's to make getting started easier.

✨ Key Features

AI-generated outdoor missions: Personalized suggestions based on available time, interests, and preferences.
Flexible activity ideas: Walking, nature observation, gardening, photography, and other outdoor-friendly activities.
Beginner-friendly experiences: Small missions that don't require expensive equipment or advanced skills.
Simple user experience: A straightforward interface that helps users move from an idea to an activity.
Accessibility-conscious suggestions: Activities can be tailored to relevant mobility and accessibility preferences.
Practical fallback behavior: Where implemented, useful alternative suggestions or error messages keep the experience understandable when the AI service is unavailable.

The focus is on useful recommendations rather than unnecessary complexity.

🧠 Why Open-Source AI?

I wanted to explore how open-source AI could power a practical application beyond the usual chatbot experience.

Open models and open tooling can give developers more control over how an application is built, customized, and deployed. Depending on the model and deployment approach, they can also support local inference and reduce dependence on paid hosted APIs.

For GreenQuest AI, the important idea is that AI should serve a real-world purpose.

It can help translate a user's preferences into a manageable activity, while the actual experience happens away from the screen.

The best outcome isn't a user spending more time interacting with AI. It's a user finding a good reason to put their phone away.

⚙️ How It Works

At a high level, the application follows this workflow:

The user enters their available time, interests, and activity preferences.
The application prepares those preferences for the AI component.
The model generates an outdoor activity suggestion.
The application presents the mission in a clear, actionable format.
The user can take the suggestion offline and enjoy the activity.

The application is designed around a simple principle: minimize friction between discovering an activity and actually doing it.

The source repository contains the implementation details and setup instructions.

🛠️ Challenges and Learnings

Building a practical AI application involves more than connecting a model to an interface.

Some important considerations for this project include:

Making generated suggestions specific enough to be useful.
Keeping the application simple for first-time users.
Handling model errors and unavailable services gracefully.
Avoiding unsupported claims about weather, locations, or outdoor safety.
Designing an experience that encourages offline action instead of prolonged screen time.

These considerations helped shape the project around usability and real-world value.

🌍 Why This Matters

AI applications are often designed to keep us engaged with digital products. GreenQuest AI explores a different direction: using AI to help people engage with the physical world.

A useful outdoor mission doesn't need to be extraordinary. It might be a short walk, noticing five different plants, observing the clouds, or spending a little time in a garden.

Small actions can make outdoor time feel more approachable.

That's what I wanted to explore through this project.

🚀 What's Next?

Potential future improvements include:

Saving favorite missions.
Adding optional weather-aware suggestions using a reliable weather source.
Creating personalized outdoor challenges.
Supporting additional languages.
Adding privacy-conscious progress tracking.
Expanding accessibility and low-mobility activity options.

These improvements would be prioritized according to real user needs and the project's technical constraints.

🎉 Built for Hacktoberfest 2026

GreenQuest AI is my exploration of the Touch Grass theme: using open-source AI to encourage something simple but meaningful outside the digital world.

The project is an opportunity to experiment with open AI tooling, build something practical, and explore how technology can support healthier relationships with our surroundings.

If you're interested in the idea, check out the code and try the demo.

🌱 Project: GreenQuest AI

I'd love to hear your thoughts: What is one small outdoor activity you'd recommend to someone who wants to spend less time indoors?

hacktoberfest #opensource #ai #webdev