DEV Community: Gourav Chhatwani

TinySteps AI: Building an AI-Powered Task Roadmap Generator with Local Google Gemma, Streamlit, and Full CI/CD

Gourav Chhatwani — Wed, 21 Oct 2026 10:25:06 +0000

⚡ TinySteps AI: Building an AI-Powered Task Roadmap Generator with Local Google Gemma, Streamlit, and Full CI/CD

Hey everyone! 👋

For Week 3 of Hacktoberfest, I decided to tackle a problem I deal with almost every single day: jumping into a big, intimidating project—like building an ML pipeline from scratch or setting up microservices—and feeling completely paralyzed by where to start.

To solve that, I built TinySteps AI. It’s a tool that takes any complex software or ML engineering objective and breaks it down into structured, realistic, energy-aware phases you can actually execute without burning out.

Check out the full walkthrough video below to see it generating roadmaps in real-time and triggering our automated deployment pipeline:

🎯 What Does TinySteps AI Do?

Instead of just spitting out a generic checklist, TinySteps AI adapts to your real-world setup:

Energy-Aware Planning: Select your current energy level (Low, Medium, or High) along with your available time budget (10 to 240 mins). The engine dynamically adjusts phase durations and depth so you don't overcommit when you're tired.
Interactive Streamlit Frontend: Clean, fast dashboard built with Streamlit for tweaking inputs and viewing instant execution blueprints.
Dual-Backend AI Engine:
- Local Inference (Google Gemma): Runs gemma3:4b locally via Ollama. It keeps your code ideas completely private, works offline, and costs $0.
- Cloud Fallback (OpenRouter): Integrates free cloud endpoints so the app stays functional anywhere.

🏗️ Under the Hood: Full CI/CD & Production Setup

I wanted this to be a production-ready application rather than just a local script, so I packed in several devops and pipeline features:

Automated Testing: Unit test suite using pytest verifying engine fallback logic, step sizing, and key mapping.
GitHub Actions CI/CD: Runs automated tests on every push to main, builds a Docker container, and publishes the image directly to the GitHub Container Registry (GHCR).
Live Render Deployment: Connected to our registry hooks on Render for automated continuous deployment with zero downtime.

🔗 Public Links & Proofs

Everything is 100% open-source and publicly accessible without any auth walls:

🌐 Live App on Render: https://slothsort-ai-latest.onrender.com
💻 GitHub Repository: https://github.com/GouravGC/tinysteps-ai
⚙️ GitHub Actions (CI/CD Runs): Pipeline Activity
📦 GitHub Container Registry: Published Packages

🚀 Running it Locally

If you want to spin it up on your local machine with Google Gemma:


bash
# 1. Clone & install
git clone [https://github.com/GouravGC/tinysteps-ai.git](https://github.com/GouravGC/tinysteps-ai.git)
cd tinysteps-ai
pip install -r requirements.txt

# 2. Start local Ollama model (Google Gemma)
ollama run gemma3:4b

# 3. Launch Streamlit UI
python -m streamlit run app.py

I Built GraphSleuth AI with FalkorDB for Graph Hacks — Here's What I Learned

Gourav Chhatwani — Sun, 18 Oct 2026 18:23:25 +0000

Why I built this

For Graph Hacks: Context for AI Agents, I wanted to build something practical around graph databases instead of just reading about them. I decided to try a cybersecurity investigation tool because investigating suspicious activity often means connecting the dots between accounts, devices, servers, and alerts.

That's how GraphSleuth AI came together.

GitHub: https://github.com/GouravGC/GraphSleuth-AI

What does it do?

Imagine you're looking into a suspicious user account. You might want to know which device it accessed, which server that device connected to, and whether any security alerts are related.

Looking at those details separately doesn't always make the bigger picture obvious. GraphSleuth AI lets you explore these connections through a graph.

I built the prototype with Python, Streamlit, and FalkorDB. The application uses Cypher queries to trace account-to-device-to-server paths, connect relevant alerts, and display the evidence found in the graph.

The project currently uses synthetic cybersecurity data, so it's a prototype rather than a tool intended for real security investigations.

Where FalkorDB fits in

FalkorDB isn't just there to draw a graph. It's the database behind the investigation logic.

I represent entities such as accounts, devices, servers, and alerts as nodes, with relationships connecting them. Then I use Cypher queries to follow those relationships and retrieve connected evidence.

That was the interesting part for me: instead of looking at each record in isolation, I could explore how several entities were connected through multiple steps.

The tech stack

Here's what I used:

Python for the application logic
FalkorDB for storing and querying the graph
Cypher for traversing relationships
Streamlit for the interface
Docker Compose to run FalkorDB locally

I kept the setup local and documented the steps in the repository README.

A few things I learned

One thing that stood out to me was how much the graph model matters. You need to think about which entities belong in the graph and what their relationships actually mean. Otherwise, even a working query won't give you useful investigation results.

I also got a practical reminder that running an app locally and deploying it to the cloud are different challenges. If the database is running on your own machine, a cloud-hosted interface can't automatically connect to it.

There is still plenty I'd like to improve, including adding more investigation scenarios, expanding the tests, and eventually exploring a proper remote deployment.

What's next?

GraphSleuth AI is an early prototype, and I don't want to present it as a finished cybersecurity product. For now, it demonstrates one idea: graph relationships can help make investigation paths easier to follow and explain.

If you'd like to explore the code, here's the repository:

https://github.com/GouravGC/GraphSleuth-AI

This was my project for Graph Hacks: Context for AI Agents, organized by WeMakeDevs and FalkorDB. Building it gave me a more practical understanding of how graph databases can be used beyond simple visualization.

FreelanceFlow AI: Generate Client Proposals with Open-Weight AI

Gourav Chhatwani — Sat, 17 Oct 2026 10:38:57 +0000

Demo

Watch the project walkthrough:

Try FreelanceFlow AI: https://freelanceflow-ai-2du9.onrender.com/

Source code: https://github.com/GouravGC/freelanceflow-ai

Project evidence and screenshots: https://github.com/GouravGC/freelanceflow-ai/tree/main/evidences

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

What I Built

Freelancers often spend valuable time converting client requirements into clear, professional project proposals. FreelanceFlow AI helps simplify that process.

I built FreelanceFlow AI, an AI-powered proposal generator for freelancers, independent consultants, and small service businesses.

Users enter a client name, project brief, hourly rate, and estimated hours. The application generates a structured proposal with a title, summary, requirements, assumptions, deliverables, exclusions, milestones, risks, and a client email. It also calculates the estimated project cost and supports downloading the proposal as JSON.

For example, a freelancer can enter the requirements for an e-commerce website and generate a proposal with a cost estimate and a clear breakdown of the work.

The people most likely to benefit are freelance developers, designers, consultants, and agencies that repeatedly prepare client proposals. It could be useful as a time-saving tool for people who want to spend less time on repetitive writing and more time delivering client work.

Demo

Live application:

https://freelanceflow-ai-2du9.onrender.com/

Project evidence and screenshots:

https://github.com/GouravGC/freelanceflow-ai/tree/main/evidences

Code

GitHub repository:

https://github.com/GouravGC/freelanceflow-ai

The project uses a modular Python structure, automated tests, Docker, and GitHub Actions. The repository includes the application source code, tests, configuration examples, and documentation.

How I Built It

I built FreelanceFlow AI using Python and Streamlit, with a modular structure to keep the application organized and maintainable.

The project supports two AI generation options:

Google Gemma through Ollama: A local inference option that runs an open-weight model on compatible hardware.
OpenRouter: A cloud-based option for AI-powered proposal generation.

The application takes the user's project requirements and pricing details, calculates the estimated cost, and generates a structured proposal. Pydantic supports data validation, while pytest covers the pricing logic, decimal rates, and invalid input values.

I also added Docker support and a GitHub Actions workflow for automated testing and container publishing. The web application is deployed on Render.

This project brought together AI integration, modular Python development, testing, containerization, and deployment in one practical application.

Why Does Open Innovation Matter?

Freelancers may work with client briefs, budgets, and business requirements that they do not want to send to an external AI service unnecessarily.

By supporting local inference through Gemma and Ollama, FreelanceFlow AI gives users an alternative to sending every generation request to a hosted AI provider. When generation runs locally, the prompt can be processed on the user's own machine, subject to the local setup and model requirements.

Open-weight models also provide more flexibility to experiment with model choices and deployment approaches instead of depending entirely on one hosted provider. The cloud option remains available when convenience is more important.

For a side hustle, these choices matter. Freelancers need tools that fit their budgets, workflows, hardware, and client confidentiality requirements. Open-weight AI makes it possible to explore a more flexible approach to building those tools.

Prize Categories

Best Use of Gemma

FreelanceFlow AI integrates Google's Gemma open-weight model through Ollama for local proposal generation.

Best Use of Render

The Streamlit application is deployed on Render and accessible through a live web application. I am entering this category based on its use for hosting the application's frontend.

Final Thoughts

FreelanceFlow AI began with a straightforward goal: make client proposal writing faster and more

🌿 Walk & Notice — AI That Gets You Off the Screen

Gourav Chhatwani — Sat, 10 Oct 2026 13:35:19 +0000

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

What I Built

🌿 Walk & Notice

AI should help you leave the screen — not keep you on it.

For Hacktoberfest Week 1, I built Walk & Notice, an AI-powered outdoor observation mission generator built around one simple idea:

The AI interaction should end when the real-world experience begins.

Instead of creating another chatbot that encourages people to spend more time on their phones, Walk & Notice uses AI to create a short, personalized outdoor mission — and then tells the user to put the phone away.

The project has a proper Streamlit frontend where users configure the experience before generating their mission.

The interface lets users choose:

🤖 AI provider
⏱️ Available time
🌳 Outdoor environment
🔎 What they want to notice
⚡ Energy level

The application turns those choices into a short four-step observation mission.

Every mission ends with:

Now put your phone away.

The idea is intentionally simple:

Generate it. Read it. Go outside. Notice something.

The screen is supposed to be the shortest part of the experience.

Demo

GitHub may not preview the video directly because of its file size. The original high-quality video is available for download.

🔄 Alternative Video Download

Download the demo from JioCloud

Alternative download option if the GitHub file is inconvenient to access.

📸 Evidence

View screenshots and supporting evidence

Code

💻 GitHub Repository

View Walk & Notice on GitHub

The repository contains the complete implementation, including:

Streamlit frontend
AI provider abstraction
Gemma 4 E4B + Ollama integration
OpenRouter integration
Prompt engineering
Automated tests
Docker configuration
GitHub Actions CI/CD
GitHub Container Registry publishing
Render deployment
Documentation
Demo and supporting evidence

How I Built It

I wanted the AI to be part of the solution without making the AI interaction itself the main experience.

The project therefore has two AI inference paths: a local open-weight path for development and a production path through OpenRouter.

🦙 Local AI — Gemma 4 E4B + Ollama

During development, I run Gemma 4 E4B locally through Ollama.

The local architecture is:

Streamlit
    ↓
Python
    ↓
Ollama
    ↓
Gemma 4 E4B
    ↓
Outdoor Mission

This allows the application to generate missions locally using an open-weight model.

The local model runs on my RTX 3060, allowing me to develop and test the core AI experience without requiring a hosted AI API.

☁️ Production AI — OpenRouter

For the public deployment, I added a second provider using OpenRouter with:

openai/gpt-oss-20b

The application keeps the AI provider behind the same Python interface, allowing the frontend and mission-generation logic to work with different inference providers.

The overall application flow is:

                     Streamlit Frontend
                           │
              ┌────────────┴────────────┐
              ↓                         ↓
       Local AI Provider        Production Provider
              ↓                         ↓
       Gemma 4 E4B                 OpenRouter
              ↓                         ↓
           Ollama                  GPT-OSS-20B
              └────────────┬────────────┘
                           ↓
                  Personalized Mission
                           ↓
                  "Put your phone away."
                           ↓
                         🌳 Outdoors

🎨 Streamlit Frontend

Rather than asking users to interact directly with an LLM, I built a proper Streamlit frontend around the model.

The interface collects structured preferences and passes them to the mission generator.

This turns the project from a raw model experiment into a small usable application.

The frontend controls the experience.

The model handles the generation.

And then the user leaves the screen.

🧠 Prompt Engineering

The mission generator is intentionally constrained.

The model is instructed to:

Generate exactly four numbered steps
Keep each step short
Match the user's selected preferences
Create safe outdoor activities
Require no special equipment
Avoid interacting with wildlife
Avoid traffic and dangerous locations
Avoid requiring a phone, camera, or recording

The final instruction is always:

Now put your phone away.

The goal isn't to generate a long AI response.

The goal is to generate something useful enough to read quickly and then act on in the real world.

🛡️ Safety by Design

Because Walk & Notice encourages people to go outdoors, safety is built into the generation instructions.

The model is explicitly prevented from creating missions involving things such as:

Traffic
Approaching wildlife
Dangerous climbing
Dangerous objects
Unsafe locations
Required equipment
Recording or photographing

The activities are designed around observation rather than risky physical challenges.

🧪 Automated Testing

I added automated tests for both AI provider paths:

Ollama generation
OpenRouter generation

The local test suite currently passes:

2 passed

These tests are also executed automatically through GitHub Actions before the production image is built.

🐳 Docker

The application is containerized with Docker.

The production image is published to GitHub Container Registry:

ghcr.io/gouravgc/walk-and-notice:latest

This provides a reproducible production artifact that can be deployed without manually configuring the application environment.

⚙️ GitHub Actions CI/CD

I built an automated GitHub Actions pipeline for testing and container delivery.

The workflow is:

GitHub Push
     ↓
Run pytest
     ↓
Build Docker Image
     ↓
Push Image to GHCR
     ↓
Render
     ↓
Production Application

View the successful GitHub Actions workflow

This means a code change can move through testing and container publishing automatically instead of requiring a manual Docker build and registry push.

🚀 Render Deployment

The production application runs on Render using the Docker image published to GHCR.

Open the production application

This takes Walk & Notice beyond a local prototype and gives the project a publicly accessible production deployment.

Why Does Open Innovation Matter?

Open innovation matters to Walk & Notice because the AI itself is part of the project's philosophy.

The application was built around an open-weight model that can run locally.

With Gemma 4 E4B and Ollama, I can run the AI on my own hardware, experiment with prompts, change the model configuration, and develop the application without making a proprietary hosted API the only way the system can work.

That is particularly relevant to this project.

Walk & Notice is designed to reduce unnecessary screen time.

A local inference path means the core mission-generation experience can work without sending every development interaction to a remote AI provider.

It also gives me more control over experimentation.

I can:

Run the model locally
Modify the prompts
Experiment with the model
Change the application's behavior
Keep the core AI workflow under my control

The production deployment adds an OpenRouter path for public access, but the application architecture still keeps local open-weight inference as a first-class option.

For me, that is where open innovation fits this project best:

The AI can be experimented with locally, while the experience itself is designed to get the user away from the screen.

Prize Categories

I am entering the following partner categories:

🟢 Best Use of Gemma

Walk & Notice uses Gemma 4 E4B locally through Ollama as one of its AI providers.

Gemma is directly responsible for generating the personalized outdoor observation missions.

🟠 Best Use of Render

The production version of Walk & Notice is deployed on Render using the Docker image published to GitHub Container Registry.

Open the production application

🟣 Best Use of GitHub Copilot

Walk & Notice uses GitHub Actions to automate its software delivery workflow.

The pipeline automatically runs tests, builds the Docker image, and publishes the production image to GHCR.

This uses the GitHub Actions automation route explicitly listed in the challenge's Best Use of GitHub Copilot category.

🌍 The Idea Behind Walk & Notice

The easiest thing for an AI application to do is give us another reason to stay online.

I wanted to build something different.

Walk & Notice uses AI to create the starting point for a real-world experience — and then gets out of the way.

The AI generates the mission.

You do the walking.

You do the noticing.

The real world does the rest.

🌿

DEV Community: Gourav Chhatwani

TinySteps AI: Building an AI-Powered Task Roadmap Generator with Local Google Gemma, Streamlit, and Full CI/CD

⚡ TinySteps AI: Building an AI-Powered Task Roadmap Generator with Local Google Gemma, Streamlit, and Full CI/CD

🎯 What Does TinySteps AI Do?

🏗️ Under the Hood: Full CI/CD & Production Setup

🔗 Public Links & Proofs

🚀 Running it Locally

I Built GraphSleuth AI with FalkorDB for Graph Hacks — Here's What I Learned

Why I built this

What does it do?

Where FalkorDB fits in

The tech stack

A few things I learned

What's next?

FreelanceFlow AI: Generate Client Proposals with Open-Weight AI

Demo

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Final Thoughts

🌿 Walk & Notice — AI That Gets You Off the Screen

What I Built

🌿 Walk & Notice

Demo

▶️ Quick Video Preview

🚀 Live Production App

🌐 Streamlit Demo

🎥 High-Quality Demo Download

🔄 Alternative Video Download

📸 Evidence

Code

💻 GitHub Repository

How I Built It

🦙 Local AI — Gemma 4 E4B + Ollama

☁️ Production AI — OpenRouter

🎨 Streamlit Frontend

🧠 Prompt Engineering

🛡️ Safety by Design

🧪 Automated Testing

🐳 Docker

⚙️ GitHub Actions CI/CD

🚀 Render Deployment

Why Does Open Innovation Matter?

Prize Categories

🟢 Best Use of Gemma

🟠 Best Use of Render

🟣 Best Use of GitHub Copilot

🌍 The Idea Behind Walk & Notice