DEV Community: Rudraksh Karmakar

🦥 SlothDesk AI: Do Less Busywork. Get More of Your Day Back.

Rudraksh Karmakar — Tue, 20 Oct 2026 08:56:41 +0000

What if your computer could take care of the boring digital tasks you keep postponing?

Students accumulate PDFs. Freelancers collect invoices. Developers leave their Downloads folder full of files named final_v2_revised_FINAL.pdf. And somehow, organizing everything becomes another task on an already endless to-do list.

That's why I built SlothDesk AI — a local-first AI productivity assistant designed to help people spend less time managing digital clutter and more time doing what actually matters.

What I Built

SlothDesk AI is a personal productivity agent powered by Google Gemma 3 4B, running locally through Ollama.

It helps users automate repetitive digital tasks, including:

📁 Organize files: Categorize documents and suggest meaningful filenames.
📄 Summarize documents: Extract key information from PDFs and text files.
📅 Extract deadlines: Turn dates and action items found in documents into useful tasks.
✅ Manage tasks: Keep track of priorities, upcoming deadlines, and completed work.
☀️ Generate morning briefings: Summarize your priorities and help you decide what deserves your attention today.
↩️ Review and undo file operations: Preview proposed changes and approve them before files are moved or renamed.

The idea is simple: let the AI handle the tedious parts while the user stays in control.

Demo

VIDEO: https://youtu.be/F4XZCnb-ktQ
SlothDesk AI currently runs locally. The repository includes instructions for setting up the application and running Gemma through Ollama.

To see the application in action, demo video accompanying this post.

Code

Check out the complete source code:

SlothDesk AI on GitHub →

The project includes the backend, frontend, automated tests, documentation, and an MIT license.

Contributions, suggestions, and feedback are welcome!

How I Built It

The application combines a modern web interface with a local AI backend.

Technology stack

AI model: Google Gemma 3 4B Instruct
Inference: Ollama
Backend: Python and FastAPI
Frontend: React, TypeScript, Vite, and Tailwind CSS
Database: SQLite
Document processing: PyMuPDF
Testing: pytest, Vitest, and React Testing Library

Gemma is used for tasks such as document summarization, information extraction, and file-organization proposals. A modular AI provider layer keeps the inference implementation separate from the rest of the application.

The application also uses deterministic fallback logic for selected basic operations when the local model is unavailable. These fallbacks are explicitly distinguished from actual AI-generated results.

Safety was an important part of the implementation. The application validates proposed file operations, prevents unauthorized filesystem access, handles filename collisions, and requires user approval before executing changes.

The reported automated test results are 21 passing backend tests and 5 passing frontend tests.

Why Does Open Innovation Matter?

For SlothDesk AI, open innovation isn't just about choosing a different model. It changes how the product can be used and customized.

1. Your documents can stay on your machine

Documents may contain invoices, academic information, contracts, and other private details. With the local Gemma and Ollama setup, supported AI processing can happen on the user's own computer rather than requiring document contents to be sent to a hosted AI API.

That gives users greater control over their information.

2. No mandatory paid AI API for the core local workflow

The application can use a locally installed open-weight model without paying per request to a commercial inference API.

Of course, local inference still requires hardware and electricity, and downloading or running a model has its own resource costs. But users can avoid usage-based API charges for local inference.

3. The model is replaceable

The AI provider is separated from the application services. This makes it easier to experiment with other compatible models and compare their output, performance, and resource requirements.

The application doesn't have to be permanently tied to a single hosted provider.

4. Users retain more control

Local inference offers more control over where data is processed, which model is used, and how the application behaves.

A closed API can be convenient, but a local-first approach is particularly attractive when privacy, predictable usage costs, and customization matter.

For this project, open-weight AI made it possible to build a practical productivity assistant around local inference rather than making a remote AI service a mandatory dependency.

The Lazy Payoff

The goal is to reduce the small, repetitive tasks that quietly consume a person's day.

Instead of manually opening documents, figuring out their contents, inventing filenames, and copying deadlines into a task manager, a user can let SlothDesk prepare suggestions and review them in one place.

I haven't established a reliable benchmark for the exact number of minutes saved, so I won't invent one. The next step is to compare the time required to complete these tasks manually against the time required with SlothDesk AI.

For now, the payoff is a simpler workflow: less repetitive administration, fewer forgotten details, and more time for the work that matters.

Prize Categories

Gemma — Best Use of Gemma

SlothDesk AI uses Google's open-weight Gemma 3 4B Instruct model through local Ollama inference for its AI-powered productivity workflows.

This is the primary partner category I'm targeting.

Team Credits

Built by @rudraksh_karmakar_28.

Team credit: @harry_92e400f33306e4ba7bb.

Final Thoughts

I built SlothDesk AI around a straightforward idea: AI should not only answer questions. It should also help people get rid of the repetitive work they don't want to do in the first place.

Open-weight models make that vision more accessible by giving developers the freedom to experiment with local inference, build privacy-conscious workflows, and customize how their applications work.

Sometimes the most useful AI isn't the one that does something extraordinary.

It's the one that quietly takes a few annoying tasks off your plate.

SlothDesk AI: Do less busywork. Get more of your day back. 🦥

If you have ideas for making SlothDesk AI more useful, I'd love to hear your feedback!

Repository: https://github.com/rudrakshk25060-csds/slothdesk-ai

SoloBooks AI: A Local-First AI Bookkeeper for Freelancers | Hacktoberfest 2026

Rudraksh Karmakar — Fri, 16 Oct 2026 12:51:25 +0000

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

What I Built

Meet SoloBooks AI — a local-first AI-powered expense and receipt organizer built for freelancers, independent creators, and side hustlers.

When you're running a small side business, keeping track of receipts and expenses can quickly become a tedious task. Receipts get scattered across folders, expense records become disorganized, and preparing information for bookkeeping takes time away from actual work.

I built SoloBooks AI to make this process easier.

What can it do?

🧾 Receipt processing: Upload receipts and extract useful expense information using OCR and AI-assisted processing.
📂 Expense organization: Keep expense records organized in one place.
📊 Expense dashboard: Review recorded expenses and visualize spending.
📄 CSV export: Export expense data for further analysis and bookkeeping workflows.
🤖 Open-weight AI: Use Gemma 3 4B through an Ollama-compatible inference setup.

The goal is simple: help people spend less time organizing financial paperwork and more time building their businesses.

SoloBooks AI is a prototype, not a replacement for professional accounting or tax advice.

Demo

🎥 Watch the demo:

https://youtu.be/v3q1ZUP28O0

The video demonstrates the project and its workflow.

Code

💻 GitHub repository:

https://github.com/rudrakshk25060-csds/solobooks-ai

The repository contains the application code, setup instructions, and tests.

Tech stack

Backend: Python and FastAPI
Database: SQLite
AI: Gemma 3 4B through Ollama-compatible inference
Receipt processing: Tesseract OCR and PDF processing
Frontend: HTML, CSS, and JavaScript
Charts: Chart.js

I wanted to build something practical that combines AI with a real administrative problem faced by freelancers and small businesses.

How I Built It

I built SoloBooks AI using an AI-assisted development workflow and open-source technologies.

The application uses FastAPI for its backend, SQLite for storing expense records, and a lightweight web interface built with HTML, CSS, and JavaScript.

For receipt processing, the application combines OCR and AI-assisted extraction. Gemma 3 4B is used through an Ollama-compatible inference setup to help interpret receipt information.

The application then brings the expense information into an organized workflow where users can review their records, explore spending, and export their data.

I also added automated tests to check important application behavior.

One important design decision was to keep financial calculations in application logic rather than relying on an LLM to perform arithmetic. AI can assist with interpreting unstructured information, while deterministic code handles calculations.

Why Does Open Innovation Matter?

For a tool that handles financial documents, control over data and infrastructure matters.

Using an open-weight model such as Gemma gives developers the option to run inference locally instead of depending entirely on a proprietary, hosted AI API.

For SoloBooks AI, this creates several potential advantages:

More control over data: In a local setup, users can keep their documents and application data on their own machine, subject to the actual configuration.
Greater flexibility: Developers can inspect the surrounding application code and adapt the workflow to their needs.
More control over costs: Local inference can reduce dependence on per-request API pricing, although hardware and electricity still have costs.
Less vendor lock-in: An open model-based architecture gives developers more flexibility to experiment with alternative models and inference setups.

Open innovation also makes it easier for other developers to learn from the implementation, contribute improvements, and adapt the project for different workflows.

Local inference has trade-offs, including hardware requirements and model performance. I see that as part of the engineering challenge rather than something to hide.

My goal is to make useful AI-powered bookkeeping tools more accessible to people who cannot justify expensive software for a small side hustle.

Prize Categories

Best Use of Gemma

Gemma 3 4B is a core part of the AI-assisted receipt-processing workflow, making this project relevant to the Gemma category.

JobiGo — An AI Football Coach That Wants You Off the Screen

Rudraksh Karmakar — Sat, 10 Oct 2026 13:56:24 +0000

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

What I Built

Most AI apps want more of your screen time. I built one that wants less.

JobiGo is an open-source AI football coach built around one simple idea:

The screen should be the shortest part of the experience.

It is designed for football players who want a personalized training session without needing a coach beside them.

The experience follows:

PLAN → GO OUTSIDE → PLAY → RETURN → REPORT → IMPROVE

You start by choosing:

Training duration
Football level
Training goal
Available equipment
Playing environment

JobiGo then uses Gemma 3 4B to generate a structured football mission.

For my test session, it generated a 45-minute Intermediate Cone Dribbling Challenge with a warm-up, cone weave, figure-8 drill, speed dribble, challenge, cooldown, success metric and safety guidance.

Then comes the most important part:

PHONE DOWN. GO PLAY.

The app deliberately gets out of the way and tells the player to leave the screen and complete the session.

When the player returns, they report what actually happened:

Attempts
Successful attempts
Goals
Drills completed
Difficulty
Notes

Gemma then reviews the session and generates:

A performance summary
Strongest area
One thing to improve
A recommendation for the next session

The next session is based on the previous performance instead of simply generating another random workout.

In my test session, I recorded 15 attempts, 7 successful attempts, 2 goals and 3 completed drills. Gemma identified the player's strengths and areas to improve, then recommended another dribbling-focused session based on that performance.

So JobiGo isn't just an AI chatbot that talks about football.

It uses AI to create an action, gets out of the way, and then helps the player improve after the action.

Demo

🎥 Video Demo

Watch the complete JobiGo walkthrough, from generating a personalized football mission to receiving the Gemma-powered session review and next-session recommendation.

I recorded a complete JobiGo walkthrough showing the flow from creating a mission to receiving the Gemma-powered session reflection and next-session recommendation.

The demo covers:

Mission setup → Gemma-generated mission → PHONE DOWN → GO PLAY → session report → Gemma reflection → next-session recommendation.

The recorded demo is attached to this submission.

🌐 Live Demo

JobiGo Live Demo — Render

The public application is deployed on Render.

The verified Gemma inference flow used for this project runs locally through Ollama with Gemma 3 4B.

Code

💻 GitHub Repository

JobiGo — GitHub Repository

The repository contains the complete application, including the FastAPI backend, frontend, AI provider layer, session storage, validation and tests.

How I Built It

The core of JobiGo is Gemma 3 4B, running locally through Ollama.

The main architecture is:

Frontend → FastAPI → AI Provider → Ollama → Gemma 3 4B

Gemma is responsible for three important parts of the experience.

1. Personalized Mission Generation

The player's duration, level, goal, equipment and environment are provided to Gemma.

Gemma generates a structured football mission rather than an unstructured chatbot response.

The output is validated using Pydantic, with validation and correction handling to make sure the generated mission follows the application's expected structure.

2. Session Review

After the player completes the mission, their actual results are submitted back to the application.

Gemma analyzes those results and produces a performance reflection containing:

Performance summary
Strongest area
Area to improve
Actionable recommendation

3. Next-Session Progression

The previous session becomes part of the progression loop.

Instead of starting from zero every time, JobiGo uses the previous performance to recommend what the player should work on next.

For my test session, Gemma identified good control during the cone weave and figure-8 drills, while identifying difficulty in completing the challenge and reaching the desired success metric.

It then recommended another 45-minute dribbling session focused on building those areas.

Technology

JobiGo uses:

Gemma 3 4B — open-weight AI model
Ollama — local inference
FastAPI — backend
Pydantic — structured output validation
SQLite — session history
HTML/CSS/JavaScript — frontend
Render — deployment

The final test suite passed 51/51 tests.

The AI layer is also separated behind provider abstractions, allowing different inference providers to be integrated without rewriting the core application.

Why Does Open Innovation Matter?

Open innovation mattered to JobiGo because I wanted the AI layer to be something I could actually build around, rather than just a black-box API.

With an open-weight model such as Gemma, I can run the core AI experience locally through Ollama and control:

The model
The prompts
Structured output
Validation
The inference environment
How application data flows through the system

This is especially useful for an application involving personal training history and performance.

The local inference path means the verified core experience does not require sending the player's session data to a third-party AI API.

It also makes experimentation much easier. I can change the prompts, validation rules and application logic and immediately test how the model behaves.

For me, that's one of the most interesting things about open AI:

The model becomes something you can build with and experiment around, rather than simply something you send requests to.

And JobiGo uses that openness for a slightly different purpose:

to use AI to get people away from the screen.

Prize Categories

🏆 Overall

JobiGo directly addresses the Touch Grass theme by using AI to encourage physical activity and deliberately minimizing screen time.

The product's core loop is intentionally designed around leaving the screen:

PLAN → GO OUTSIDE → PLAY → RETURN → REPORT → IMPROVE

🧠 Best Use of Gemma

Gemma 3 4B is central to the application.

It powers:

Personalized football mission generation
Structured training plans
Session performance analysis
Next-session recommendations

The product is built around the model rather than simply adding an AI chatbot to an existing application.

☁️ Best Use of Render

JobiGo is deployed on Render as a publicly accessible web application.

The Render deployment provides the public web experience, while the verified Gemma inference flow used for this project runs locally through Ollama.

My Agent Session

JobiGo was developed using an AI-assisted coding workflow. The development process involved using an AI coding agent to help with implementation, debugging, testing, documentation and iterative improvements.

No DevRelay agent session is included because this section is optional.

Final Thought

The goal of JobiGo isn't to keep you in the app.

It's to give you a reason to put the phone down.

Most AI products measure success by how long they can keep you engaged with a screen.

JobiGo measures success differently.

If it takes a couple of minutes to generate a useful training session and then sends someone outside for the next 30–45 minutes, the AI has done its job.

PLAN.

GO OUTSIDE.

PLAY.

RETURN.

REPORT.

IMPROVE.

Then do it again.

Team

This project was built by:

JobiFC: A Finishing Coach Built for My Friend

Rudraksh Karmakar — Sun, 04 Oct 2026 18:20:04 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.

What I Built

I built JobiFC for my friend, Jobi Anand. He told me finishing is the area he especially wants to improve, so I made it the app’s default coaching focus. After trying the finishing drill, Jobi said it fits him.

JobiFC lets him record match stats, review a small performance snapshot, and ask for a practical training suggestion. It is a practice aid, not a player rating or a replacement for his coach.

Demo

Watch the JobiFC walkthrough

The walkthrough shows JobiFC’s finishing focus, a match-stat entry, and a finishing drill from the coach.

Code

JobiFC source on GitHub

How I Built It

The interface uses HTML, CSS, and JavaScript, with a Python FastAPI backend. The backend validates match entries, imports CSV files, calculates the visible stats, and stores match history in a local JSON file.

For coaching, JobiFC sends the question and recent match data to Gemma 3 4B (gemma3:4b) running locally through Ollama. The app checks whether Gemma’s answer follows Jobi’s chosen focus. If it switches to another skill area, JobiFC shows a clearly labeled finishing drill instead.

Why Does Open Innovation Matter?

Running Gemma locally let me build around Jobi’s specific goal without sending his match history to a hosted chatbot API. I can inspect and change the model call, choose where inference happens, and keep the data on the same computer during this demo. Open model tooling made that control practical for a small, personal project.

Prize Categories

Best Use of Gemma — JobiFC uses Gemma 3 4B through Ollama for its coaching flow.