DEV Community: J Sai Vardhan

SlowSort AI — Let AI Handle the File Chaos

J Sai Vardhan — Fri, 23 Oct 2026 18:32:29 +0000

SlowSort AI — Let AI Handle the File Chaos

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

What I Built

Ever opened your Downloads folder and found hundreds of files you meant to organize “later”?

That is the problem I wanted to solve with SlowSort AI.

SlowSort AI is a local-first, privacy-conscious file organization tool that helps turn a messy folder into something manageable. Instead of manually opening files, figuring out what they are, creating folders, renaming documents, and searching for duplicates, you can scan a folder and get an AI-assisted organization plan.

Here is what it does:

Smart organization: Uses Google Gemini to suggest meaningful categories, destination folders, and cleaner filenames.
Review before action: Lets you review, edit, approve, or reject proposed file operations before they happen.
Duplicate detection: Uses SHA-256 content hashes to identify exact duplicate files and estimate wasted storage.
Safer file operations: Prevents path traversal and accidental overwrites, and verifies file integrity before and after moves.
One-click undo: Records completed operations locally so they can be reversed.
Fallback sorting: Includes a deterministic rule-based organizer when AI inference is unavailable.

The idea is simple: spend less time managing files and more time doing the work those files are meant to support.

Demo

Repository: https://github.com/saivardhan1245/slowsort-ai

Live preview: https://slowsort-ai.onrender.com

The application is designed to run locally when working with files on your own computer. A hosted preview does not automatically have access to your computer's filesystem.

Note: The Render build recently encountered an esbuild dependency conflict. Verify the deployment is working before relying on the live-preview link.

Code

Explore the source code, setup instructions, and technical details here:

GitHub: https://github.com/saivardhan1245/slowsort-ai

The project is built with React, TypeScript, Vite, Tailwind CSS, Node.js, Express, SQLite, and Zod. It also includes tests for important filesystem, collision-prevention, and AI-resilience behavior.

How I Built It

I built SlowSort AI around the principle that file organization should be helpful without being destructive.

The frontend provides a reviewable interface for scanning files and inspecting proposed changes. The Node.js backend handles filesystem operations, hashing, validation, and persistence. SQLite stores operation history locally, while Zod validates structured AI responses.

For AI-powered suggestions, I integrated Google Gemini through the open-source @google/genai SDK. The model receives file metadata by default rather than the private contents of documents. Its suggestions are validated before they are presented to the user.

I also added a deterministic rule-based fallback so basic organization suggestions do not depend entirely on an available AI API.

A key engineering decision was to avoid automatic destructive actions. Duplicate files are identified, not automatically deleted. File changes require explicit approval, destination collisions are rejected, and completed operations can be undone.

Why Does Open Innovation Matter?

Open innovation matters because useful tools should be understandable, adaptable, and open to improvement—not just something people can use without knowing how it works.

By building SlowSort AI with open-source libraries and an inspectable codebase, I could combine AI-assisted classification with practical safeguards for real filesystem operations. Developers can study the implementation, test the safety logic, adapt the rules, and contribute improvements.

The project also demonstrates that AI does not need unrestricted access to private data to be useful. File metadata can provide enough context for organization suggestions while the actual file contents remain local by default.

For me, open source is not just about making code available. It is about making the design decisions, limitations, and opportunities for improvement visible to others.

Prize Categories

Add the partner prize categories that are explicitly listed on the challenge page and that SlowSort AI genuinely qualifies for.

SoloBiz AI: Local-First AI for Private, Verifiable Freelancer Finance

J Sai Vardhan — Fri, 16 Oct 2026 12:45:41 +0000

SoloBiz AI — Your Private, AI-Powered Finance Command Center

Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle

What I Built

SoloBiz AI is an open-source, privacy-first financial management platform built for freelancers, independent consultants, and side-hustlers. It brings receipt processing, expense tracking, invoice generation, and AI-powered financial queries into one workspace—without relying on cloud AI for routine financial operations.

The core idea is simple: AI should help freelancers understand their finances, not take control of their data or invent their numbers.

The Problem

Freelancers often spend valuable working hours organizing receipts, extracting figures from PDF invoices, tracking expenses across currencies, and preparing client invoices manually.

Traditional accounting platforms can introduce recurring subscription costs, while cloud-based document processing may require sending sensitive invoices, client information, and vendor details to external services. General-purpose language models also create a risk when users rely on generated answers for financial calculations.

Independent professionals need a tool that combines document intelligence with privacy, transparent verification, and reliable arithmetic.

The Solution

SoloBiz AI turns scattered financial documents into organized, searchable business records.

Key Features

1. Local Receipt OCR and Intelligent Extraction

Upload PDF invoices and receipts for extraction of merchant names, dates, currencies, subtotals, taxes, and totals. The application uses local document-processing tools rather than requiring raw documents to be sent to an external cloud OCR service.

2. Human-in-the-Loop Verification

Review extracted information side by side with the source document. Users can correct uncertain fields before committing information to their financial records, keeping human judgment in the workflow.

3. Multi-Currency Expense Management

Manage financial records in INR (₹), USD ($), EUR (€), GBP (£), CAD, AUD, and JPY. The system preserves currency distinctions instead of incorrectly adding amounts in different currencies without an explicit conversion.

4. Invoice Builder and PDF Generation

Create professional invoices with dynamic line items, automatically calculated subtotals, taxes, and totals. Track invoice status through Draft, Sent, and Paid, then generate downloadable PDF invoices for clients.

5. Record-Grounded Financial Assistant

Ask questions such as “Which invoices are unpaid?” or “What are my expenses by category?” The assistant retrieves relevant database records and cites the underlying expense or invoice IDs. Financial arithmetic is handled by deterministic application logic rather than relying on an LLM to calculate totals.

6. Local AI with an Offline Fallback

SoloBiz AI supports local inference through Ollama with the open-weight Gemma 2 (2B) model. When local inference is unavailable in a hosted environment, the application falls back to offline rule-based processing rather than silently switching to a cloud model.

Demo

Live application: https://solobiz-ai.onrender.com/
GitHub repository: https://github.com/saivardhan1245/solobiz-ai-
License: MIT

To run locally, clone the repository, install the dependencies, and start the development server using the commands documented in the repository.

How I Built It

SoloBiz AI combines open-source document processing, a local AI option, deterministic financial logic, and a lightweight full-stack application.

Frontend

React 19 and TypeScript
Vite and Tailwind CSS
Motion for interface interactions
Lucide icons

Backend and Data

Node.js and Express
SQLite using sql.js and WebAssembly
Automatic disk synchronization for local data
Vite middleware during development and optimized static serving in production

Document Intelligence and AI

Tesseract.js for OCR
pdf-parse for PDF text extraction
Gemma 2 (2B) through Ollama for local inference
A rule-based fallback for environments where local model inference is unavailable

Financial Integrity and Security

Deterministic calculations for invoice totals and taxes
Record-linked assistant responses
Human review before extracted data is committed
Explicit separation of financial amounts by currency
Authentication and access-control mechanisms

The architecture separates document extraction, financial calculations, database operations, and AI-generated explanations. This makes the application easier to test and reduces the risk of treating generated text as authoritative financial data.

Why Open Innovation Matters

Privacy by Design

Invoices and receipts can contain confidential client details, negotiated rates, and tax identifiers. Local processing and open-weight models give users greater control over where their information is handled. The local-first approach is especially useful for freelancers who do not want routine financial documents sent to third-party AI services.

Financial Tools Without Mandatory AI API Costs

Independent professionals should be able to organize expenses and create invoices without depending on paid AI API calls. Open-source components and deterministic processing make it possible to run core workflows locally, subject to the user's hardware and setup.

AI With Verifiable Results

A language model can explain a financial record, but it should not be trusted to invent a total. SoloBiz AI separates language generation from arithmetic and connects answers to underlying records. This makes results easier to inspect and correct.

Accessible and Extensible Software

An MIT-licensed codebase allows developers to inspect, adapt, and extend the project. Freelancers and contributors can build additional workflows without being locked into a proprietary accounting platform.

My First User

I shared SoloBiz AI with an independent freelance UI/UX designer who manages clients across India and the United States.

The feedback highlighted three practical benefits: reducing repetitive invoice entry, recognizing INR and USD without manually converting the amounts, and generating client-ready PDF invoices quickly. The local-first design was also important because the user wanted greater control over confidential financial information.

This feedback reinforced the project's goal: reduce administrative work so freelancers can spend more time on paid work.

What Makes SoloBiz AI Different?

SoloBiz AI is not simply a chatbot placed on top of an expense tracker. It combines document extraction, human verification, deterministic financial calculations, multi-currency records, and database-grounded AI assistance.

Its defining principle is that AI can explain the numbers, but the application must calculate them and let users verify the records.

Challenge Category

Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle

Built to help independent professionals manage the business behind their side hustle—with greater privacy, fewer repetitive tasks, and financial information they can inspect and verify.

What If AI Told You to Close the App? Meet WildQuest

J Sai Vardhan — Sat, 10 Oct 2026 05:35:00 +0000

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

🌿 WildQuest: AI Missions That Get You Outside

What if the best AI interaction was the one that convinced you to close the app?

Most AI applications compete for our attention through endless conversations, notifications, and scrolling. I wanted to build something different: an application that uses AI to get people away from their screens and into the real world.

That's why I built WildQuest — an AI-powered outdoor exploration companion that turns a simple walk into a mission of discovery.

What I Built

WildQuest generates personalized outdoor missions that encourage people to observe nature, explore their surroundings, and become more curious about the world around them.

Instead of giving users another chatbot to spend hours talking to, WildQuest gives them a reason to put their phone away.

🌱 How it works

Generate a Quest: Choose your available time, environment, difficulty, and area of interest to receive an outdoor mission.
Go Outside: Enter Outdoor Mode, featuring a large countdown timer, minimal controls, and nature-inspired audio cues.
Observe the World: Look for biodiversity, investigate natural patterns, explore unfamiliar paths, or practice mindful observation.
Record Discoveries: Return to add field notes or photos about what you observed.
Reflect and Learn: Receive a reflection on your experience and follow your curiosity into future missions.
Build Your Field Passport: Track completed quests, time spent outdoors, discoveries, and exploration progress.

WildQuest also includes a Mystery Quest experience and the ability to turn a real-world discovery into a new mission.

The application is designed around a simple principle:

The best interaction with WildQuest is closing the app and stepping into the wind.

Demo

🌐 Live Application: https://wildquest-81wr.onrender.com/

Try generating a quest, entering Outdoor Mode, and exploring the complete experience.

Code

💻 GitHub Repository: https://github.com/saivardhan1245/WildQuest

The project is built with React, TypeScript, Vite, and Tailwind CSS, with an Express server for backend functionality.

Contributions, feedback, and ideas for making outdoor exploration more engaging are welcome!

How I Built It

I built WildQuest around a provider-based AI architecture so that the application isn't tied to a single model or inference service.

🧠 Open-Weight AI with Gemma

WildQuest integrates Google's open-weight Gemma 2 models through Ollama, targeting gemma2:2b by default, with support for other local models.

The local provider generates outdoor missions and reflections using structured prompts. This makes it possible to run inference on a user's own machine rather than requiring every interaction to go through a hosted AI API.

🌿 An Adaptive Offline Engine

Local models aren't always available, especially when users are outside or working with limited connectivity.

To handle this, I implemented an offline adaptive engine that generates missions using predefined ecological patterns and contextual information. The provider registry can fall back to this engine when the preferred provider fails.

This keeps the core quest experience usable without depending entirely on remote inference.

🔌 Swappable AI Providers

The application includes three provider paths:

Local Gemma: Open-weight model inference through Ollama.
Offline Adaptive Engine: Algorithmic mission generation and reflections.
Gemini Development Provider: An optional server-side provider for comparison and testing.

This architecture lets me experiment with different inference approaches while keeping the user experience consistent.

🛠️ The Tech Stack

Frontend: React, TypeScript, Vite, Tailwind CSS
Backend: Node.js and Express
AI: Google Gemma 2, Ollama, optional Gemini integration
Storage: Browser-based local persistence for user progress and discoveries
Deployment: Render
Development: AI-assisted coding and iterative testing

Why Does Open Innovation Matter?

For a project like WildQuest, open innovation isn't just about having access to a model. It's about having control over how intelligence is used.

Open-weight models make local inference possible. Users can experiment with models on their own hardware, and developers can inspect, replace, and adapt the model layer to suit their applications.

This matters particularly for an outdoor companion.

A user shouldn't need a constant cloud connection just to receive a nature observation mission. By combining local model support with an offline adaptive engine, WildQuest can keep its core experience available even when connectivity is limited.

The provider architecture also makes experimentation easier. I can compare models, adjust prompts, and explore alternative open-weight models without rebuilding the entire application around one proprietary API.

My goal is to make AI a bridge to real-world experiences, not another reason to stay online.

My Agent Session

I used AI-assisted development to help build and iterate on WildQuest's React components, AI provider architecture, and user experience.

Agent session: [Add your DevRelay session link here if you saved one.]

Prize Categories

Primary focus: Open-Source AI / Touch Grass.

Potential additional category: Best Use of Gemma, provided the submission meets the category's requirements and Gemma is meaningfully demonstrated in the project.

Final Thoughts

Building WildQuest challenged me to think about AI product design differently.

Instead of asking, "How can I keep users engaged for longer?", I asked, "How can I help users do something meaningful away from the screen?"

That question shaped the mission-generation flow, the distraction-free Outdoor Mode, the offline fallback, and the focus on genuine user discoveries rather than artificial engagement metrics.

WildQuest is a step toward the kind of AI experience I want to build: useful, adaptable, and designed around life beyond the interface.

Generate a quest. Step outside. Discover something. Come back with a story. 🌿

Hacktoberfest #OpenSourceAI #Gemma #React #AI

StudyMate AI: Your Notes, Your Tutor, Your Study Companion

J Sai Vardhan — Sat, 03 Oct 2026 13:22:51 +0000

StudyMate AI — A Study Companion Built for a Friend Who Was Always Running Out of Time

What I Built

I built StudyMate AI, a personalized AI study companion for a friend who was constantly juggling lectures, assignments, and exams — especially when there was too much material to revise and not enough time.

The problem wasn't a lack of study material. It was not knowing what to study next.

StudyMate turns a student's own lecture PDFs and notes into an interactive study companion.

You can:

Upload lecture notes and PDFs.
Ask questions grounded in your own study material.
Choose different learning modes, including Quick, 2-Mark, 5-Mark, and 10-Mark answers.
Use Teach Me mode to learn concepts step by step.
Generate quizzes and MCQs from uploaded material.
Track performance and identify weak topics.
Generate a personalized study plan.
Use Last-Minute Rescue before an exam to focus revision on important material and weak areas.

The idea was simple:

Instead of giving a student another generic AI chatbot, give them an AI tutor that actually studies their notes with them.

I built it around a real student problem: "I have all my notes, but I don't know what to revise first."

Demo

Live Demo:
https://studymateai-fea9.onrender.com/

Source Code:
https://github.com/saivardhan1245/StudyMateAI

How I Built It

The core of StudyMate is Gemma, Google's open-weight model.

I wanted the project to use an open-weight model as a real part of the application rather than simply wrapping a generic chatbot.

The architecture is:

Student → React + Vite Frontend → Express + TypeScript Backend → PDF Processing → Hybrid Retrieval → Relevant Study Material → Gemma → Grounded Study Response

Grounded Study Chat

When a student asks a question, StudyMate retrieves relevant sections from their uploaded material before generating the response.

The retrieval layer uses:

PDF.js page-level text extraction
256-dimensional normalized feature-hashing embeddings
BM25-style lexical scoring
User-scoped document retrieval
Relevance filtering
Page-level provenance

This allows the application to use the student's own study material as the context for AI-generated answers.

If there are no uploaded documents or no relevant material can be found, StudyMate prevents the normal grounded response flow instead of pretending that the answer came from the student's notes.

Learning Modes

Quick — concise answers for fast revision.

2-Mark / 5-Mark / 10-Mark — answers structured for different academic answer lengths.

Teach Me — explains concepts step by step.

Practice — generates MCQs and tracks performance.

Study Plan — organizes revision based on study material and progress.

Last-Minute Rescue — combines available study material, exam timing, and weak areas into a focused revision session.

Technology

Frontend

React
TypeScript
Vite
Tailwind CSS
Motion

Backend

Node.js
Express
TypeScript
PDF.js
JWT authentication
bcrypt

Gemma open-weight model
Google GenAI SDK

Database

MongoDB Atlas

Deployment

Render

Why Does Open Innovation Matter?

For StudyMate, open innovation isn't just about choosing a different model. It is about having more control over how the AI becomes part of the product.

A closed AI API can provide a powerful general-purpose chatbot, but StudyMate needs something more specific: an AI tutor where the student's own material becomes the foundation for the interaction.

Using an open-weight model such as Gemma gives me the flexibility to build my own retrieval and grounding layer around the model and control how it is used inside the application.

It allows me to:

Choose how the model is integrated into the application.
Build my own retrieval and grounding workflow.
Control the study experience instead of handing the entire experience to a black-box chatbot.
Experiment with different models and inference approaches as the project evolves.
Keep the application architecture independent from a single closed AI provider.

The important part is that Gemma is not just included for the sake of using an open model.

It is part of the actual study-generation workflow. StudyMate retrieves relevant content from the student's documents and provides that context to Gemma to generate the learning response.

That makes the open model part of the product's core architecture rather than an afterthought.

Prize Categories

I am entering the following categories based on technologies actually used in StudyMate:

Best Use of Gemma
Best Use of Render
Best Use of MongoDB Atlas

#devchallenge #weekendchallenge #hf26challenge