FriendFlow AI: A Private, Local Task Board That Turns Messy Thoughts into Clear Actions

Sumedha Niroshan — Mon, 05 Oct 2026 05:54:56 +0000

FriendFlow AI: A Private, Local Task Board That Turns Messy Thoughts into Clear Actions

devchallenge #weekendchallenge #hacktoberfest

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

What I Built

FriendFlow AI is a privacy-first task organizer that runs its AI on your own machine. I built it for my friend Sandaru, a software engineer whose day is a pile of PR reviews, meetings, bug fixes and small errands. The big tasks never slip. The tiny ones do: the call he meant to make, the invoice he meant to send.

I tried a few task managers, and they all share one problem. Adding a task means typing a title, picking a priority, choosing a date and saving, then doing it all again for the next one. When your head is already full, that is extra work.

So FriendFlow has one input: write everything that's on your mind in one messy paragraph.

Tomorrow I need to review the API PR, buy milk,
send the project report today, and call Kasun.

A local AI model reads the note and returns structured tasks, each with a title, a due date and a priority. They land on a board, sorted by urgency.

Dump your thoughts first. Let the AI organize them.

What the App Looks Like

The first version was a single column. For this challenge I redesigned it as a small workspace:

A sidebar with two views, Task board and Completed history. It shows a count for each, a "High priority" counter and an overall progress bar.
A compact composer at the top for pasting your note. Ctrl + Enter organizes it without reaching for the mouse.
A priority board that groups active tasks into High, Medium and Low columns, so the urgent ones are visible at a glance.
Search that filters tasks in whichever view you're in.
Completed history, where finished tasks keep their priority and completion time. You can delete them one by one or clear them all.
A responsive layout. The columns stack on smaller screens and the sidebar becomes a top bar.
Demo

**
The demo shows:**

Pasting an unstructured note
The local model generating tasks
Tasks sorted into priority columns
Completing a task and watching the progress bar update
Searching and clearing history
Code

https://github.com/sumedha-niroshan/friendflow-board.git
How I Built It

Frontend: React, Vite, CSS
Backend: Node.js, Express
AI: Ollama with a Gemma model [state the exact model you use]
Storage: local JSON files

Messy note
↓
React frontend
↓
Express API
↓
Ollama (local Gemma)
↓
Structured JSON
↓
Validation + normalization
↓
Priority board + local JSON storage

The React app sends the note to an Express endpoint. The backend builds a prompt asking the model to extract actionable tasks and return only JSON:

json

The hard part wasn't calling the model. It was trusting its output. Small models sometimes wrap JSON in extra text, rename fields or skip the priority. The backend therefore validates every response, handles a few different response shapes, and falls back to safe defaults such as "Medium" priority.

After each change, the server returns the full current list of active and completed tasks. The frontend replaces its state with that list, so the two sides can't drift apart. The board layout depends on this, because each task has to land in exactly one column.

I ran into one practical problem during development. Ollama returned a "model not found" error because the model name in my code wasn't installed on my machine. Checking ollama list and matching the exact model tag fixed it. It's a good reminder that local AI means you manage the model yourself.

Why Open Innovation Matters

Personal notes are sensitive. They can mention clients, family, deadlines and private plans. I didn't want every note sent to a third-party API.

Running an open-weight model through Ollama gave me:

Privacy: the note is processed on the user's computer.
No per-request cost: once the model is installed, organizing tasks is free.
Flexibility: I can swap models by changing one setting.
Control: both the AI runtime and the task data stay with the user.

I also learned how well small models handle a narrowly defined job. I didn't train anything. I gave the model one clear responsibility, turning messy text into tasks, and wrapped it in validation.

Building for Ravihara

"Build for a Friend" changed my approach. I didn't build a general productivity platform. I built the one thing Ravihara needs: a faster way to get what's in his head onto a list.

FriendFlow AI is a really interesting idea, especially for people who have a busy workday filled with small tasks that are easy to forget. I like that the AI runs locally on the user’s own machine, which makes the privacy-first approach a strong advantage.
The concept feels practical because it focuses not only on big projects but also on those small tasks that often get lost between meetings, PR reviews, and bug fixes. The interface and workflow could make it much easier to capture and organize these little tasks without adding more mental load.
Overall, FriendFlow AI feels like a useful tool for developers and anyone who has a lot of small things to keep track of. The local AI and privacy focus make it stand out from many cloud-based task organizers.

What I Learned

Running open-weight models locally with Ollama
Prompting a small model for strict JSON output
Validating and normalizing AI responses before the UI uses them
Keeping frontend and backend state in sync by returning the full list after every change
Designing a layout around the shape of the data (priority columns, history view) rather than a generic list
My Agent Session

Prize Categories

Best Use of Gemma: a local Gemma model is the core of the app, converting unstructured notes into structured, prioritized tasks without any data leaving the machine.

Final Thoughts

FriendFlow is a small project. It takes one tedious step out of task management, which is organizing your thoughts before you're allowed to save them. You write naturally, and the AI does the structuring on your own machine.

DEV Community: Sumedha Niroshan

FriendFlow AI: A Private, Local Task Board That Turns Messy Thoughts into Clear Actions

devchallenge #weekendchallenge #hacktoberfest