DEV Community: Charan Romi

SlothPlan AI: Let a Robotic Sloth Untangle Your To-Do List

Charan Romi — Thu, 22 Oct 2026 08:10:51 +0000

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

What I Built

Sometimes the hardest part of a task list is deciding where to start.

I built SlothPlan AI, a personal planner that turns a messy brain dump into small, manageable steps—with breaks already included.

You can type something like:

Finish the project proposal today, 50 minutes; reply to emails, 15 minutes; book a dentist appointment, 10 minutes.

With hosted Gemma configured, SlothPlan extracts task names, durations, priorities, effort levels, and deadlines. You review and edit those details before anything is saved.

The planner then builds a daily schedule around your available hours and work budget.

Its defining feature is Sloth Mode. Switch it on for:

A smaller daily work budget.

Focus sessions capped at 25 minutes.

Breaks of at least 15 minutes.

Easier, shorter tasks after urgent deadlines.

Tasks that cannot fit remain visible. If an urgent task exceeds your capacity, the app explains the problem instead of quietly hiding it.

It is for anyone who wants to spend less energy organizing their work—especially when their energy is already low.

And yes, there is a sleepy robotic sloth supervising the dashboard.

Demo

Live demo: https://slothplan-ai.vercel.app/

Code

GitHub repository: https://github.com/charan2r/slothplan-ai.git

How I Built It

The stack is:

React + TypeScript + Tailwind CSS for the interface.

Python + FastAPI for the backend.

SQLite for saved tasks, preferences, and schedules.

Hosted Gemma 3 for natural-language task extraction.

Gemma handles the interpretation: turning informal language into structured task data.

Python handles the scheduling constraints: deadlines, priorities, available hours, focus blocks, breaks, and daily capacity. Keeping those rules explicit makes the resulting schedule easier to explain and test.

The provider connection is configurable through environment variables. Credentials stay on the backend.

Model output passes through server-side validation, and users review the extracted tasks before saving. If credentials are missing or the provider fails, the app can offer an explicitly labeled local-rule fallback. Manual task entry also remains available.

Verification included 12 backend tests, 9 frontend tests, and 4 browser tests, alongside a production build and automated accessibility checks. Hosted-provider success and failure cases were tested with mocked HTTP responses.

Why Does Open Innovation Matter?

The useful freedom here is control over the model behind the planner.

Gemma’s open weights make it possible to move from hosted inference to infrastructure I control, experiment with another model, or explore fine-tuning for better task extraction. The application’s UI and scheduling logic can remain the same.

That flexibility matters because people describe their work differently. A student’s study plan, a freelancer’s client tasks, and someone’s household chores may need different interpretations.

There is also an important privacy distinction: saved tasks live in SQLite on the backend machine, but hosted extraction sends the brain dump to the configured provider. This version does not claim fully offline AI inference. Open weights provide a path toward self-hosting when that becomes a requirement.

My favorite part of the project is its small ambition: take the planning overhead off someone’s plate, give them a realistic next step, and leave room for a break.

Sloth speed feels appropriate.

Prize Categories

Best Use of Gemma — Gemma provides the natural-language task extraction at the center of SlothPlan AI.

ReceiptPilot: Turn a Pocket Full of Receipts into Organized Expenses with Gemma

Charan Romi — Mon, 19 Oct 2026 05:52:03 +0000

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

What I Built

Small purchases create surprisingly large amounts of paperwork.

For freelancers and people running a side business, a receipt is easy to collect and easy to forget. Eventually, someone has to type its details into a spreadsheet.

I built ReceiptPilot, a receipt and expense organizer that uses Gemma to turn receipt images and PDFs into editable expense records.

The workflow is straightforward: upload, review, verify, export.

ReceiptPilot can:

Extract merchant, date, currency, subtotal, tax, total, category, and line items.

Accept JPEG, PNG, WebP, and PDF files, including scanned PDFs.

Display the original receipt beside editable fields.

Flag missing information and inconsistent totals.

Search and filter expenses by review status, category, and currency.

Export all saved expenses to CSV.

Detect uploads of the exact same receipt.

Every AI extraction starts as a review. The user checks the original, corrects any mistakes, and explicitly verifies the expense.

My intended customer is a freelancer or solo business owner who wants help organizing expenses without adopting a full accounting platform. The paid opportunity I want to explore is a lightweight tool that reduces repetitive entry and makes handing records to an accountant easier. Willingness to pay still needs validation.

Demo

Demo: https://recipe-pilot-livid.vercel.app/

Code

The source code and setup instructions are available here:

https://github.com/charan2r/recipe-pilot.git

How I Built It

ReceiptPilot uses React, TypeScript, and Vite for the interface; FastAPI and Pydantic for the backend; and SQLite for persistent storage.

The AI component is Gemma, an open-weight model accessed through Google’s hosted API. The backend sends receipt page images with instructions to return structured JSON matching the expense schema.

Before extraction, the app checks file content, prepares images, and renders PDF pages locally. Uploaded images are oriented and resized for the model request.

The extraction prompt asks Gemma to leave uncertain fields empty instead of inventing values. Server validation then checks the returned structure and flags issues such as missing fields or inconsistent subtotal, tax, and total amounts.

A few implementation decisions matter to the everyday workflow:

Human review is required. Successful extraction never automatically verifies an expense.

Currencies stay separate. The dashboard does not combine different currencies into a misleading total.

Credentials stay on the backend. The browser does not receive the provider API key.

Manual entry remains available. Organizing expenses does not depend on model availability.

The current version is a single-user application designed to run on the user’s computer. Expenses and original receipts are stored on the backend’s disk. AI extraction requires an internet connection and sends receipt images to Google after user consent.

The repository includes API, provider-contract, and frontend utility tests. Mocked provider responses check integration behavior; they do not establish live extraction accuracy. Measuring accuracy on varied real receipts is an important next step.

Why Does Open Innovation Matter?

Open-weight AI makes it possible to build a focused product around a model while retaining a path to greater control over inference.

For ReceiptPilot, that matters because receipts vary across merchants, languages, layouts, and currencies. Access to model weights creates possibilities for experimenting with specialized deployment and adaptation as the product develops.

This version uses hosted Gemma to keep the initial setup manageable. It does not yet implement local inference or fine-tuning. Moving inference to infrastructure I control would require additional engineering, but Gemma’s open weights make that a practical direction to investigate.

The application’s review and validation logic is also explicit in the code. I can change how uncertain fields are handled, add checks, and improve the workflow as users reveal where it breaks down.

My goal is a small, useful tool: spend less time copying receipt details, retain the original evidence, and keep the user involved in deciding what is correct.

Prize Categories

Best Use of Gemma — Gemma powers the receipt-to-structured-expense extraction at the center of ReceiptPilot.

Earthly: Less Screen, More Green with Gemma AI 🌿

Charan Romi — Sun, 11 Oct 2026 13:05:59 +0000

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

What I Built

Sometimes the hardest part of going outside is deciding what to do once you get there.

I built Earthly, an outdoor adventure app that turns a little spare time into a personalized nature quest. It’s for anyone who wants a break from their screen without needing to organize a big trip: developers between tasks, students after studying, or someone looking for a different way to explore their neighborhood.

Choose your available time, mood, location, company, and mobility preferences. Earthly asks Gemma to create a short plan with activities that fit those choices.

The experience is designed around getting you moving:

No login required: start planning as a guest.
Personalized quests: choose a peaceful pause, curious exploration, or an energized walk.
One instruction at a time: field mode keeps the next activity easy to read.
Phone-away reminders: prompts encourage you to put the device away between moments.
Nature bingo: notice small details such as clouds, leaves, textures, and sounds.
Text and photo observations: save something interesting and ask Gemma for cautious context.
Optional voice instructions: hear your next step through ElevenLabs.
Adventure journal: revisit your quests and observations afterward.

The completion recap estimates time spent away from the app by subtracting visible app time from elapsed quest time. It’s an estimate, not GPS verification or a measurement of total device screen time.

My goal is simple: make the screen the shortest part of the adventure.

Demo

Live app: https://earthly-roan.vercel.app

A walkthrough follows this journey:

Open Earthly and start without logging in.
Choose a 30-minute adventure and a mood.
Enter a familiar public area or discover nearby places.
Generate a quest and review its steps.
Enter field mode, follow the activities, and mark nature bingo items.
Save an observation and finish with a recap.

Previously saved quest instructions remain available offline. Generating new plans and requesting AI analysis require a connection.

Code

GitHub repository: https://github.com/charan2r/earthly.git

Earthly has a Next.js frontend and a NestJS backend, with MongoDB Atlas storing device profiles, quests, progress, and observations.

How I Built It

Earthly’s core planner is Gemma 4, Google’s open-weight model. The current integration uses gemma-4-26b-a4b-it through the Gemini API.

Gemma generates structured JSON containing a quest title, description, timed steps, and nine nature bingo items. The backend validates that response with Zod, checks that the step durations match the requested time, and applies a conservative filter for risky activity suggestions. Invalid output receives one validation retry.

Gemma also powers text and photo observations. Its instructions emphasize uncertainty, observation from a distance, and avoiding claims about edibility or safe handling.

The supporting stack includes:

Next.js, React, TypeScript, and Tailwind CSS for the interface.
NestJS for request validation, session ownership, and provider integrations.
MongoDB Atlas and Mongoose for persistence.
SerpApi for nearby public-place discovery.
ElevenLabs for optional spoken instructions.
Browser storage and a service worker for saved progress and offline access to the app shell.

Place suggestions are starting points, not verified routes. Users still need to check local access, daylight, weather, and their surroundings.

Why Does Open Innovation Matter?

For Earthly, open innovation means having a path to control how the planner runs and evolves.

Gemma’s available weights make self-hosting, experimentation, and future fine-tuning possible. I can explore adapting the model to produce shorter instructions, more consistent plans, or experiences suited to particular communities.

The backend also separates the planning interface from the provider implementation. It supports Google-hosted inference and an OpenAI-compatible endpoint, giving the project room to experiment with other hosting environments.

A closed API could generate similar plans, but it would not give me access to its underlying model weights for those experiments.

My Agent Session

I used Codex as a development partner to examine the codebase, simplify guest access, and update the app’s branding to Earthly.

Prize Categories

Best Use of Gemma: personalized quest generation and nature-observation insights.
Best Use of MongoDB Atlas: persistent storage for quests, progress, device profiles, and observations.
Best Use of ElevenLabs: optional spoken instructions during an adventure.
Best Use of SerpApi: nearby public-place discovery to help users choose a starting point.

NutriMate: A Gemma-Powered Meal Planner for My Friend

Charan Romi — Mon, 05 Oct 2026 05:56:25 +0000

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

What I Built

I built NutriMate for a friend who wants meals that support their workout routine while keeping food expenses within an affordable budget.

That gave me a concrete problem to work on: turn a fitness goal and a daily budget into practical meals using familiar Sri Lankan ingredients.

NutriMate is a meal-planning app powered by Gemma, Google’s open-weight model. It combines profile information, dietary preferences, budget, and previous meal feedback to generate personalized plans.

The app includes:

Multi-day meal plans with estimated calories, protein, carbohydrates, fat, and cost.
Ingredients and preparation instructions for each meal.
Meal replacements that must fit the rest of the day’s plan.
A grocery list generated from the planned meals.
Meal completion tracking and plan history.
Feedback through ratings, comments, and tags such as “too expensive” or “too spicy.”

Sri Lankan food is central to the experience. The generation prompts emphasize dishes and ingredients such as red rice, dhal, string hoppers, eggs, fish, and local vegetables.

My friend has no special cooking restrictions, so the focus is affordability and workout-related meal planning. The app also supports dietary exclusions and allergy information for users who need them.

Demo

https://drive.google.com/drive/folders/1m9L4f9kfHT88joQW3xmM69XyJY434GFV?usp=drive_link

Code

GitHub repository: https://github.com/charan2r/nutri-mate.git

How I Built It

NutriMate is built as a mobile app for easy usage.

The stack is:

React Native and Expo for the mobile interface.
NestJS and TypeScript for the backend.
PostgreSQL and TypeORM for profiles, plans, meals, and feedback.
Gemma, served through Google’s hosted API, for meal plan and replacement generation.

The generation flow is:

Profile and preferences → Gemma → structured meal data → validation → saved plan and groceries

A major part of the work was deciding what should happen when a model returns incomplete or unsuitable information.

The backend rejects missing meal slots, incomplete nutrition, invalid numbers, unknown catalogue IDs, and missing prices. Each day must meet its calorie target within a 10% tolerance and stay within its budget. Reported calories are also checked against the meal’s macros for plausibility.

When a model selects a reviewed database meal, the backend uses that record’s actual ingredients and nutrition before validating the plan.

Replacement generation is also the same. A proposed swap must fit the complete plan, and saving it updates the meal, totals, validation results, and groceries in one database transaction.

Why Does Open Innovation Matter?

For this project, the value of open weights is the ability to choose how the AI runs as the application develops.

Gemma handles the core generation tasks. Its available weights create a path toward running the model on infrastructure I control and adapting it to a more specific food-planning task. That matters for an application built around personal preferences and regional food knowledge.

I separated inference behind a provider interface, allowing the hosting implementation to change without rebuilding the mobile experience or validation engine.

The current version uses hosted Gemma, so the profile context and feedback included in prompts are sent to Google. Self-hosting and fine-tuning are future possibilities, rather than features demonstrated in this version.

Open innovation also makes the surrounding application easier to inspect and improve. Someone can review the budget rules, contribute better Sri Lankan meal data, improve ingredient matching, or change how feedback influences future plans.

For my friend’s use case, those improvements matter: better local food knowledge and more realistic prices can make a meal plan more useful in everyday life.

Prize Categories

Gemma is the central model for generating meal plans and replacement recipes. The application’s prompts, structured response handling, and validation workflow are built around those tasks.

Render is used to host the backend of the application.