DEV Community: Anoohya Jagarlamudi

I Built a Local AI Order Manager for Small Businesses

Anoohya Jagarlamudi — Sun, 18 Oct 2026 23:11:29 +0000

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

What I Built

Small businesses often receive orders through WhatsApp, Instagram, phone calls, and walk-ins. Customer details, sizes, colors, materials, prices, and deadlines can easily become scattered across conversations and notes.

I built MakerFlow, a lightweight order-management tool for small businesses.

A shop owner can:

Paste a customer message into the app.
Use Gemma to turn the message into a structured order draft.
Review and correct the draft before saving it.
Track the customer, contact information, item, quantity, material, color, size, and other specifications.
Record the price, deposit, and remaining balance.
Add a due date and pickup or delivery details.
Move the order through a production workflow: New → Quoted → Paid → In production → Ready → Shipped → Completed
Highlight overdue orders.
Filter orders by active, overdue, or all.
Export the order queue as CSV.

The target customer is a solo maker or small business owner who needs a simple order desk without paying for a large e-commerce or production-management platform.

Customers could pay for MakerFlow through a small monthly subscription, a one-time setup service, or a customized version for their shop.

Demo

The main workflow is:

Paste a customer message into MakerFlow.
Click Draft with Gemma.
Review the extracted order details.
Save the order.
Track its production status.
Monitor the balance and delivery information from the dashboard.

Example message:

Hi, I’m Maya. I need three black phone stands, 18 cm wide, for $45. I can pick them up Friday. My number is 555-0100.

MakerFlow turns that message into an editable order draft instead of requiring the owner to retype every detail manually.

Code

The source code is available here:

GitHub repository: Anyaxx/makerflow

The project includes:

FastAPI backend
SQLite persistence
Browser-based dashboard
Gemma/Ollama integration
Docker configuration
Docker Compose deployment setup
CSV export
Order status workflow
Deposit and balance tracking

How I Built It

MakerFlow uses Python, FastAPI, SQLite, HTML, CSS, JavaScript, Docker, Ollama, and Gemma 3 4B.

The AI feature is intentionally focused. Gemma does not make production decisions or automatically communicate with customers. It creates a draft that the shop owner reviews before saving.

The application sends a pasted customer message to Gemma through Ollama and requests structured JSON:

{
"customer_name": "Maya",
"contact": "555-0100",
"item": "phone stands",
"specifications": "3 units, black, 18 cm wide",
"price": 45,
"currency": "USD",
"due_date": "",
"delivery_details": "Pickup Friday",
"notes": ""
}
The backend then normalizes the price, currency, and date, sets the initial status to new, and returns the draft to the browser.

The owner can edit the draft before saving it. FastAPI validates the order, including price and deposit values, and stores the final order in SQLite.

The deployment architecture is:

Browser
↓
FastAPI + MakerFlow dashboard
↓
Private Docker network
↓
Ollama
↓
Gemma 3 4B

The application is packaged for deployment on a DigitalOcean Droplet using Docker Compose. The app and Ollama run in separate containers, while the model and order database use persistent Docker volumes.

GitHub Copilot helped me shape the product idea, design the order workflow, implement the FastAPI backend and browser UI, integrate Gemma through Ollama, test the API behavior, and prepare the Docker deployment.

Why Does Open Innovation Matter?

Open innovation made this project practical for a small business.

A hosted AI API could extract order details, but it would send customer messages to an external service and potentially introduce a usage charge for every request. With Gemma and Ollama, MakerFlow can run the model on infrastructure controlled by the business.

That provides:

More predictable operating costs
Greater control over customer data
No per-message AI API charge
The ability to run the model locally or on a private DigitalOcean server
The freedom to change models or prompts later
A focused AI workflow instead of an expensive general-purpose chatbot

For a small business, the important point is not having the largest model. The important point is having a useful, private, affordable tool that removes repetitive work.

MakerFlow uses open-source AI for a specific job: converting informal customer requests into structured order drafts. The owner remains in control of the final order.

My Agent Session

The project was built with GitHub Copilot, and the session included the product design, implementation, Gemma integration, local testing, Docker setup, and repository creation.

My First User

MakerFlow was designed for a friend who runs a small 3D-printing business.

The product direction came from how small print shops actually receive work: informal messages, phone calls, and conversations rather than structured e-commerce orders.

The first user workflow is intentionally simple:

Copy a real customer message.
Paste it into MakerFlow.
Let Gemma create a draft.
Review the details.
Save and track the order.

Prize Categories

Best use of GitHub Copilot
Best use of Gemma

FriendVault: A Local-First Bill Buddy for the People You Love

Anoohya Jagarlamudi — Mon, 05 Oct 2026 05:30:23 +0000

I built FriendVault, a local-first bill and receipt assistant for a friend who was overwhelmed by rent, utilities, subscriptions, and the pile of digital and paper receipts that always seemed to show up at the worst time.

This wasn’t just a “finance app” demo; it was a real problem for a real person. The pain point wasn’t only tracking totals; it was the mental load of remembering what was due, when it was due, and what had already been paid. Small missed bills create stress fast

FriendVault helps someone:

upload a receipt or bill photo 📸
extract the vendor, date, and amount locally with OCR 🔍
detect grocery items from receipts 🛒
generate reminders for recurring expenses ⏰
review monthly summaries 📊
keep data on their own device instead of sharing it with a remote service 🔒

The goal was simple: turn a messy, stressful workflow into something calmer, private, and genuinely useful.

Demo

App setup:

install Tesseract
create a virtual environment
install requirements
run: streamlit run app/main.py

The app is designed to run entirely on a laptop, with local OCR and local storage. It’s meant to work without internet access and without sending receipts to a third-party service.

Code

Repository: https://github.com/Anyaxx/friendvault-hacktober

How I Built It

I built FriendVault around open-source local tooling instead of relying on a hosted AI API.

Tech stack:

Streamlit for the UI
Tesseract OCR for local text extraction
OpenCV for image preprocessing
SQLite for local persistence
Python for automation and reminder logic

The important part is that the app’s “AI” is not a cloud black box. It runs locally on the machine, which means:

no internet required 🌐
no need to send sensitive receipts to a vendor ☁️
no recurring API costs 💸
easier customization and experimentation 🔧

That makes it a practical, privacy-first tool instead of just a flashy prototype.

Why Does Open Innovation Matter?

Open innovation matters for this project because the best part of it is that it stays under the user’s control.

A closed AI service would have required sending private household billing data to a remote platform. That’s a trust problem, especially for something personal like rent, utilities, and grocery receipts. With open-source tools, the app can run entirely on a laptop, work offline, and stay local-first.

That gave me several practical advantages:

The app can run with no internet connection 🌐
Private data never has to leave the device 🔐
The OCR and extraction logic can be modified locally 🧩
The app remains cheap and flexible to iterate on 🚀

This is exactly where open-source AI helps: it makes privacy-first, offline-first software not just possible, but practical.

Conclusion

FriendVault is a small project, but it solves a real everyday problem in a way that is useful, private, and practical. I built it for someone I care about because the best software is the kind that quietly makes life easier without adding more stress.

That’s where open-source AI really mattered: local OCR, offline-first workflows, and full control over personal data made this possible without sending sensitive receipts to a cloud service. It’s a simple tool, but it’s a useful one, and that’s what I hope to keep building: software that helps people, respects their privacy, and works without locking them into a closed system.

Hello DEV 👋 I’m Learning AI by Building

Anoohya Jagarlamudi — Fri, 02 Oct 2026 00:11:07 +0000

After spending a lot of time learning about machine learning, NLP, LLMs, and cloud technologies, I’ve realized something:

The fastest way for me to learn is to build.

So, I’m starting to document that journey here on DEV.

I’m an early-career software/AI engineer interested in AI engineering, LLM applications, RAG systems, cloud, and backend development. Over the past few months, I’ve been experimenting with technologies such as Python, FastAPI, LangChain, Hugging Face, vector databases, Azure, AWS, and local LLMs.

One of the projects I recently worked on was a Retrieval-Augmented Generation (RAG) system.

Instead of simply asking an LLM a question and hoping it knows the answer, the system retrieves relevant information from a knowledge base and uses that context to generate a response.

At a high level:

Text
Documents
↓
Document Processing
↓
Chunking
↓
Embeddings
↓
Vector Store
↓
Similarity Search
↓
Relevant Context
↓
LLM
↓
Answer

Building it made me realize that RAG isn't just about connecting a vector database to an LLM.

There are a lot of interesting engineering decisions involved:

How should documents be chunked?
Which embedding model should be used?
How do you retrieve the most relevant information?
How do you prevent irrelevant context from reaching the LLM?
How do you evaluate whether the generated answer is actually grounded?
How do you handle documents that change over time?
How do you turn a prototype into something that can actually be deployed?

These are the kinds of questions I want to explore more deeply.

What I'm learning next

I want to go beyond simple chatbot projects and explore:

Agentic RAG
Multimodal AI
MCP and tool-using agents
LLM evaluation
AI application observability
FastAPI and production backend architecture
Azure/AWS AI services
Local and open-source LLMs

This is my first post here, so I'm excited to start documenting the journey.

If you're also learning AI engineering, backend development, or LLM systems, I'd love to learn from what you're building too.