DEV Community: Indu

GreenBreak AI 🌱 — Less Scrolling, More Living!

Indu — Sat, 10 Oct 2026 11:05:37 +0000

What if we used our screen breaks to reconnect with the outdoors instead of scrolling through another feed?

That's the idea behind GreenBreak AI — a project that encourages people to step away from their screens and enjoy small, meaningful outdoor activities.

🌱 The problem

We spend a lot of time looking at screens, even when we only intended to check something for a few minutes. Taking a break can easily turn into more scrolling.

I wanted to build something that makes it easier to choose an outdoor activity instead.

🌿 What GreenBreak AI does

Personalized break plans: Generate outdoor activities based on the available time, activity type, and difficulty.
Local AI generation: Uses Ollama with the gemma2:2b model to generate break-plan suggestions locally.
Template fallback: If the local model is unavailable or returns an invalid response, the application can fall back to predefined activity templates.
Daily nature missions: Encourages users to complete small outdoor activities.
Progress tracking: Stores activity progress in browser local storage.

The goal is simple: make it easier to replace a few minutes of scrolling with a refreshing break outdoors.

🧠 How I built it

GreenBreak AI combines a Python backend with a web frontend.

When a user requests a break plan, the backend sends a structured generation request to a locally running Ollama service. The model's response is validated before being returned to the frontend. If AI generation fails, the application can use the template-based fallback.

This approach keeps the core experience available even when the local model cannot generate a response.

The local AI integration

I used Gemma 2 2B (gemma2:2b) through Ollama.

Instead of relying on a paid, hosted AI API, the application can generate suggestions using a model running on the user's own computer. This avoids per-request cloud inference charges, although running the model still requires suitable local hardware and resources.

The model is distributed under Google's Gemma Terms of Use. It is an open-weight model with specific license conditions, so I am not claiming that it is OSI-approved open-source software.

🛠️ Tech stack

Backend: Python, FastAPI
AI: Ollama, Gemma 2 2B
Frontend: HTML, CSS, JavaScript
Validation: Pydantic
Progress storage: Browser local storage
Testing: Pytest

🚀 Run it locally

1. Clone the repository

git clone https://github.com/Sri-Indu/GreenBreak-AI.git
cd GreenBreak-AI

2. Install the dependencies

Create and activate a Python virtual environment if desired, then install the project's requirements:

python -m pip install -r requirements.txt

3. Set up Ollama

Install Ollama and make sure the gemma2:2b model is available locally.

If you do not already have the model, run:

ollama pull gemma2:2b

If it is already installed, you do not need to download it again. Ensure the Ollama service is running.

4. Start the backend

From the project directory, run:

python -m uvicorn backend.main:app --host 127.0.0.1 --port 8000

5. Open the frontend

Follow the frontend instructions in the repository README to open the application locally.

If Ollama is unavailable, the template fallback can provide break plans instead.

🧪 Testing

I ran the Python test suite after integrating local AI generation:

67 Python tests passed
JavaScript syntax check completed without errors

These results verify the tested application behavior. Actual AI generation also depends on the local Ollama service and model being available.

🔗 Project links

GitHub repository: https://github.com/Sri-Indu/GreenBreak-AI
Demo video: https://drive.google.com/file/d/1m0QsAE5tY1_h85-CpulkI_5whhALjc4h/view?usp=drivesdk

🌍 Why open innovation matters

I wanted to explore how AI could support healthier digital habits without requiring a paid hosted AI API.

Local inference gives developers an opportunity to experiment with AI on their own machines, understand how model integration works, and build useful applications with fewer external service dependencies.

This project also helped me learn about structured model responses, backend validation, error handling, and fallback behavior.

💚 The goal

A short break outside can be more meaningful than another few minutes scrolling.

With GreenBreak AI, I hope to make those small breaks easier to plan — one outdoor activity at a time.

Thanks for reading! 🌱

devchallenge #hf26challenge

I built PrepMate, an AI interview coach for a friend preparing for SDE interviews 🤝

Indu — Mon, 05 Oct 2026 05:26:49 +0000

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

What I Built

I built PrepMate, a privacy-first AI interview preparation assistant for a friend preparing for software engineering interviews.

The problem is simple: interview preparation is often generic. A candidate may have a specific resume, a specific target job, and specific weaknesses, but still practice the same questions as everyone else.

PrepMate makes the preparation personalized.

The user provides:

A resume
A target job description

PrepMate then analyzes the candidate against the role and provides:

Strengths
Skill gaps
Relevant interview topics
A personalized preparation plan

But I didn't want it to stop at resume analysis.

PrepMate also conducts an adaptive mock interview. It evaluates the candidate's answer and uses that evaluation to decide what kind of question should come next.

Demo

Demo video: Watch the PrepMate demo

The demo shows the complete flow:

Upload a resume and job description
Analyze the candidate's fit
Start the mock interview
Answer the first question
Receive an AI evaluation
Generate an adaptive second question
Complete the interview
Receive the final feedback report

How It Works

The main pipeline is:

Resume + Job Description → PDF Extraction → RAG → Gemma → Personalized Analysis → Adaptive Interview → Final Report

The project uses:

Next.js + TypeScript for the frontend
FastAPI + Python for the backend
FAISS for vector search
Sentence Transformers for embeddings
Ollama + Gemma 2B for local AI inference
pypdf for resume extraction

The resume and job description are processed in memory.

Adaptive Interview

The interview is intentionally adaptive rather than simply generating a fixed list of questions.

After each answer, PrepMate evaluates:

Correctness
Depth
Clarity
Completeness

Based on the evaluation, the system can choose strategies such as:

Reinforce a weakness
Ask a follow-up
Increase difficulty
Continue on the same topic
Move to a new topic

The current MVP runs a focused 2-question interview followed by a final report.

Why Open-Source AI?

I wanted the core AI functionality to work without depending on a paid proprietary LLM API.

PrepMate uses the open-weight Gemma 2B model locally through Ollama.

This makes the project:

Local
Free to run
More privacy-friendly
Easier to experiment with and inspect

The RAG pipeline also runs locally using FAISS and Sentence Transformers.

Prize Category

Best Use of Gemma: PrepMate uses the open-weight Gemma 2B model locally through Ollama for resume and job-description analysis, interview question generation, answer evaluation, and personalized feedback.

Gemma is not just used as a simple chatbot. It is integrated into the core interview-preparation workflow, while the deterministic Python logic controls the adaptive interview strategy.

Privacy

Resumes can contain sensitive personal information, so privacy was an important design consideration.

PrepMate:

Processes the resume in memory
Does not permanently store the uploaded PDF
Keeps interview session state in memory
Uses local Ollama/Gemma for AI inference
Does not require a paid LLM API

The demo uses fictional sample candidate data.

What I Learned

Building PrepMate helped me understand how different AI components fit together into an actual product rather than just calling an LLM.

I worked with:

PDF document processing
Embeddings and vector search
RAG
Local LLM inference
Structured JSON generation
Adaptive interview logic
FastAPI APIs
Next.js frontend integration
Testing an AI-powered application end-to-end

One important design choice was keeping the interview strategy deterministic in Python while using Gemma for natural-language question generation and evaluation.

This makes the adaptive behavior easier to understand, test, and debug.

GitHub

💻 Source code: https://github.com/Sri-Indu/PrepMate

The project is open source and includes the implementation, setup instructions, and tests.

Current Limitations

This is an MVP, so it currently has:

2 interview questions per session
No authentication
No persistent interview history
No voice input
No production deployment
Local Ollama/Gemma setup required

These are intentional scope limitations for the challenge rather than unfinished core functionality.

What's Next

Future versions could include:

Longer adaptive interviews
Voice-based interviews
Persistent candidate history
More advanced interview strategies
Production deployment
Support for additional open-weight models

Final Thoughts

I built PrepMate because I wanted to solve a real problem for someone preparing for SDE interviews instead of building another generic AI chatbot.

The goal is simple:

Give a candidate a preparation plan based on their actual profile, then help them improve through an adaptive interview.

Building this project also helped me understand how RAG, embeddings, local LLMs, structured generation, and application logic can work together as one complete AI product.

Built for the Hacktoberfest 2026 Build for a Friend Challenge 🤝