DEV Community: Tanmay Patil

LazyDesk AI: A Smarter Way to Organize Documents

Tanmay Patil — Sun, 25 Oct 2026 04:23:51 +0000

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

What I Built

Have you ever downloaded a document, saved it somewhere, and then spent more time searching for it than actually using it?

That was the problem I wanted to tackle with LazyDesk AI — a document organizer designed to make handling everyday files simpler.

LazyDesk AI lets users upload PDF and TXT documents, extract their text, organize and categorize documents, search through their library, review metadata, and download or delete files when needed.

The goal is simple: spend less time managing files and more time doing meaningful work.

Demo

GitHub repository: LazyDesk AI

The repository includes the application source code, setup instructions, sample documents, and tests.

A live hosted demo or video walkthrough is not currently available.

Code

Explore the complete project here:

Tanmaypatil-25/LazyDesk-AI on GitHub

The project uses a React frontend and a Node.js/Express backend, with MongoDB for document metadata and storage-related records.

How I Built It

I built LazyDesk AI using the MERN ecosystem:

React and Vite for the frontend.
Node.js and Express for the backend API.
MongoDB and Mongoose for document metadata.
Multer for handling file uploads.
PDF and text extraction to process supported documents.
Ollama with Gemma 3 1B as the intended local AI integration for document analysis.

One of my goals was to explore how local, open-weight AI could fit into an everyday productivity tool rather than relying entirely on a hosted AI API.

The application also includes safeguards for unsupported files, malformed uploads, filename sanitization, and safe search handling.

During verification, the automated tests and frontend production build passed. I also tested document upload, extraction, metadata updates, search, download, and deletion.

The remaining step is to verify the live Gemma-powered analysis workflow in an environment where Ollama is running.

Why Does Open Innovation Matter?

Open innovation gives developers the opportunity to learn from, experiment with, and build on openly available tools and models.

For a project like LazyDesk AI, local inference is an appealing direction because it can give users more control over where document contents are processed. It also creates an opportunity to experiment with AI-powered organization without making a hosted AI API the core of the design.

Open-source frameworks and community resources made it possible to bring together the frontend, backend, database, and document-processing components into one project.

This project is also a learning experience for me: understanding not just how to connect AI to an application, but how to build the surrounding software responsibly.

The Lazy Payoff

The idea behind LazyDesk AI is to reduce repetitive document-management work.

Instead of manually keeping track of every file, users can work toward a searchable library with useful metadata and a simpler review workflow.

I have verified the core document-management functionality, but I have not yet measured a real-world time saving. The next milestone is to test the complete AI workflow and evaluate how much effort automated categorization and summarization can actually save.

Prize Categories

No partner prize category is claimed in this submission yet.

Built for Hacktoberfest Week 3: Slow and Steady.

Thanks for checking out LazyDesk AI!

ListingLab: Turn Product Details into Marketplace-Ready Listings with Open-Weight AI

Tanmay Patil — Sat, 17 Oct 2026 07:23:55 +0000

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

What I Built

ListingLab is an AI-powered product listing generator designed for independent sellers, small businesses, and people running side hustles.

Writing product descriptions for multiple marketplaces can be repetitive. Sellers need clear titles, useful selling points, detailed descriptions, and search tags — and adapting that content for different platforms takes time.

ListingLab turns basic product details into an editable listing containing:

A product title and short hook
Five key selling points
A detailed product description
Search tags
A social media caption

It supports marketplace-specific generation for platforms such as Shopify, Etsy, Amazon, eBay, and WooCommerce. Users can edit the generated content, copy individual sections, and export the results as Markdown or JSON.

The goal is simple: help sellers spend less time writing listings and more time building their businesses.

Demo

Try ListingLab here:

https://listinglab-lnle.onrender.com/

Code

GitHub repository: https://github.com/Tanmaypatil-25/ListingLab

How I Built It

I built ListingLab as a full-stack TypeScript application.

The frontend uses React, Vite, and Tailwind CSS. The backend uses Node.js, Express, and TypeScript to validate input, construct prompts, communicate with the AI provider, and process generated responses.

The deployed application uses the open-weight openai/gpt-oss-120b model through Groq's API. I also designed the AI integration around a configurable provider adapter, with support for compatible endpoints such as local Ollama.

A key part of the implementation is guiding the model to work from the information supplied by the user instead of inventing product specifications or unsupported claims. Generated content remains editable because AI output should be reviewed before being published to a real marketplace.

Why Does Open Innovation Matter?

For a small seller, access to capable AI should not require building an entire AI system from scratch or committing to one proprietary model forever.

Using an open-weight model gives ListingLab a different path: the underlying model can be accessed through different compatible providers, and the application can be adapted as model availability, hosting options, and costs change. With a compatible local inference setup, sellers or developers can also explore running models on their own hardware.

The deployed demo currently uses Groq-hosted inference, so it still depends on an external service. Local inference is an alternative configuration, not a claim that the live demo runs entirely offline.

For a tool aimed at side hustles, flexibility matters. Keeping the application modular makes it easier to experiment with models and providers without rebuilding the entire product.

What I Learned

Building ListingLab gave me practical experience connecting a frontend to an AI-powered backend, designing prompts for structured outputs, handling provider errors, validating requests, and deploying a full-stack application.

It also reinforced an important lesson: generating text is only one part of an AI product. The workflow around that text — editing, copying, exporting, and making the output useful for a specific audience — matters just as much.

ListingLab is an early version, and there is room to improve marketplace-specific guidance, output quality, and the overall seller workflow.

What's Next?

I'd like to explore feedback from actual sellers, learn which parts of listing creation take them the most time, and use that feedback to decide what to build next.

If you run a small online business, I'd love to hear what you would want a tool like this to handle.

GrassQuest: AI That Invites You to Close the App

Tanmay Patil — Wed, 07 Oct 2026 10:57:43 +0000

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

What I Built

GrassQuest turns a spare moment into a small outdoor adventure. Choose how much time you have, your mood, and your surroundings. Gemma then generates a personalized quest with a mission, a few objectives, and an optional bonus.

I wanted to build something that gives people a reason to step outside without making the activity feel like another productivity task. A neighborhood walk, a campus break, or a quiet moment in a park can be enough.

The key interaction is Touch-Grass Mode. Once a quest starts, the interface becomes a simple timer and reminder to pocket your phone. The active quest survives a refresh, so you can close the app and return later.

Afterwards, you can save a short reflection and an optional photo in your adventure journal. Guests can keep memories locally; signed-in users can access their completed entries across devices.

Demo

Try GrassQuest

You can generate a quest without creating an account. Sign in if you want a cloud journal.

Taking it outside

I tested two quests in real use and found the experience worked well. I also checked generation, completion, and journal persistence. This was a small personal trial, rather than a study of whether the app changes people's habits.

The outdoor experience matters to the concept: the quest should be a short invitation, followed by time spent away from the interface.

Code

GitHub repository

The application source is MIT-licensed and includes local setup instructions, contribution guidelines, and tests.

How I Built It

The interface uses HTML, CSS, and JavaScript, with a Node.js backend deployed on Render.

Gemma 4, accessed through Google's hosted API, creates the quest content. The server sends the selected preferences and requests structured JSON. It validates the response before displaying the mission and objectives. The model is central to the product: it generates the personalized adventure, rather than serving as an extra chatbot.

MongoDB Atlas stores accounts, sessions, and completed journal entries. Passwords are salted and hashed with scrypt. Session cookies are HttpOnly, and journal queries are scoped to the signed-in user. Existing browser memories can be imported explicitly; retries use the same entry IDs to avoid duplicates.

I used Codex to assist with implementation and interface design. The hero landscape is AI-generated. I configured and tested the Google API, Atlas database, GitHub repository, and Render deployment.

All 15 automated tests passed during development. They cover model-response handling, authentication, session expiry, input validation, and account isolation using a database test double. I also verified the live application manually, including journal access from another browser session.

Why Does Open Innovation Matter?

Gemma's open weights make self-hosting and model adaptation possible beyond this hosted version. The application supports an alternative OpenAI-compatible model endpoint, which provides a path to experimenting with another Gemma deployment without redesigning the interface.

The current demo uses a hosted API. I have not tested offline inference or fine-tuning, and using open weights does not make this deployment automatically private or free to run.

For me, the value is having room to inspect, adapt, and eventually host the model behind the experience. The application code is also available for others to modify and contribute to.

Prize Categories

Best Use of Gemma: Gemma generates the personalized outdoor quests.
Best Use of MongoDB Atlas: Atlas provides persistent private journals and account/session storage behind the open-weight-model application.
Best Use of Render — for consideration: Render hosts the Node application, including the interface and server that calls Gemma. Model inference itself runs through Google's API.

What I Would Improve Next

I would add password recovery and email verification, improve rate limiting behind a reverse proxy, and test a local Gemma deployment. Active quest timers currently remain device-local, while completed account entries sync through Atlas.

GrassQuest's main idea is deliberately small: let AI help you choose a reason to go outside, then give the real world your attention.