This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.
FriendFlow AI: Turning Messy Thoughts into Clear Tasks with Local AI
What I Built
I built FriendFlow AI, a privacy-first local AI task organizer for my friend Sandaru, who is a software engineer.
Like many developers, Sandaru has a heavy daily workload. He has meetings, development tasks, code reviews, personal errands, reminders, and other responsibilities happening at the same time.
Because of that workload, he sometimes forgets small daily tasks.
The usual solution would be to use a task management application, but I noticed another problem: traditional task managers can actually create more friction for someone who is already busy.
To create a single task, you may need to:
- Type the task title
- Choose a priority
- Select a date
- Add details
- Save the task
- Repeat the same process for every other task
When someone already has many things on their mind, organizing everything manually can become another task by itself.
I wanted to make that process much simpler.
That is where FriendFlow comes in.
Instead of manually creating tasks one by one, Sandaru can simply write or paste everything that is on his mind in one messy paragraph.
For example:
Tomorrow I need to review the API PR, buy milk,
send the project report today, and call Kasun.
FriendFlow sends that unstructured text to a locally running open-weight AI model.
The AI then turns the note into structured tasks such as:
Review the API PR
Tomorrow
High Priority
Buy milk
No date
Medium Priority
Send the project report
Today
High Priority
Call Kasun
No date
Medium Priority
The user can then mark tasks as completed, and finished tasks are moved into a completed-task history.
The goal is simple:
Dump your thoughts first. Organize them later with AI.
Demo
Here is a short video showing FriendFlow in action:
The demo shows:
- Entering an unstructured note
- Sending the note to the local AI model
- Automatically generating structured tasks
- Detecting priorities and deadlines
- Marking a task as completed
- Saving completed tasks in local history
Code
The complete project is available on GitHub:
https://github.com/nadunjayaweera/friendflow-ai
FriendFlow is built as a small full-stack application with a React frontend and a Node.js/Express backend.
How I Built It
FriendFlow uses the following stack:
Frontend
- React
- Vite
- CSS
Backend
- Node.js
- Express
AI
- Ollama
- Gemma 3 1B
Storage
- Local JSON storage
The basic architecture looks like this:
User Note
↓
React Frontend
↓
Node.js / Express Backend
↓
Ollama
↓
Gemma 3 1B
↓
Structured JSON Tasks
↓
React Task List
↓
Local JSON Storage
The React frontend sends the user's note to an Express API endpoint.
The backend creates a prompt asking Gemma to extract actionable tasks from the note.
Gemma returns structured task information including:
- Task title
- Due date
- Priority
The backend validates and normalizes the AI response before saving the tasks locally.
The generated tasks are then returned to the frontend and displayed to the user.
When a task is completed, it is removed from the active task list and moved into completed-task history.
One of the interesting parts of this project was making the AI output reliable enough for the frontend.
Instead of allowing the model to return free-form text, I instructed it to return structured JSON.
For example:
{
"tasks": [
{
"title": "Send project report",
"dueDate": "Today",
"priority": "High"
}
]
}
The backend also handles different possible response structures and normalizes them before sending the final task data to React.
Why Does Open Innovation Matter?
Open innovation is not just something I added to FriendFlow to meet the challenge requirement.
It directly influenced how I designed the application.
Personal notes can contain a lot of private information.
A user may write about:
- Work projects
- Client names
- Personal plans
- Family matters
- Deadlines
- Private reminders
For FriendFlow, I did not want every personal note to automatically be sent to an external AI provider.
Instead, I used Gemma 3 1B running locally through Ollama.
This means the AI inference can happen directly on the user's machine.
The note does not need to be sent to a third-party AI API.
That gives FriendFlow several advantages.
Privacy
The user's notes can remain on their own machine.
This is especially important for work-related or personal information.
No AI API Cost
There is no per-request cost for organizing tasks.
Once the model is installed locally, FriendFlow can use it without paying for every prompt.
Model Flexibility
The application is not permanently tied to a single AI provider.
Because Ollama supports multiple models, I can experiment with or replace the model later without rebuilding the entire application.
User Control
The user controls both the AI runtime and the task data.
FriendFlow stores task information locally instead of depending on an external cloud database.
Local Inference
The most interesting part for me was seeing that a small open-weight model could perform a useful everyday task directly from my own computer.
Before this challenge, I had very little experience working with AI models.
Building FriendFlow helped me understand that integrating an open-weight model does not always require training a model or having deep machine-learning knowledge.
Sometimes, the most useful approach is simply giving a model a clear responsibility inside an application.
In FriendFlow, that responsibility is turning messy human thoughts into structured tasks.
Building for Sandaru
The theme of this challenge was Build for a Friend, and that changed how I approached the project.
Instead of trying to build a large general-purpose AI application, I focused on one small problem that someone I know actually experiences.
Sandaru does not need another complicated productivity platform.
He needs a faster way to capture what is already in his head.
That is why FriendFlow intentionally keeps the interaction simple:
Sandaru said the most useful part was being able to dump several thoughts at once instead of creating tasks one by one.
Write everything
↓
Click Organize with AI
↓
Get clear tasks
The project is small, but the problem is real.
That was one of my favorite parts of this challenge.
What I Learned
This was also my first real experience building an application around an open-weight AI model.
I learned how to:
- Run Gemma locally using Ollama
- Send prompts to a local model from Node.js
- Request structured JSON output from an AI model
- Validate AI-generated responses
- Connect local AI inference to a React application
- Persist AI-generated task data locally
- Design an application where AI performs a specific useful function
The biggest lesson for me was that I did not need to understand model training before I could start building useful applications with open models.
As a web developer, I could treat the model as another service inside my application and gradually learn how it behaves.
My Agent Session
I did not use an agent session for this submission.
The project was built using a simple local AI architecture with Gemma running through Ollama.
Prize Categories
I am entering FriendFlow in:
- Best Use of Gemma
Gemma 3 1B is the core AI model responsible for converting unstructured user notes into structured tasks.
Final Thoughts
Hacktoberfest 2026 pushed me into an area I had not explored much before: open-weight AI.
I started this challenge without much knowledge about AI models.
By the end, I had a working application where a locally running Gemma model was solving a real problem for someone I know.
FriendFlow may be a small project, but that is also what I like about it.
It takes one repetitive part of task management and removes it.
Instead of carefully organizing every thought before saving it, the user can simply write naturally and let the AI handle the structure.
Sometimes the most useful tools are not the biggest ones.
They are the ones that remove a little bit of friction from someone's day.
Top comments (0)