Your To-Do List Is Dead — Meet the AI That Executes Everything

Ashiha Mahesh Kumar — Mon, 30 Mar 2026 05:59:51 +0000

This is a submission for the Notion MCP Challenge

DueIt — The AI That Doesn't Just Plan Your Tasks. It Executes Them.
Table of Contents

What I Built
The Problem That Kept Me Up at Night
The Breakthrough Moment
How It Works — The Full Pipeline
How I Used Notion MCP
The Architecture
TinyFish — The Web Agent Layer
Show Us the Code
What This Unlocks
Wrapping Up

DueIt is an AI-powered Flutter productivity app that transforms a single task creation into a fully automated execution pipeline.
Most productivity apps give you a to-do list. DueIt gives you a done list.
One task. Fully executed.
DueIt works in two layers that feed into each other seamlessly.

Layer 1 — The Flutter App: A Full Productivity Engine
Before DueIt even touches Notion, it's already a powerful productivity system on its own.

AI-Powered Time Blocking Calendar
When you create a task, DueIt doesn't just add it to a list. It plans your entire journey to the deadline.
Gemini AI estimates the total time required and distributes microtasks across every day from today until your deadline — automatically populating your calendar with real time-blocked sessions.
Open the calendar and you see:

Every day has real tasks assigned with specific time slots
Multiple tasks from different projects distributed intelligently across days
Exactly what to work on and for how long — every single day
A real calendar view — not a flat to-do list

If you miss a day, DueIt recalculates automatically and redistributes the remaining work across your remaining days. Your path to the deadline always stays clear.

Dashboard — The Pressure System
The DueIt dashboard is built around one core insight: deadlines create pressure, and pressure without awareness creates failure.
Three live indicators track every task in real time:
Pressure Meter — As your deadline approaches and tasks pile up unfinished, the pressure meter rises. It tells you exactly when you need to act — before it's too late.
Risk Meter — Combines deadline proximity, task completion rate, and estimated remaining work to calculate your real risk of missing the deadline. Red means danger. Green means on track.
AI Productivity Heatmap — A full monthly view showing exactly how productive you were each day. Dark means high output. Light means minimal work. One glance shows your real work pattern — not what you think it is.

This isn't motivational fluff. It's an honest mirror of your execution reality.

Adaptive Replanning
DueIt doesn't punish you for missing a day. It adapts.
Every morning, the AI checks what you completed and automatically replans your schedule going forward. Missed tasks get redistributed. Time blocks shift. Your calendar updates itself so you always have a clear path to the deadline — even when life gets in the way.

Layer 2 — The Autonomous Execution Pipeline
On top of the Flutter productivity engine, DueIt adds a fully automated execution layer.
When you create a task, this pipeline fires automatically:

Gemini AI breaks it into structured phases and microtasks
TinyFish browses the web and finds real curated resources specific to your task
TinyFish navigates Excalidraw and generates a visual workflow diagram
Notion auto-generates a complete workspace with Progress Tracker, Workflow, and Resources
Cursor AI reads the Notion page via Notion MCP and executes the work phase by phase
Status syncs back to Notion and your Flutter app in real time

The Flutter app tracks your progress. The execution pipeline builds your workspace and does the work. Together they form a closed loop — from idea to execution to completion.
From the user's perspective, there's no setup, no planning, and no context switching. You create a task — and the system starts working.

Video Demo

The Problem That Kept Me Up at Night
I'm a builder. I always have 10 ideas, 5 projects in progress, and 3 deadlines I'm probably missing.
Every time I started something new, the same painful cycle repeated:

Create a task in some productivity app
Stare at a blank page wondering where to start
Spend 2 hours searching for the right resources
Try to figure out the right order to do things
Get overwhelmed and lose momentum
Switch to a different project and repeat

The tools weren't the problem. The gap between planning and actually starting was the problem.
I didn't need another to-do app. I needed something that would build my entire execution environment FOR me — the moment I created a task.
That's what DueIt is.

The Breakthrough Moment
I was building this for the TinyFish hackathon. The idea was simple — use TinyFish to scrape resources for tasks. But somewhere around 2AM, I realized something bigger was possible.
What if the Notion page DueIt creates isn't just documentation — what if it's the command center for an AI coding agent?
That's when Notion MCP clicked. Not as a nice integration. As the backbone of the entire system.
Notion becomes the shared brain between your mobile app, the web agent, and the AI coding agent. Everyone reads from it. Everyone writes to it. The loop closes.
Remove Notion MCP, and the execution loop breaks.
Notion is not just storage in DueIt — it is the coordination layer that makes autonomous execution possible.

    User creates task in Flutter app
            ↓
   Gemini 2.5 Flash generates schedule
   (phases, microtasks, time estimates)
            ↓
  FastAPI on Google Cloud Run orchestrates everything
            ↓
        ┌───────────────────────────────┐
        │     Three parallel actions    │
        └───────────────────────────────┘
         ↓              ↓              ↓
  TinyFish           Notion         TinyFish
scrapes web         page created    generates
for resources       with Progress   Excalidraw
                    Tracker DB      workflow
         ↓              ↓              ↓
        └───────────────────────────────┘
            ↓
  Notion workspace fully populated
   (Resources + Workflow + Tracker)
            ↓
  Cursor Agent reads Notion via MCP
            ↓
  Cursor executes task phases as code
            ↓
  Notion Progress Tracker updated → Done
            ↓
   DueIt app reflects updated status

From the user's perspective, there's no setup, no planning, and no context switching. You create a task — and the system starts working.

How I Used Notion MCP
This is the part I'm most proud of.
Setup
I configured Notion MCP in Cursor using the @notionhq/notion-mcp-server:

json{
  "mcpServers": {
    "notion": {
      "command": "npx",
      "args": ["-y", "@notionhq/notion-mcp-server"],
      "env": {
        "OPENAPI_MCP_HEADERS": "{\"Authorization\": \"Bearer YOUR_TOKEN\", \"Notion-Version\": \"2022-06-28\"}"
      }
    }
  }
}

The Notion Page Structure

Every task DueIt creates generates a "Let's Get Started" page with this exact structure:

Task Overview
Task details, deadline, estimated time, category
Expected Output
Category-specific completion statement

3. Progress Tracker (inline database)
   ┌─────────────────────┬─────────┬──────────┐
   │ Step                │ Phase   │ Status   │
   ├─────────────────────┼─────────┼──────────┤
   │ Research & Design   │ Phase 1 │ To Do    │
   │ Implementation      │ Phase 2 │ To Do    │
   │ Testing & Deploy    │ Phase 3 │ To Do    │
   └─────────────────────┴─────────┴──────────┘

Workflow Diagram
[Excalidraw collaboration room link]
Notes
Phase 1 — Research & Design
• Microtask 1
• Microtask 2

Phase 2 — Implementation
• Microtask 1
• Microtask 2

Resources • [Real curated link from TinyFish] • [Real curated link from TinyFish] • [Real curated link from TinyFish]

The MCP Agent Loop
Here's the CURSOR.md I created to give Cursor full context:

# DueIt — Cursor Agent Instructions
When activated:
1. Use Notion MCP to find the most recent "Let's Get Started" page
2. Read the Progress Tracker database — understand all phases
3. Read the Notes section — understand each phase's microtasks
4. Execute phases one by one as code changes
5. After each phase: update Notion Status → "In Progress" → "Done"
6. When all phases complete: task is done

When I type /dueit-execute in Cursor:

Cursor searches Notion via MCP for the latest DueIt task page
It reads the Progress Tracker database — understanding what needs to be built
It reads the Notes section — understanding the specific microtasks
It executes the code changes phase by phase
After each phase it updates the Notion database status from "To Do" → "In Progress" → "Done"
The DueIt Flutter app reads the updated Firestore data and shows the new status

Real example: I created a task "Build a personal portfolio website". Within 5 minutes:

Notion page appeared with Research & Design phase and Implementation phase
TinyFish found real resources including MDN docs, CSS tutorials, and design inspiration
Excalidraw showed a workflow: Research → Design → Build → Test → Deploy
Cursor read the Notion page via MCP, scaffolded the HTML/CSS structure, updated Phase 1 to Done
DueIt app showed the updated progress automatically

Why Notion MCP and Not Just the API?

I use both — strategically.

Direct Notion API for page creation, database population, and resource updates. It's faster for bulk operations.

Notion MCP for the Cursor agent loop — reading task context, understanding phases, and writing status updates back. MCP gives the AI agent structured, tool-level access to the workspace. It's not just reading raw JSON — it's interacting with Notion the way a human would, through proper tool calls.

The difference is enormous. Without MCP, the agent would need to parse raw API responses and figure out the workspace structure itself. With MCP, it understands the workspace natively — pages, databases, properties, blocks — and can interact with them intelligently.

Remove Notion MCP, and the execution loop breaks. Notion is not just storage in DueIt — it is the coordination layer that makes autonomous execution possible.


## The Architecture

┌─────────────────────────────────────────────────────┐
│                   Flutter App                       │
│         (Task creation, status display)             │
└──────────────────┬──────────────────────────────────┘
                   │ HTTP
┌──────────────────▼──────────────────────────────────┐
│          FastAPI on Google Cloud Run                │
│                                                     │
│  /plan-task ──→ Gemini 2.5 Flash                    │
│  /generate-doc ──→ notion_service.py                │
│  /scrape-resources ──→ tinyfish_service.py          │
│  /create-excalidraw ──→ tinyfish_service.py         │
└──────┬──────────────┬────────────────┬──────────────┘
       │              │                │
┌──────▼──────┐ ┌─────▼──────┐ ┌──────▼──────┐
│  Firebase   │ │   Notion   │ │  TinyFish   │
│  Firestore  │ │    API     │ │    API      │
└─────────────┘ └──────┬─────┘ └─────────────┘
                       │
               ┌───────▼────────┐
               │  Notion MCP    │
               │    Server      │
               └───────┬────────┘
                       │
               ┌───────▼────────┐
               │  Cursor Agent  │
               │  (executes)    │
               └────────────────┘

Key files:

main.py — FastAPI endpoints, pipeline orchestration
notion_service.py — Notion page generation with Progress Tracker database
tinyfish_service.py — TinyFish web scraping and Excalidraw automation
CLAUDE.md — Cursor agent instructions for Notion MCP loop

TinyFish — The Web Agent Layer
TinyFish is what makes DueIt feel like magic. It's not hitting an API — it's browsing the web like a human.
Resource Scraping

pythondef scrape_resources(topic: str, category: str) -> dict:
    if category.lower() == "study":
        url = f"https://duckduckgo.com/?q={topic}+free+course+tutorial+pdf"
        goal = f"""Search for learning resources about "{topic}".
        Find the top 3-5 most relevant, high-quality results.
        Prioritize official docs, Coursera, edX, MIT OpenCourseWare.
        Return as JSON array: [{{title, url, description}}]"""
    return run_automation(url, goal)

TinyFish navigates DuckDuckGo, reads the search results, filters for quality, and returns structured JSON. The results become clickable blue hyperlinks in the Notion page.
Excalidraw Workflow Generation

pythondef create_excalidraw_workflow(title, category, steps):
    mermaid_code = f"""flowchart LR
    S0["{steps[0]}"] --> S1["{steps[1]}"] --> S2["{steps[2]}"]"""

    goal = f"""Go to excalidraw.com.
    Open Mermaid importer. Paste this code:
    {mermaid_code}
    Click Insert. Start collaboration session.
    Return the #room= URL."""

    return run_automation("https://excalidraw.com", goal)

TinyFish opens Excalidraw, uses the built-in Mermaid importer, creates the diagram from AI-generated flowchart code, starts a collaboration room, and returns the shareable URL. Every task gets a unique diagram specific to its actual phases.

Show Us the Code

ashihams / due-it

AI-powered task planning app that automatically breaks tasks into actionable subtasks, adapts daily schedules, and recalculates workload based on missed tasks and approaching deadlines.

DueIt

AI-powered task planning system with:

Flutter frontend app (due_it/)
FastAPI backend (due_it_backend/)
Firebase Auth + Firestore
Gemini-based planning
Notion + TinyFish integrations for docs/resources/workflow automation

🎥 Demo

👉 Click here to watch the demo

Repository Layout

.
├─ due_it/                 # Flutter frontend
│  ├─ lib/
│  ├─ android/ ios/ web/ ...
│  └─ pubspec.yaml
├─ due_it_backend/         # FastAPI backend
│  ├─ main.py
│  ├─ notion_service.py
│  ├─ tinyfish_service.py
│  ├─ requirements.txt
│  └─ Dockerfile
└─ README.md               # This file

What DueIt Does

User signs in with Firebase Auth.
User creates a task in Firestore (users/{uid}/tasks/{taskId}).
Frontend calls backend /plan-task.
Backend uses Gemini to generate
- estimated duration
- day-wise schedule
- microtasks
- pressure/risk metrics
Backend stores AI plan in Firestore.
Backend syncs task + launchpad docs to Notion (if connected).
Backend uses TinyFish to:
- scrape useful resources
- generate Excalidraw workflow links
Frontend reflects updates from…

View on GitHub

dueit/
├── due_it/                    # Flutter app
│   ├── lib/
│   │   ├── services/
│   │   │   ├── notion_service.dart
│   │   │   ├── task_service.dart
│   │   │   └── ai_planning_service.dart
│   │   └── screens/
│   │       ├── dashboard_screen.dart
│   │       ├── calendar_screen.dart
│   │       └── settings_screen.dart
└── due_it_backend/            # FastAPI backend
    ├── main.py
    ├── notion_service.py
    ├── tinyfish_service.py
    ├── CLAUDE.md
    └── Dockerfile

Tech Stack:

Flutter — cross-platform mobile app
FastAPI + Google Cloud Run — scalable backend
Firebase + Firestore — auth and real-time sync
Gemini 2.5 Flash — AI task planning
TinyFish API — web agent automation
Notion API + Notion MCP — workspace generation and agent coordination
Excalidraw — visual workflow diagrams
Cursor AI — autonomous code execution

What This Unlocks

DueIt isn't just a productivity app. It's a proof of concept for something bigger.

The pattern:

Mobile intent → AI planning → Web agent execution
→ Notion as coordination layer
→ AI coding agent → Status sync → Mobile feedback
This pattern works for ANY task. Study for an exam. Build a startup. Learn a skill. Launch a product. The system doesn't care what the task is — it builds the execution environment and starts working on it.
What Notion MCP makes possible: For the first time, your workspace isn't just where you document work. It's where work actually happens. The AI agent reads it, acts on it, updates it. It becomes a living, breathing coordination layer between human intent and machine execution.
Remove Notion MCP, and the execution loop breaks. With it, DueIt becomes something genuinely new — not a productivity tool, but an autonomous execution system.
I genuinely believe this is what productivity software looks like in 2 years. DueIt is just the first version.

Wrapping Up
I built DueIt in 25 days across two simultaneous hackathons — TinyFish Pre-Accelerator and the Notion MCP Challenge. Some nights I was debugging Notion API errors at 3AM. Some mornings I was rewriting the entire TinyFish goal string because CAPTCHA broke everything. There were moments I thought this wasn't going to work.
But the moment I watched Cursor read a Notion page I had just auto-generated from my phone and start writing code for it — updating the status back to "Done" without me touching anything — I knew every late night was worth it.
The productivity gap between "I have an idea" and "I'm actually working on it" has always been the hardest part. DueIt closes that gap.
Not with another to-do list. With an autonomous execution system that works while you sleep.
One task. Fully executed.

Built with way too much coffee, Gemini, TinyFish, Notion MCP, and the belief that AI should do more than suggest — it should execute.

DEV Community: Ashiha Mahesh Kumar