When Your Task Manager Becomes a Prison
I built a local-first system to escape Notion's limitations. Here's what I discovered about data ownership, API constraints, and the gaps that cloud tools can't fill.
2026 UPDATE: The Intake Rebellion
Since publishing this, I’ve solved the “Quick Capture” bottleneck by building Power-Flow. My rebellion has shifted from manual entry to a frictionless pipeline: I record thoughts into Pocket AI, which uses LLMs to generate summaries, action items, and hierarchical mind maps. Power-Flow then automatically syncs those recordings directly into my Notion Inbox while I’m away from my desk.
Wait … if Power-Flow sends everything to Notion, have I abandoned the “Local-First” source of truth?
No. Power-Flow is a one-way intake valve. It treats Notion as a high-friction “Reference and Collaboration Hub” but keeps the raw data available via the Pocket API and local logs. By automating the capture into Notion, I’m actually freeing up my “Local-First” brain to focus on Execute and Organize rather than data entry. I still own the workflow; I’ve just eliminated the “UI click tax.”.
I was on a plane, trying to update a task in Notion, when I realized something uncomfortable: my data wasn’t really mine. Notion was down, or my connection was spotty, or the app was syncing. I couldn’t access my own work. That moment sparked an experiment: what if my tasks lived in files I actually controlled?
This is the story of Personal OS: a local-first task management system that syncs with Notion but doesn’t depend on it. It’s also a case study in the gaps that even the best cloud tools leave behind.
The Hypothesis
Notion is beautiful. It’s powerful. It’s transformed how many people organize their work. But as I dug deeper into automating my workflow, I hit walls. The API has rate limits. Bidirectional sync is unreliable. Offline access is limited. I started asking: what if the cloud was optional, not required?
The hypothesis: a local-first system using markdown files could give me the speed and control I wanted, while still syncing to Notion when I needed collaboration. The files would be the source of truth. Notion would be a mirror, not the master.
The Gaps I Discovered
After months of building and testing, I documented ten specific gaps that Notion (as of 2025) can’t fill:
Offline access is limited. Desktop apps have some offline capabilities, but creating new content or accessing databases often requires internet. Browser-based work is completely dependent on connectivity.
The API has real constraints. Rate limits cap you at about 3 requests per second. Bidirectional relations often default to single-property, even when you request dual-property. Relation limits behave inconsistently. Property value limits cap rich text at 2000 characters. These aren’t edge cases; they’re daily frustrations for anyone trying to automate.
No true bidirectional sync. Most sync tools are one-way or create duplicates. If you edit the same item in Notion and locally, there’s no automatic conflict resolution. Changes can overwrite each other silently. The question “which system is the source of truth?” shouldn’t be a question.
Vendor lock-in is real. Your data lives on their servers. If you want to switch tools or export everything, it’s painful. You’re dependent on their infrastructure, their pricing decisions, their feature roadmap. What happens if they change their API? Raise prices? Shut down?
AI integration is surface-level. Notion’s AI features are basic. They don’t understand your workflow deeply. You can’t ask “show me what’s due this week” or “help me break down this task” in natural language and get meaningful results.
Version control doesn’t exist. Notion doesn’t track changes like git does. You can’t see the history of a task, revert changes, or understand how your planning evolved over time. For knowledge work, this is a significant limitation.
Quick capture is slow. Creating a task requires opening the app, clicking “New”, filling out a form. Too many steps for quick thoughts or brain dumps. Your workflow shouldn’t move at the speed of UI clicks.
Search is limited. Notion’s search is okay, but you can’t use powerful command-line tools like grep or ripgrep to find things across all your tasks instantly. For power users, this is a bottleneck.
Customization is constrained. Notion’s structure is flexible, but you’re still constrained by their interface and how they think tasks should work. What if you want a different structure? Different fields? Different views?
Local-first philosophy is missing. Notion is cloud-first. Your data lives on their servers, subject to their downtime, their changes, their decisions. What if your data lived on your computer first, and the cloud was optional?
The Solution: Personal OS
Personal OS is my answer to these gaps. It’s a local-first system built on markdown files, powered by Claude Code, with optional Notion sync.
Here’s how it works: your tasks live in markdown files on your computer. Each task is a file with YAML front matter for metadata and markdown for content. Claude Code understands your entire system and can help through natural conversation. Want to create a task? Just say “new task: Ship feature, due Friday.” Want to see what’s due this week? Ask Claude. The Kanban board generates automatically from your task files. Change a task’s status, and the Kanban updates. No manual dragging, no forgetting to update views.
Notion sync is optional but powerful. When you run /sync-tasks, the system performs true bidirectional sync. Edit in Notion OR markdown, and changes flow both ways intelligently. Smart conflict resolution handles edge cases: Notion wins on status and dates (for planning), markdown wins on body and notes (for detailed content). UUID matching prevents duplicates. Rate limiting and batching respect Notion’s API constraints automatically.
My system handles four databases: Tasks, Projects, Project Tasks, and Brain Dumps. More coming. All sync bidirectionally. All maintain relationship integrity. All work offline first, sync when online if wanted.
Why This Matters
This isn’t just about task management. It’s about data ownership, workflow autonomy, and the philosophy of local-first computing.
When your data lives in files you control, you’re not dependent on any single service. You can switch tools anytime. You can backup however you want. You can work at your own pace, even when services are down. Your workflow isn’t subject to someone else’s business decisions.
The local-first movement is growing for a reason. As we become more dependent on cloud services, we’re also becoming more vulnerable. What happens when a service changes its API? Raises prices? Shuts down? With local-first, your data is safe. The cloud becomes a convenience, not a requirement.
But there’s a deeper point here: the best tools should adapt to how you work, not force you to adapt to them. Personal OS is infinitely customizable because it’s just files. Structure tasks however you want. Add any fields you need. Create custom views. It’s all text files. The possibilities are endless.
The Experiment Continues
I’m still testing hypotheses. Still discovering gaps. Still refining the system. But the core principle holds: your data should be yours. Your workflow should be yours. The tools should serve you, not the other way around.
If you’re curious, I can make the code available. The documentation is detailed. The philosophy is clear. This isn’t a product; it’s an experiment. A case study. A proof of concept that local-first can work, even with cloud sync.
The question isn’t whether cloud tools are useful. They are. The question is: what happens when the cloud is optional, not required? What happens when you own your data, control your workflow, and work at your own pace?
I’m still finding out. But so far, the results are promising.
Validated Resources
Local-First Software - The manifesto by Ink & Switch that defines the philosophy of owning your data while enabling collaboration.
The Notion API Documentation - The official reference for the constraints (rate limits, property types) mentioned in this build.
Plain Text Productivity - A guide to the philosophy of using simple text files to manage complex lives.