FriendFlow AI: Turning Messy Thoughts into Clear Tasks with Local AI

Nadun Jayaweera — Fri, 02 Oct 2026 20:05:43 +0000

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:

https://youtu.be/4JgI4OzFFLs

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.

DEV Community: Nadun Jayaweera

FriendFlow AI: Turning Messy Thoughts into Clear Tasks with Local AI

FriendFlow AI: Turning Messy Thoughts into Clear Tasks with Local AI

What I Built

Demo

Code

How I Built It

Frontend

Backend

AI

Storage

Why Does Open Innovation Matter?

Privacy

No AI API Cost

Model Flexibility

User Control

Local Inference

Building for Sandaru

What I Learned

My Agent Session

Prize Categories

Final Thoughts