Full opportunity report: Disk Is the Contract: Inside Threlmark’s Local-First Architecture on ThorstenMeyerAI.com — validation score, market gap, and execution plan.
TL;DR
Threlmark has developed a project management system that relies entirely on local JSON files stored on disk, eliminating the need for a server or cloud. This approach emphasizes portability, inspectability, and safety through atomic file operations and a file-based contract.
Threlmark has unveiled a new architecture for its project management system that relies entirely on local JSON files stored on disk, with no server or cloud dependency. This design choice emphasizes data portability, inspectability, and safety, marking a significant shift from traditional server-based systems and focusing on local-first principles.
The core architectural decision in Threlmark’s system is that the disk contents serve as the contract and record of truth. All project data, including cards, dependencies, and progress, are stored as individual JSON files within a dedicated directory, defaulting to ~/.threlmark. This setup allows external tools and AI agents to participate seamlessly without needing permission or access to a central database.
The system avoids server reliance by implementing atomic file writes—each update is written to a temporary file and then renamed atomically, preventing corruption during crashes. Reads are tolerant, merging updates and preserving unknown fields to maintain forward compatibility. This file-per-item approach ensures concurrency safety, as external tools can modify individual files without conflicts, and the system automatically reconciles the project state on each read, ensuring consistency and integrity.
Disk is the contract: inside Threlmark’s architecture — ThorstenMeyerAI.com
<!– DEPLOY: swap this Google Fonts for self-hosted base64 woff2 (German GDPR) –>
Disk is the contract: inside a local-first roadmap hub
A Next.js app on top of plain JSON files — no database, no cloud, no accounts. The key decision: the on-disk layout IS the API. Everything else cascades from taking that seriously.
There is no server-of-record — the files are the record
The UI and any external tool reach the same files through the same discipline. The data root defaults to ~/.threlmark — home-based, because it’s a shared hub every one of your apps points at.
├─ threlmark.json # manifest
├─ links.json # dependency graph
├─ projects//
│ ├─ project.json # meta + wipLimits
│ ├─ board.json # lane ordering
│ ├─ items/.json # ONE card per file ← source of truth
│ ├─ suggestions/ # the Inbox (drop-zone)
│ ├─ handoffs/ # recorded agent handoffs
│ ├─ reports/ # agent report drop-zone
│ └─ ROADMAP.md # human-readable mirror
├─ shared/items/ # cards many projects ref
└─ archive/ # archived, still readable
Inspectable
Every artifact is a file you can cat, diff, grep, commit.
Portable · no lock-in
Back up with cp, sync with Dropbox / git, migrate trivially.
Interoperable
Any tool in any language joins by reading / writing files.
Restartable
No in-memory state to lose — stateless over the files.
Two disciplined patterns instead of a database
“Just use files” is easy to get wrong. These two patterns — ported from a battle-tested sibling app — are what make file-based state sound rather than reckless.
Atomic writes
Write to a temp file in the same dir, then rename() over the target. Rename is atomic on one filesystem — a crash mid-write leaves the complete old file or the complete new one, never a half.
→
fsync
→
rename() over target
The board heals itself
A single roadmap.json array races when two tools write at once. One file per card makes writes collision-free. Lane order lives in board.json and reconciles on read.
The numbers can’t drift from the files
Anything computable from item state is computed — so the displayed numbers can never disagree with the underlying JSON. Priority is the clearest example: it’s calculated on read, never persisted.
priority — computed on read
Impact weighted heaviest; effort the only axis that subtracts. Reused verbatim from the original tool, so imported cards rank identically.
→
29
A handoff is a first-class flow event
The genuinely 2026-shaped part: most building is done by AI agents, so Threlmark closes the loop. Watch a card go from ranked to Done without anyone dragging it.
Handoff → report → self-move
The brief carries a reporting protocol. The agent reports through REST or the filesystem — and a done report moves the card itself.
POST /api/projects/:id/
items/:itemId/report
Direct call. Applied immediately.
drop reports/.json
→ ingested on read
Robust even if the server’s down at finish time.
claude done: price-drop alerts shipped · typecheck + lint + build passed — card moved to Done
A small formula, and an honest hosting caveat
Because items are globally addressable (/), the Portfolio ranks everything together by a status-weighted score — finishing beats starting, blockers get a boost.
Portfolio ranking — status-weighted
In-flight work floats to the top; bottlenecks cost the most, so blockers get nudged up.
Static read-only demo
Seeded data, writes to localStorage. Try-before-you-clone.
Personal Node instance
Password-gated, persistent backed-up THRELMARK_DATA_DIR.
Multi-tenant SaaS
Add accounts + per-tenant isolation. A separate build.
Advantages of a Disk-Based, Serverless Architecture
This approach offers multiple benefits: all artifacts are inspectable via simple file commands, making it easy to back up, migrate, or integrate with other tools. Its interoperability enables any program that can read and write files to participate, and its restartability ensures no in-memory state is lost, making the system resilient and straightforward to maintain. By avoiding a database, Threlmark simplifies data integrity and collaboration, especially for users who prefer local control and portability over cloud reliance.
The Shift Toward Local-First Project Management
Traditional project management tools often depend on centralized servers or cloud services, which can fragment data and introduce lock-in. Threlmark’s design aligns with broader trends toward local-first software, emphasizing user control, data portability, and resilience. Its architecture draws from established file-based systems, implementing atomic operations and tolerant merging to ensure safety and compatibility. This design responds to a need for flexible, open, and interoperable project management workflows, especially for developers and power users who prefer local control.
“The fundamental idea is that the disk itself becomes the API, with no server needed. This makes the system portable, inspectable, and resilient—traits that are essential for modern, flexible workflows.”
— Thorsten Meyer, creator of Threlmark
Remaining Questions About Threlmark’s Implementation
While the architecture is clearly defined, it is not yet confirmed how well it performs at scale or under heavy concurrent modifications. Details about user adoption, integration with existing tools, and long-term data management are still emerging. Additionally, the effectiveness of the system’s self-healing and reconciliation mechanisms in complex, multi-user environments remains to be tested in real-world scenarios.
Next Steps for Adoption and Development
Threlmark plans to release the system publicly, inviting community testing and feedback. Future updates may focus on enhancing automation, expanding external tool integrations, and refining the reconciliation process. Monitoring how users adopt this local-first approach will be key to understanding its practical benefits and limitations in diverse workflows.
Key Questions
How does Threlmark handle concurrent updates from multiple tools?
It uses atomic file writes and a self-healing, read-reconcile approach to ensure consistency without locks, allowing multiple tools to modify individual JSON files safely.
Is there a central server or cloud dependency in Threlmark?
No, the entire system relies on files stored locally on disk, with no server or cloud required, making it highly portable and user-controlled.
Can external tools participate in managing project data?
Yes, any tool that can read and write JSON files in the specified directory structure can participate, enabling flexible integration.
What are the main benefits of a file-based, local-first system?
Benefits include inspectability, easy backup and migration, interoperability, restartability, and avoiding lock-in or vendor dependency.
What remains uncertain about Threlmark’s architecture?
Its performance at scale, handling of multi-user conflicts, and long-term data management strategies are still to be demonstrated in real-world use.
Source: ThorstenMeyerAI.com