DEV Community: Bhadra Lakshmi Swetha Oruganti

HacktoberFest Week 2 Challenge LocalLedger AI: A Private Invoice and Receipt Organizer for Freelancers

Bhadra Lakshmi Swetha Oruganti — Mon, 19 Oct 2026 06:24:15 +0000

LocalLedger AI: A Private Invoice and Receipt Organizer for Freelancers

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

What I Built

LocalLedger AI is a privacy-first invoice and receipt organizer built for freelancers, consultants, and independent workers.

Managing invoices and receipts manually can become frustrating. Financial documents end up scattered across folders, searching for a particular expense takes time, and preparing monthly summaries involves repetitive work. Uploading these documents to cloud-based AI services can also raise privacy concerns.

I built LocalLedger AI to make this workflow simpler while keeping documents on the user's computer.

Here’s what it does:

Smart data extraction: Extracts vendor names, invoice numbers, dates, currency, subtotal, tax, total, and payment status from invoices and receipts.
Human-reviewed results: Flags missing, ambiguous, or inconsistent fields so users can verify and correct the extracted information.
Duplicate detection: Identifies exact duplicates using file hashes and flags possible duplicates using document details.
Local document organization: Organizes original documents into folders while avoiding filename collisions.
Expense insights: Generates monthly and vendor-wise summaries with CSV export.

The potential customers are freelancers and small independent businesses that want less manual bookkeeping without depending on cloud AI services. A paid desktop edition could be a future direction, although I haven't validated pricing or paying customers yet.

Demo

There isn't a hosted demo or video walkthrough available yet. LocalLedger AI is designed to run on the user's own computer rather than requiring a hosted service.

To run it locally:

Install Ollama and Tesseract OCR.
Download the Qwen2.5 model:

   ollama pull qwen2.5:3b-instruct

Install the Python dependencies:

   pip install -r requirements.txt

Start the application:

   streamlit run app.py

After the required software and model are installed, document processing can run offline. The application also indicates whether Ollama and the selected model are available.

Code

Check out the source code and implementation here:

LocalLedger AI — GitHub Repository

Contributions and suggestions for improving local document processing, extraction accuracy, and privacy are welcome!

How I Built It

I wanted to build around open-source tools and a locally running model instead of depending on a proprietary, cloud-hosted AI API.

Here's the technology stack:

Python: Core application logic and document-processing pipeline.
Streamlit: User interface for importing documents, reviewing extracted fields, and exploring expense summaries.
Qwen2.5 Instruct (3B): Open-weight language model used for structured invoice and receipt data extraction.
Ollama: Runs the model locally and provides the interface for local inference.
PyMuPDF: Extracts text from text-based PDF documents.
Tesseract OCR: Extracts text from scanned PDFs and image-based receipts.
SQLite: Stores document metadata and extracted information locally.
Pandas and Plotly: Support data analysis, monthly summaries, and vendor-wise visualizations.
Python hashlib: Generates SHA-256 hashes for exact duplicate detection.

The workflow is straightforward: a user imports a document, the application extracts its text, and the local model identifies relevant financial fields. The returned JSON is validated before the results are saved to SQLite.

An important design decision was to treat AI-generated results as suggestions rather than unquestionable facts. Missing or uncertain values are flagged for human review. Original files are retained, filenames are made collision-safe, and documents remain available for review even if a model request fails.

Why Does Open Innovation Matter?

Financial documents can contain sensitive information, including client names, addresses, invoice details, and transaction amounts. Sending this information to an external AI service isn't always desirable, especially for freelancers handling client data.

Open-source tooling and local inference make a different approach possible.

With LocalLedger AI, users can run the model on their own machines, inspect the processing pipeline, and keep document content within their local workflow. After the initial setup, they can process documents offline without depending on a hosted inference API or paying per-request API charges.

Open innovation also gives developers the freedom to experiment with different models, improve extraction and validation, and adapt the application to their own workflows without being locked into a single proprietary AI provider.

Of course, local AI has trade-offs. Performance depends on available hardware, OCR quality varies between documents, and model outputs still need verification. That's why human review is an important part of this project rather than an afterthought.

For me, this project was an opportunity to explore how open-weight AI can solve a practical problem while keeping privacy at the center of the design.

My Agent Session

Optional section — add this if you have a saved DevRelay agent session.

I used this project to explore an open-source AI workflow for a practical, privacy-focused application. If a shareable DevRelay session becomes available, I'll link it here.

Prize Categories

Open-Source AI Challenge — Week 2: Side Hustle

No partner-specific prize category claimed. The project uses the open-source and locally runnable tools described above.

Built with Python, local AI, and a focus on keeping financial documents private.
Hacktoberfest #Hacktoberfest2026 #BuildForAFriend #OpenSource #DSA #DevTools #JavaScript #NodeJS #WebDevelopment

# FixIt Forward — Turn Overlooked Public Problems into Actionable Reports

Bhadra Lakshmi Swetha Oruganti — Mon, 12 Oct 2026 05:10:09 +0000

FixIt Forward — From Noticing a Problem to Taking Action

The problem isn't that we don't notice what's broken. It's that we don't always know what to do about it.

An overflowing dustbin. A broken streetlight. A damaged pavement. A neglected public space.

We encounter these problems in our everyday lives, but reporting them can be confusing. We might not know which authority to contact, how to describe the issue, or what information to include.

So, for the Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass, I'm building FixIt Forward — a project designed to turn everyday observations into structured, actionable civic reports.

The idea is simple: instead of noticing a public problem and walking past it, make it easier to take the next step toward getting it addressed.

What I Built

FixIt Forward is centered around one focused workflow: photograph a public issue, turn it into a clear report, and make it easier to act on it.

The intended workflow includes:

Photo-based issue identification: Use AI to identify issues such as overflowing bins, damaged roads, broken streetlights, and neglected public spaces.
AI-assisted report generation: Convert the observation into a concise, structured description.
Location support: Allow users to add the location of the issue.
Editable reports: Let users review and correct AI-generated information before using it.
Report export: Make the report easy to copy or export for submission to the relevant civic authority.
A privacy-conscious approach: Explore self-hosted, open-weight AI models so that image processing can happen locally when the chosen model and deployment support it.

The goal isn't to replace civic authorities or promise that every reported issue will be resolved.

It's to reduce the friction between noticing a problem and doing something about it.

Less scrolling past problems. More taking action in the real world.

Demo

I haven't deployed a live demo yet.

🚧 Project Status: Source repository available; deployment and a live walkthrough are not yet available.

Code

💻 GitHub Repository:

FixIt Forward — Source Code

How I Built It

I approached FixIt Forward as an application of open-source AI to a practical, everyday problem.

The project is designed around a straightforward pipeline:

Photo → Issue Classification → Report Generation → User Review → Export

The AI component is intended to help identify the type of public issue and draft a useful description. The user remains in control of the final report, including its wording and location.

I also want to explore open-weight models that can be self-hosted rather than making the application dependent on a proprietary AI API. This could offer communities greater control over their data and deployment, depending on the model and infrastructure used.

The focus is not simply on generating text with AI. It is on producing something useful outside the application: a report that a person can review and use to contact the appropriate authority.

Why Does Open Innovation Matter?

Public infrastructure affects everyone, but the tools available to report problems are not always straightforward or accessible.

Open innovation creates an opportunity to build tools that communities can adapt to their own needs.

A workflow developed for reporting overflowing bins in one city could be adapted to report damaged pavements, broken streetlights, or neglected public spaces elsewhere.

Using open-source AI could also make it possible to self-host parts of the workflow, inspect the implementation, and adapt the technology to local requirements instead of relying entirely on a closed service.

For me, the value of open innovation is making technology more accessible, adaptable, and useful beyond a single application.

The aim is not to build another AI chatbot. It's to use AI to help people take practical action in the physical world.

My Agent Session

I don't currently have a saved, shareable DevRelay agent session for FixIt Forward.

I'll leave this section without a session link rather than include an unrelated session or an unverified link.

Prize Categories

Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass

Final Thoughts

Touch Grass is a reminder to step away from our screens and engage with the world around us.

FixIt Forward takes that idea one step further: what if the things we notice while walking around our neighbourhoods became opportunities to make those places better?

A photograph won't fix a broken streetlight by itself. But a clear, actionable report can help turn an observation into a concrete next step.

Notice it. Report it. Fix it forward. 🌱

Hacktoberfest #Hacktoberfest2026 #OpenSourceAI #TouchGrass #CivicTech #OpenSource #AI #Community

Hacktober Fest Weekend Challenge: Build for a Friend-AlgoAtlas — One Focused Path Through the DSA Chaos

Bhadra Lakshmi Swetha Oruganti — Mon, 05 Oct 2026 06:09:02 +0000

AlgoAtlas — One Focused Path Through the DSA Chaos

The problem isn't finding DSA questions. It's deciding what to solve next.

A friend of mine was preparing for coding interviews and kept running into the same problem: there were too many resources and no clear path through them.

LeetCode. Codeforces. NeetCode. Blind 75. Striver A2Z. GitHub repositories. Interview resources.

All useful. But constantly switching between them made practice feel more complicated than it needed to be.

So for the Hacktoberfest Weekend Challenge: Build for a Friend, I built AlgoAtlas — a focused DSA practice workspace designed to help learners decide what to practice next.

What I Built

AlgoAtlas brings problem discovery, practice planning, recommendations, progress tracking, and coding into one workspace.

It includes:

A practice dashboard with solved problems, streaks, topics, and practice time
Topic-based problem exploration
Search and filters for topic, difficulty, source, and platform
Curated collections including Blind 75 / Grind 75, NeetCode 150, and Striver A2Z
A recommendation system that suggests the next problem based on practice history, topic coverage, popularity, and interview relevance
A roadmap covering important DSA patterns
A problem-specific coding workspace
Local drafts and progress tracking
Local execution for JavaScript, Python, Java, and C++

The goal is simple:

Spend less time deciding what to solve and more time actually solving.

Demo

🚀 Live Demo:
https://hacktoberfest-weekend-challenge-build-xnkg.onrender.com

Code

💻 GitHub Repository:
https://github.com/Swetha-Oruganti/Hacktoberfest-Weekend-Challenge--Build-for-a-friend-_AlgoAtlas

How I Built It

I intentionally kept the implementation small: the entire application is built with just two files — index.html and server.js.

The frontend uses HTML, CSS, and Vanilla JavaScript, with browser LocalStorage for local progress and preferences.

The Node.js backend provides the /api/run endpoint and handles local code execution. It creates temporary execution directories, runs the selected language through the appropriate runtime/compiler, captures the output, and removes the temporary files afterward.

AlgoAtlas currently supports:

JavaScript · Python 3 · Java · C++17

For problem-specific practice, the backend can also create language-specific sample-test harnesses around the user's solution.

The application does not submit solutions to LeetCode, Codeforces, CodeChef, or another online judge. The current implementation focuses on local execution and public sample checking.

Why Does Open Innovation Matter?

DSA preparation already has a huge open ecosystem.

There are problem collections, interview-preparation resources, contest archives, roadmaps, GitHub repositories, and community resources spread across different platforms.

I didn't want to rebuild all of that.

I wanted to connect it in a way that makes it easier to navigate.

AlgoAtlas keeps the original source links visible instead of hiding where problems came from. It brings resources such as Blind 75 / Grind 75, NeetCode 150, Striver A2Z, Codeforces, CodeChef, GeeksforGeeks, and community resources into one practice experience.

That is what open innovation means to me here:

Build on the ecosystem that already exists, connect it thoughtfully, and make it more useful for the person using it.

My Agent Session

My Slug-

AlgoAtlas — Hacktoberfest Weekend Challenge: Build for a Friend

You

I want to build AlgoAtlas: a practice platform that connects coding problem sources, recommends a user-selected number of distinct problems based on topic coverage, popularity, and recent company interview reports, and includes authentication and an IDE.

Agent

Planning focused on a single workspace for curated multi-platform practice, a problem-count preference, progress tracking, and an integrated editor.

You

The editor should not be tied to one question. It needs useful language templates, indentation on Enter, and working Tab indentation.

Agent

The editor was adjusted toward generic language starters and automatic indentation. The problem-specific Two Sum starter remains appropriate only when solving that specific problem.

You

Recommendations should prioritize broad topic and pattern coverage, number of attempts, and recent FAANG or popular-company interview reports. Include NeetCode 150, Blind 75, GeeksforGeeks, takeUforward, CodeChef, Codeforces, Reddit reports, and useful repository collections. Avoid duplicate questions while preserving novel patterns.

Agent

The curated catalog uses problem metadata and source collections to support pattern coverage and reduce duplicates. Recommendation metadata can show attempt volume and recent reports when that data is available.

You

For all languages, keep generated comments on one line. Problems without imported examples should not fail with a missing-samples compiler error. I also want the app to submit solutions instead of sending users to another site.

Agent

Shortened generated TODO comments, disabled editor soft wrapping, and added a compile-only fallback when there are no imported sample cases. This confirms syntax but cannot compare expected outputs without a problem-specific test contract. Submission remains unavailable without a supported authenticated judge integration.

Agent

▸ syntax_check Check server and inline JavaScript syntax.

Input

Check server and inline JavaScript syntax.

Output

server.js and the inline script passed node syntax checks. No behavioral test suite was run.

You

If you cannot scrape every problem, show the link to that problem for each entry.

Agent

Added a publisher link beside every problem in Explore and an Open publisher problem link in the IDE. Problems with alternate source entries also show those links in the details.

I used DevRelay as an agent-assisted development workflow while building AlgoAtlas.

My workflow was:

Idea → Planning → Implementation → Debugging → Testing → Refinement

DevRelay helped me work through development tasks and iterations while I remained responsible for the product decisions, implementation, and final integration.

The current AlgoAtlas implementation itself does not contain an AI model or external AI API. The recommendation system is application logic based on practice history, topic coverage, popularity, and interview relevance.

I chose to keep that distinction clear rather than adding an AI API simply for the sake of calling the project AI-powered.

Prize Categories

Hacktoberfest Weekend Challenge — Build for a Friend

Hacktoberfest #Hacktoberfest2026 #BuildForAFriend #OpenSource #DSA #DevTools #JavaScript #NodeJS #WebDevelopment

Download the AlgoAtlas README

This is my First Post

Bhadra Lakshmi Swetha Oruganti — Thu, 01 Oct 2026 10:13:27 +0000

Hi everyone, Great to start my dev journey and share my thoughts about emerging tech world.