FlowMind

FlowMind is the "paste your notes, get your sprint" tool — AI that reads the chaos so your team doesn't have to.

Comment

Inspiration

FlowMind didn't start with a grand epiphany. I was brainstorming hackathon ideas with AI when the concept surfaced — what if AI could turn messy meeting notes into a structured task board?

The idea landed because it was relatable. My own notes are manageable, but I could see how it spirals for teams with more moving parts: action items buried in paragraphs, owners never assigned, deadlines implied but never written down. The gap between "things we discussed" and "things that actually get done" is surprisingly wide — and it almost always starts with notes nobody wants to re-read.

The AI I used to brainstorm the idea ended up becoming the engine running inside what I shipped. That felt like a good sign the project was worth building.

What it does

FlowMind takes any block of unstructured text — a meeting transcript, a project brief, a wall of bullet points — and converts it into a structured, execution-ready work card in seconds.

  • Task extraction — pulls out every action item with its owner and deadline
  • Risk detection — surfaces blockers buried in the text
  • Timeline summary — builds a chronological view of milestones and due dates
  • Next action — AI recommends the single most important thing to do right now
  • Kanban board — all cards drop into a drag-and-drop board, ready to track

Users sign in with their own Chutes account, so AI usage bills directly to them.

How I built it

FlowMind is a full-stack app: React + Vite on the frontend, FastAPI on the backend, and Qwen/Qwen3.6-27B-TEE on Chutes as the AI layer. Auth flows through Chutes OAuth 2.0 with PKCE.

The core is a four-stage pipeline where each stage's output feeds the next:

$$\mathcal{T}(\text{notes}) = f_4 \circ f_3 \circ f_2 \circ f_1(\text{notes})$$

Stage Name What it does
f1 Understanding Classifies the input type and intent with a confidence score
f2 Processing Extracts tasks, owners, deadlines, timeline, and risks
f3 Synthesis Writes a unified summary and picks the recommended next action
f4 Formatting Validates the schema and fills any missing fallback values

Tech stack: React · Vite · TailwindCSS · FastAPI · Python · Chutes API · OAuth 2.0 + PKCE

Challenges I ran into

The UI had no obvious shape. I knew what the output should look like — cards on a board — but the journey between "paste your notes" and "here's your board" took a lot of iteration. There's no template for what that middle experience should feel like.

JSON schema drift between platforms. Without Chutes plan access during early development, I tested locally with Ollama using the same model family. The pipeline worked perfectly. When I finally switched to the Chutes API, things broke.

Even with the same model $m$ and input $x$, the response structure differed across platforms:

$$f(x\,;\, m,\, p_1) \neq f(x\,;\, m,\, p_2)$$

Variables I was parsing didn't exist, or lived under different keys. I had to load real API responses from both sides, compare schemas, and remap the entire parsing layer by hand.

Accomplishments that I'm proud of

  • The pipeline is reliable. Paste any real meeting notes and it produces a coherent work card — not just on clean test inputs, but on genuinely messy real-world text.
  • OAuth with Chutes works end to end. Implementing PKCE from scratch and getting the full sign-in → token → AI call → sign-out cycle working cleanly was a real milestone.
  • The Kanban board is actually usable. Cards drag, stack, and reorder correctly — it feels like a tool, not a demo.
  • Provider flexibility. The backend supports both Chutes and any OpenAI-compatible endpoint via a single config switch — no code changes needed.

What I learned

Debugging LLM JSON is its own discipline. Response shape can vary by runtime, quantization, or prompt temperature. I now validate structure before parsing values and write code that degrades gracefully when the schema drifts.

Chutes was a genuine discovery. I didn't know the platform existed before this hackathon. Renting direct API access to a specific model — without managing infrastructure — makes the gap between prototype and deployed product much smaller than I expected.

Sometimes the idea finds you. I went in without a strong concept and came out with something I'd actually use. The best sign a project is worth building is when you find yourself reaching for it.

What's next for FlowMind

  • Team workspaces — shared boards where multiple members can own cards, comment, and track progress together
  • Export integrations — push generated cards directly into Notion, Jira, Linear, or Trello
  • Richer input types — support for audio transcripts, PDFs, and pasted Slack threads
  • Pipeline transparency — show confidence scores and extraction reasoning so users can understand and correct what the AI decided

Built With

Share this project:

Updates