DEV Community: Om Upadhyay

LazyDesk AI: A Local-First AI Assistant for Smarter File Organization

Om Upadhyay — Sun, 25 Oct 2026 17:52:36 +0000

This is my submission for the Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady.

What I Built

Meet LazyDesk AI, a local-first AI-powered file organization assistant designed to make managing files easier, smarter, and safer.

We all accumulate files over time: notes, invoices, documents, reports, and miscellaneous downloads. Organizing them manually takes time, and moving files without checking the consequences can create new problems.

LazyDesk AI aims to simplify this process by scanning an approved workspace, analyzing file metadata, suggesting useful categories, and generating an organization plan for review.

The goal is simple: less time organizing files, more time doing meaningful work.

Privacy and control are central to the design. Metadata analysis is the default, document-content analysis requires explicit permission, and proposed file operations should be reviewed before anything changes.

Instead of blindly letting AI reorganize a user's computer, LazyDesk AI puts the user in control.

Demo

Git hub link : https://github.com/snappyff43-hub/LazyDesk-AI.git
The prototype is being developed and tested locally.

The intended workflow is:

Scan Workspace → Select Files → AI Analysis → Organization Plan → Dry Run → Review and Approve

The interface includes workspace scanning, file selection, AI provider status, analysis controls, and organization-plan review.

Demo video or deployed link: [Add your demo URL here before publishing]

Code

GitHub repository: [Add your LazyDesk AI repository URL here before publishing]

The project is organized around a React frontend and a Python backend, keeping the user interface, AI integration, and filesystem operations separate.

How I Built It

I wanted to build something useful rather than simply wrapping a model in a chat interface.

The project uses:

React + Vite + TypeScript for the frontend.
Python + FastAPI for backend services.
Ollama for local model inference.
Qwen2.5:3B as the open-weight model for local AI experimentation.
Pydantic for validating structured backend data.
Workspace scanning and metadata analysis to provide context for file organization.
Git and automated tests to support incremental development and regression checking.

The architecture prioritizes local processing, with an optional cloud AI integration planned through a backend-only configuration. Cloud processing should require explicit consent rather than silently sending information outside the user's machine.

One of the main engineering challenges is not generating an organization suggestion; it is making sure the suggestion is safe to act on.

That is why the design includes workspace-boundary checks, destination-conflict detection, dry-run previews, approval controls, and execution-journal safeguards.

I am following the Slow and Steady philosophy: build the foundation, test individual components, identify edge cases, and then expand functionality without sacrificing user control.

Why Does Open Innovation Matter?

Open innovation makes AI development more accessible.

A developer should not need an expensive subscription or a permanently available cloud API to start building useful AI-powered software. Open-weight models and local inference give developers the freedom to experiment, learn, adapt systems, and understand how their applications work.

Using Ollama with Qwen2.5:3B lets me explore AI-assisted file organization locally. It also helps me think carefully about privacy, hardware constraints, inference quality, and the trade-offs between local and cloud models.

For a tool that interacts with personal files, these choices matter.

Open innovation also makes experimentation more affordable for students and independent developers. Instead of starting with a large budget, I can start small, test an idea, learn from failures, and improve it incrementally.

The most useful AI is not always the biggest model. Sometimes, it is the model you can run, understand, and control yourself.

The Lazy Payoff

The payoff I am aiming for is less repetitive work and less time spent searching for misplaced files.

As an early target, I would like LazyDesk AI to save 5–10 minutes per small file-cleanup session, depending on the size and messiness of the workspace. This is a goal, not a measured benchmark yet.

More importantly, I want the assistant to make organization easier without making users worry about unexpected file movements or losing control of their documents.

That is the kind of laziness I want to engineer: removing repetitive work while keeping responsibility with the user.

What's Next?

My next priorities are to finish validating the end-to-end workflow, test the AI providers, improve recovery from interrupted operations, and verify that file changes can happen only after safe validation and explicit approval.

I also want to test the prototype with larger synthetic workspaces and document its limitations clearly.

This project is a reminder that useful AI engineering is not only about intelligence. It is also about trust, reliability, and knowing when automation should stop and ask for permission.

Building slowly, testing carefully, and improving one component at a time—that is LazyDesk AI's approach to Slow and Steady.

LocalLedger AI — The Zero-Cloud, Privacy-First Invoice Organizer for Freelancers

Om Upadhyay — Sun, 18 Oct 2026 18:11:27 +0000

What I Built

LocalLedger AI is a privacy-first, zero-cloud invoice and receipt organizer built specifically for freelancers, independent contractors, and solo founders.

The Problem It Solves

Independent operators handle dozens of sensitive invoices, client billing statements, and expense receipts every month. Current options force an unacceptable trade-off:

Cloud Privacy Leaks: Sending sensitive financial records, private client names, hourly billing rates, and home addresses across cloud AI APIs risks customer confidentiality.
Subscription & Per-Token Overhead: Commercial SaaS receipt scanners charge recurring monthly fees or per-page API tolls that penalize solo operators for basic bookkeeping.
Manual Transcription Burnout: Typing dates, invoice IDs, subtotal breakdowns, taxes, and totals into spreadsheets by hand is tedious and error-prone. ### Who Would Pay For It?
Freelancers & Independent Developers: Who bill clients and need clean, categorized expense records for tax write-offs without sending confidential client documents over the internet.
Sole Proprietors & Consultants: Who want a one-click desktop tool that converts messy text or PDFs into spreadsheet-ready CSVs.

- Commercialization / Side Hustle Potential: While the core codebase is open-source, the side hustle offering centers on turnkey setup & customization services ($49–$99 one-time setup assistance for non-technical small business owners, custom vertical category packs, and turnkey desktop binaries).

Demo - "https://drive.google.com/file/d/1uTFPEZ8HfIOu0nSthFHvDq4_QKxQ2hwa/view?usp=drivesdk"

GitHub Repository: https://github.com/snappyff43-hub/Ledger-AI
Live Local Demo Script: Available in DEMO_GUIDE.md ### Key Features Demonstrated:
Multi-Input Ingestion: Accepts pasted text or uploaded text-based PDF/TXT files (with an enforced 5 MB limit).
Deterministic Extraction: Extracts 8 canonical fields (vendor, invoice_number, invoice_date, subtotal, tax, total, currency, category) locally.
Anti-Hallucination: Missing fields evaluate strictly to null / empty rather than being fabricated.
Human-in-the-Loop Review: Pre-filled editable form with arithmetic discrepancy warnings (subtotal + tax != total).
Duplicate Protection: Intercepts repeat scans by (vendor, invoice_number) or (vendor, date, total) to prevent duplicate accounting entries.

6. Safe CSV Export: Exports sanitized records protected against spreadsheet formula injection (`=`, `@`, `+`, `-`).

Code

The complete source code, automated test suite, and architectural documentation are publicly available on GitHub:

snappyff43-hub / Ledger-AI

LocalLedger AI

LocalLedger AI is a privacy-first, on-device invoice and receipt organizer designed for freelancers, independent contractors, and small business owners. It extracts structured financial records from unstructured invoice text and text-based PDFs using an open-weight language model running locally on your computer.

All document parsing, AI inference, and SQLite storage occur entirely on localhost. No financial documents or client details are sent to third-party cloud APIs.

1. Problem Statement & Objective

Freelancers and micro-business operators face significant friction managing business expenses:

Cloud Privacy Risks: Uploading confidential financial documents, client names, hourly rates, and home addresses to public cloud AI tools compromises data sovereignty.
Subscription & Token Overhead: Commercial SaaS receipt scanners charge recurring monthly tiers or per-page API fees, penalizing freelancers for routine bookkeeping.
Manual Data Entry Burden: Manually transcribing dates, invoice numbers, tax breakdowns, and totals into spreadsheets is slow and error-prone.

Objective: Deliver a zero-cloud, reliable…

View on GitHub

Repository Details:

URL: https://github.com/snappyff43-hub/Ledger-AI
Tech Stack: Python 3.11, Streamlit, Ollama, Qwen2.5 3B, SQLite, pypdf.

- License: MIT License.

How I Built It

LocalLedger AI was engineered around open-weight models and a strictly local runtime architecture:

Local Inference Engine (ai_service.py):
- Utilizes Ollama running on http://127.0.0.1:11434 with Qwen2.5 3B (qwen2.5:3b, 4-bit quantized Q4_K_M).
- Uses Ollama's native JSON mode (format: "json", temperature: 0.0) to guarantee deterministic structured responses matching a strict 8-field canonical schema.
In-Memory Document Pipeline (invoice_parser.py):
- Uses pypdf to extract text in memory without saving uploaded files to disk.
- Caps text length at 50,000 characters and file sizes at 5 MB to prevent memory exhaustion.
- Detects scanned image PDFs without a text layer and guides the user to paste text manually.
Local Ledger & Export (database.py):
- Uses Python's built-in sqlite3 (data/ledger.db) with parameterized SQL queries.
- Only confirmed fields, source filenames, and ISO timestamps are saved; raw documents and text are never written to disk.
- CSV export sanitizes every cell to protect against spreadsheet formula execution exploits.
User Interface (app.py):
- Built with Streamlit, featuring a Financial Dashboard, Add & Review Invoice view, and a Searchable Expense History table.
Decoupled Benchmark (compare_models.py):
- A standalone developer evaluation tool comparing local Ollama against optional cloud Gemini on a fixed synthetic invoice without coupling cloud dependencies to the core app.

Why Does Open Innovation Matter?

Open innovation and open-weight models made LocalLedger AI possible in ways proprietary closed APIs fundamentally cannot:
True Data Sovereignty: In financial software, privacy is not a luxury—it is a legal and ethical mandate. Closed APIs require sending private invoices over public networks to third-party datacenters. Open-weight models like Qwen2.5 allow processing 100% on-device with zero data egress.
Zero Marginal Cost for Solo Operators: Closed AI APIs bill per token. If a freelancer processes 300 receipts, a cloud API bill charges them for every page. With open-weight AI, after downloading the model once, the marginal cost per invoice is $0.00.
Offline Reliability: Freelancers often work on trains, flights, or in cafes with unstable Wi-Fi. LocalLedger AI operates completely offline without internet dependencies or cloud API rate limits.

- Hardware Democratization: Thanks to open quantization (`Q4_K_M`), a capable 3.1-billion-parameter model runs comfortably on a standard developer laptop CPU with under 2 GB of RAM.

My Agent Session

The entire project—from environment inspection and schema validation to SQLite persistence, Streamlit UI, duplicate prevention, and automated testing—was developed with an agentic pair programmer.
You can view the full architecture, test documentation, and development milestones directly in the repository:

- User Pilot Research Kit

My First User

To ground the side hustle hypothesis in authentic feedback rather than assumptions, I prepared a comprehensive customer pilot kit:

Pilot Guide & Interview Script: CUSTOMER_PILOT.md
Unpopulated Feedback Log: PILOT_RESULTS_TEMPLATE.md The kit sets up a 5-minute live demonstration using synthetic test receipts, asking neutral questions about existing bookkeeping pain points, reaction to local-only privacy, acceptable processing latency on CPU (~30 seconds), and willingness to pay for a packaged desktop installer or white-glove setup. --- ## Prize Categories
Primary Track: Side Hustle Challenge — Practical AI Tools for Independent Workers

- Open-Source AI Track: Projects built around open-weight models (Qwen2.5 3B via Ollama) with 100% on-device local inference.

Built with ❤️ for freelancers who value their privacy and their time.

Can We Build Smart Mines That Predict Danger Before It Happens?

Om Upadhyay — Tue, 13 Oct 2026 09:29:03 +0000

Can We Build Smart Mines That Predict Danger Before It Happens? ⛏️🤖

Imagine a mining environment where dangerous gases, structural vibrations, and worker emergencies could be detected before they turn into disasters.

As a Computer Science engineering student interested in IoT, cybersecurity, and hardware development, I've been exploring how technology can make industrial environments safer.

💡 The Idea: MineShield

MineShield is a smart mine safety monitoring concept that combines sensors, microcontrollers, and wireless communication to improve underground worker safety.

The goal is to monitor environmental conditions and identify potential hazards in real time.

🔧 How could it work?

Gas monitoring: Sensors measure methane, carbon monoxide, and air-quality indicators.
Environmental monitoring: Temperature and humidity readings help identify changing conditions.
Structural monitoring: Vibration sensors detect unusual movement that may require investigation.
Wireless communication: LoRa modules can transmit sensor data between monitoring devices.
Emergency alerts: The system can notify operators when readings cross configured thresholds.
Data visualization: A dashboard can display sensor readings, trends, and recent safety events.

🚀 What makes this interesting?

Instead of treating every sensor as an isolated component, the idea is to combine multiple signals into one monitoring system.

In the future, anomaly detection could help identify unusual patterns. However, reliable prediction would require validated data, testing, and careful evaluation before real-world deployment.

🧠 What I'm learning

Projects like this help me understand the connection between embedded systems, IoT communication, software development, and cybersecurity.

I'm especially interested in building affordable prototypes that address practical engineering challenges.

🤝 Let's discuss!

What would you add to a smart mine safety system?

Would you focus first on better sensors, reliable wireless communication, predictive analytics, or cybersecurity?

I'd love to learn from your ideas and feedback!

IoT #Hardware #Cybersecurity #Engineering

DEV Community: Om Upadhyay

LazyDesk AI: A Local-First AI Assistant for Smarter File Organization

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

The Lazy Payoff

What's Next?

LocalLedger AI — The Zero-Cloud, Privacy-First Invoice Organizer for Freelancers

What I Built

The Problem It Solves

Demo - "https://drive.google.com/file/d/1uTFPEZ8HfIOu0nSthFHvDq4_QKxQ2hwa/view?usp=drivesdk"

6. Safe CSV Export: Exports sanitized records protected against spreadsheet formula injection (=, @, +, -).

Code

snappyff43-hub / Ledger-AI

LocalLedger AI

1. Problem Statement & Objective

- License: MIT License.

How I Built It

- A standalone developer evaluation tool comparing local Ollama against optional cloud Gemini on a fixed synthetic invoice without coupling cloud dependencies to the core app.

Why Does Open Innovation Matter?

- Hardware Democratization: Thanks to open quantization (Q4_K_M), a capable 3.1-billion-parameter model runs comfortably on a standard developer laptop CPU with under 2 GB of RAM.

My Agent Session

- User Pilot Research Kit

My First User

- Open-Source AI Track: Projects built around open-weight models (Qwen2.5 3B via Ollama) with 100% on-device local inference.

Can We Build Smart Mines That Predict Danger Before It Happens?

Can We Build Smart Mines That Predict Danger Before It Happens? ⛏️🤖

💡 The Idea: MineShield

🔧 How could it work?

🚀 What makes this interesting?

🧠 What I'm learning

🤝 Let's discuss!

IoT #Hardware #Cybersecurity #Engineering

6. Safe CSV Export: Exports sanitized records protected against spreadsheet formula injection (`=`, `@`, `+`, `-`).

- Hardware Democratization: Thanks to open quantization (`Q4_K_M`), a capable 3.1-billion-parameter model runs comfortably on a standard developer laptop CPU with under 2 GB of RAM.