DEV Community: Mehroof Saba

Slothy: A Little Less Doing, A Little More Living

Mehroof Saba — Thu, 22 Oct 2026 15:09:32 +0000

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

What I Built

Some tasks aren't difficult. They just take more energy than they deserve.

Writing a reply to a message you have been putting off. Getting through a long document. Trying to organise a chaotic folder. Attempting to quiet your brain when it has decided bedtime is the perfect time to remember absolutely everything.

I built Slothy for those moments.

Slothy is an AI-powered productivity web app with six small tools designed to take some of the friction out of everyday digital life:

**- Brain Dump - turn a jumble of thoughts into something easier to process.

Lazy Librarian - make long text easier to digest.
Bedtime Brain - help you unload the thoughts occupying your mind when you want to wind down.
Folder Fairy - plan file organisation and prepare a Python script that you can review before running.
Lil Sloth - get the gist of lengthy content without reading every word.
Reply Later - get a starting point for a message when finding the right words feels like work.**

I didn't want to build another productivity app that tells you to wake up earlier, optimise every minute, and somehow squeeze more work into your day.

I wanted to build something that makes doing a little less feel okay.

Demo

Try Slothy - https://slothy-3p2b.onrender.com

Code

The complete project is available on GitHub:
https://github.com/mehroofsaba/Slothy

How I Built It

Slothy uses React and Vite for the frontend, Tailwind CSS for styling, Motion for animations, and Lucide for icons. The backend is built with Python and Flask.

Its AI-powered features use the Gemini API. The application is deployed on Render, with Flask serving the production-built frontend.

One of my priorities was making Slothy feel like a product with its own personality rather than another generic AI dashboard. I spent time on the visual identity, typography, colours, responsive layout, and interactions because the experience around a tool matters just as much as the response it generates.

Getting the production version right also meant making sure the latest frontend build was synced with the Flask backend before deploying it.

To be transparent, Gemini is a hosted model accessed through an API, not an open-weight model. The project uses open-source frameworks, but that alone does not make its AI model open-source.

Why Does Open Innovation Matter?

Open innovation makes it possible to build on existing work instead of starting from zero.

Frameworks such as React, Vite, and Flask gave me a foundation for building and deploying Slothy without having to create an entire web stack myself. Having the application code on GitHub also makes it possible for other developers to inspect the implementation, learn from it, and suggest improvements.

There is an important distinction in this project, though: Slothy currently relies on a hosted Gemini API. It does not yet demonstrate the privacy, offline access, or model-swapping benefits that a local or open-weight AI implementation could provide.

I'd like to explore those possibilities in a future version. An open-weight model could give Slothy more flexibility over how its AI runs and how user data is handled.

For me, open innovation isn't just about using existing tools. It's also about being honest about their limitations and leaving room for other people to build on what you've made.

The Lazy Payoff

I've tested Slothy with real inputs, but I haven't collected reliable timing data yet, so I won't claim a specific number of minutes saved.

The intended payoff is straightforward: less time wrestling with a wall of text, less effort getting a message started, and a clearer starting point for tasks you keep postponing.

I'd rather make a small task easier than promise that an app will transform someone's entire life.

Sometimes, a little less friction is enough.

A little less doing. A little more living.

Bizcuits: A Smarter Workspace for Small Business Owners.

Mehroof Saba — Sun, 18 Oct 2026 16:44:09 +0000

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

What I Built

Meet Bizcuits - an AI-assisted business workspace built for small sellers who are trying to grow their side hustles without getting buried under the little things that come with running a business.

Running a small business means juggling products, records, numbers, and decisions, often without having a whole team to help. I wanted to build something that brings business management and AI assistance together in one place, making it easier for sellers to understand their business and spend more time growing it.

Bizcuits combines a React frontend with a Python backend, data analysis using Pandas, and a PostgreSQL-ready database setup. The goal is to make useful business tools more accessible to people who are building something of their own.

I didn't want AI to be just another chatbot sitting beside a dashboard. I wanted it to be part of a workspace designed around an actual problem: running a small business.

Demo

Live application: https://bizcuits.onrender.com

The application is deployed on Render, with Neon PostgreSQL configured as its hosted database.

Code

GitHub repository: https://github.com/mehroofsaba/Bizcuits

The project includes the React + Vite frontend, Python backend, dependency files, and Render deployment configuration.

Feel free to explore the repository, check out the implementation, and contribute ideas or improvements!

How I Built It

Bizcuits is built with:

React + Vite for the frontend.
Python + Flask for the backend.
Pandas for data analysis.
PostgreSQL for hosted database storage, using Neon.
Gemma 3 27B as the configured AI model, with a backend setup designed to support hosted inference through Google AI Studio or local inference through Ollama.
Render for deployment.

One of the most exciting parts of building this project was taking it beyond my local machine. I had to work through Git, environment variables, deployment configuration, and database connectivity to get Bizcuits online.

I also learned to work with PostgreSQL during deployment. Before this project, I hadn't worked with it, so setting up Neon and connecting it to Render became part of the learning experience.

The result is a deployed application that I can continue improving, testing, and developing into something useful for real small-business owners.

Why Does Open Innovation Matter?

For a project like Bizcuits, open innovation means having more freedom over how AI fits into the application.

Using an open-weight model such as Gemma gives developers more flexibility than building around a single closed model provider. With a compatible inference setup, a model can be run locally through tools such as Ollama, giving developers more control over their deployment environment and data flow. Hosted inference can also make experimentation easier without requiring everyone to run a large model on their own hardware.

That flexibility matters when building tools for small businesses. I want Bizcuits to be adaptable rather than permanently tied to one particular AI service.

Open-source projects also make it possible for other developers to inspect the implementation, suggest improvements, and build on what already exists. A project becomes more valuable when it can grow beyond the person who started it.

For me, that's what makes open innovation exciting: you get to learn by building, share what you learn, and give other people something they can improve.

Prize Categories

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

I built an AI that wants me to stop using it.

Mehroof Saba — Fri, 09 Oct 2026 15:02:24 +0000

WHAT I BUILT

Okay so hear me out!!

We spend so much time staring at screens that we literally need apps to remind us that the world exists outside them and naturally, my response to this problem was to build another app.

Meet DETOUR.

DETOUR is an open-AI-powered adventure engine that gives you tiny real-world missions based on your mood, how much time you have, the weather, and the kind of adventure you're in the mood for.

You could have 10 minutes or two hours. You could be bored, curious, tired, restless, or just feeling a little chaotic. DETOUR takes that and turns it into an excuse to get out of your room and actually do something.

Not a workout plan. Not another productivity tracker telling you that you're behind in life and definitely not another app asking you to maintain a 47-day streak.

Just a tiny adventure.

For example, DETOUR might tell you to:

Find something yellow that you would normally walk straight past.
Take a different route home and notice three things you've never paid attention to.
Find something that looks completely out of place, then walk another 200 steps.
Go outside with a friend and let everyone pick a direction.

But there's more to it than just generating quests.

DETOUR gives your adventures a little progression system, with stats like Exploration, Curiosity, Observation, Courage, and Chaos. Apparently, even going outside needed character development.

Field Notes lets you record what you discover, write little reflections, and save your adventures.

The 1 KM Museum turns the ordinary things around you into a personal collection of discoveries.

And then there's Birdbrain, which helps you investigate the little things you encounter outside. Instead of immediately naming something, it gives you clues about what to observe.

The whole idea is to make the world around you feel a little less ordinary.

Because honestly, when was the last time you went outside without having a particular destination, deadline, or reason?

DETOUR is for people who want to explore their surroundings, people who get bored easily, people who need an excuse to leave their rooms, and anyone who wants to make an ordinary Tuesday slightly less ordinary.

The screen is not the product.

The adventure is.

DEMO

DETOUR is live.

You can go bother it here: https://detour-xqfa.onrender.com/

The app is hosted on Render's free plan, so it might need a little time to wake up if it has been inactive.

CODE

The code lives here: https://github.com/mehroofsaba/Detour

Feel free to explore the code, report bugs, suggest improvements, or contribute if something catches your eye.

HOW I BUILT IT

The tech stack is pretty straightforward, but getting the pieces to work together was the interesting part.

Frontend: HTML, CSS, and JavaScript.
Backend: Python and Flask.
Database: SQLite.
AI: Gemma through Ollama, with a procedural fallback when the model isn't available.
Deployment: Render with Gunicorn.

I wanted the interface to feel like a little field journal rather than another generic AI dashboard. Think warm paper, botanical details, handwritten accents, and the sort of thing you'd want to keep open while planning your next tiny adventure.

The AI side was particularly important because I wanted to experiment with an open-weight model locally, while still making sure the deployed application worked when that model wasn't available.

DETOUR uses Gemma to generate missions that consider the user's available time, mood, weather, and other context. The prompt is designed to make the missions specific, a little strange, and safe. It avoids suggestions involving trespassing, driving, or unnecessary purchases, and rainy weather changes the kind of adventures it suggests.

I also built a procedural fallback so that the application can still generate missions when an Ollama model isn't available.

That mattered for deployment because Render's free web service doesn't run my local Ollama installation. The deployed app can use its fallback instead of pretending a local model is magically available in the cloud.

There is still plenty I'd like to improve, but I wanted a working application that people could actually try rather than a beautiful mockup with a very ambitious README.

WHY DOES OPEN INNOVATION MATTER?

This project is a big part of why I wanted to experiment with open-weight AI in the first place.

I didn't want AI to be just a mysterious API call hidden behind a button. I wanted to understand how the model fits into the application, how the prompts shape its behaviour, what happens when the model isn't available, and how much of the experience I can build and control myself.

Using Gemma through Ollama gave me a way to experiment with model-powered mission generation while keeping the rest of the application under my control.

And I think that's especially interesting for a project like DETOUR.

The point isn't to make people dependent on an AI that keeps them engaged with a screen. The point is to use AI to create a reason to leave that screen.

Open models make that kind of experimentation more accessible. You can build around them, inspect how your application uses them, experiment with prompts, and design fallbacks instead of treating a hosted model as the entire product.

For me, open innovation means being able to take an idea that sounds a little ridiculous, get my hands dirty, and actually build something with it.

Sometimes that something tells you to go outside.

PRIZE CATEGORIES

Open-Source AI / Touch Grass

DETOUR explores how an open-weight model can power real-world adventure generation. I use Gemma through Ollama for local mission generation, with a procedural fallback that keeps the deployed application usable when the model isn't available. The idea is to use AI to encourage people to explore the world around them instead of spending even more time on a screen.

Floof - A tiny study buddy for your very questionable academic decisions.

Mehroof Saba — Mon, 05 Oct 2026 06:46:51 +0000

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

I made Floof for a friend, because she kept having the same problem: too many things to do, no idea where to start, and somehow making a schedule became another thing she had to procrastinate on.

And apparently telling her to “just make a schedule” is not actually a solution when her brain has already decided to open seventeen tabs and stare at all of them.

Floof is a small study and planning companion that tries to make getting things done feel a little less miserable.

It has tasks, projects, exams, assignments, goals, notes, a calendar, a focus timer, and a tiny mascot that sits there judging you very gently.

The idea was not to build another productivity dashboard that screams at you about your "daily efficiency."

I wanted something that felt more like a friend sitting beside you saying:

"okay. we have two hours. breathe. what actually needs to happen?"

And that is where Floof's AI comes in.

What I Built

Floof gives you one place to dump all the academic chaos that is usually scattered across notes, calendars, random screenshots, and the part of your brain that says “I'll remember this” and absolutely does not.

You can add tasks, projects, exams, assignments and goals, keep notes, check your calendar, and use the focus timer when you actually decide to start.

There is also Ask Floof, where you can tell it what is on your plate and how much time you have.

Instead of giving you some terrifying productivity lecture, Floof is meant to help turn that mess into something you can realistically deal with.

It can be as simple as:

I have 2 hours and 3 subjects. What should I do?

and Floof can help you figure out where to start.

The mascot is there because I wanted the app to have a personality.

Demo

Demo Link: https://drive.google.com/file/d/1arq6sKI3Hgd9Mi0PuD-x1DQxxExYllkM/view?usp=sharing

I also included screenshots in the repository because Floof is much easier to understand when you can actually see the little creature sitting there.

Code

GitHub: https://github.com/mehroofsaba/Floof

The repository contains the React frontend, Express backend, database setup, configuration, and the screenshots used for the project write-up.

I also made sure the API keys and local database stay out of the repository.

How I Built It

Floof is built with React and Vite on the frontend, with an Express/Node.js backend handling the application logic and data.

I used SQLite for the local application data and built the interface around a deliberately soft pastel visual system instead of the usual productivity-app grey-on-white situation.

The AI companion uses Gemma, Google's open-weight model, which is what makes the “Ask Floof” part of the app possible.

The fun part was actually getting the AI to feel like Floof instead of just dropping a generic chatbot into a pretty interface.

The responses need to feel like they belong to the same little world as the rest of the app.

That meant giving Floof a personality, keeping its advice practical, and making the interface around it feel like a companion rather than a support ticket.

Why Does Open Innovation Matter?

This was probably the part of the challenge that made the most sense for Floof.

I did not want the AI to just be a mysterious box that I send text to and get text back from.

Using an open-weight model like Gemma gives me much more room to experiment with how the model behaves, how it is integrated, and what kind of companion Floof can eventually become.

It also makes the project much more interesting to build on.

Floof could eventually have a local version, a different model, a more specialised study personality, or completely different ways of handling someone's data without having to redesign the entire application around one closed system.

For a personal tool, that flexibility matters.

Especially when the whole point is to build something for a real person rather than build another generic AI wrapper.

Prize Categories

Best Use of Gemma

And that's Floof.

It started with a very simple thought:

what if studying had a tiny creature attached to it?

So now there is a tiny creature attached to it.

And apparently the creature has opinions.