📊 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 introduces a local-first, disk-based architecture where JSON files serve as the definitive data source. This design enables portability, interoperability, and safety without relying on a database, transforming project management tools.
Threlmark has revealed a novel architecture for its project management system that uses on-disk JSON files as the sole record of truth, eliminating the need for a server or database. This approach, rooted in a simple yet powerful design choice, makes the system highly portable, interoperable, and restartable, marking a significant shift in how project data can be managed locally. You can learn more about this architecture in Disk Is the Contract: Inside Threlmark’s Local-First Architecture.
The core of Threlmark’s design is that all project data resides in plain JSON files stored on the user’s disk, with the directory layout serving as an API contract. The root directory, typically ~/.threlmark, contains a manifest file (threlmark.json), a dependency graph (links.json), and project-specific folders with metadata, lane orderings, and individual item files. External tools and AI agents can read and write these files directly, enabling seamless integration without a central server or cloud backend.
This architecture emphasizes four properties: inspectability, portability, interoperability, and restartability. Each artifact is a standalone file, making it easy to review, back up, or migrate data. The system’s file operations are designed to be atomic, ensuring data integrity even during crashes. It uses atomic renames for writes and tolerant read-merge patterns that preserve unknown fields, facilitating forward compatibility and safe updates.
By structuring data as one file per item, Threlmark avoids concurrency issues common with monolithic JSON arrays. The self-healing board view reconciles its state against actual files on each read, automatically updating lane contents and removing missing items. This design allows external tools to modify project data safely and without conflicts, supporting multi-tool workflows and AI automation.
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.
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.
![Free Fling File Transfer Software for Windows [PC Download]](https://m.media-amazon.com/images/I/41Vq6ZqHfjL._SL500_.jpg)
Free Fling File Transfer Software for Windows [PC Download]
- User-Friendly FTP Interface: Intuitive and easy to navigate
- Reliable Site Maintenance: Ensures stable FTP connections
- Automation & Sync: Automates transfers and keeps files in sync
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
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.
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.
board.json. It writes an item file — the board fixes itself on Threlmark’s next read. Unknown keys are preserved, so the contract is forward-compatible.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.
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/reportDirect call. Applied immediately.
drop reports/.json
→ ingested on read Robust even if the server’s down at finish time.
A small formula, and an honest hosting caveat
Because items are globally addressable (
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.
src/lib/*/store.ts is the natural seam — the same boundary that keeps the local tool simple is the one you’d extend for multi-tenancy. The architecture doesn’t fight that future; it just doesn’t pay for it until you need it.
Transforming Project Data Management Without a Server
This approach challenges the conventional reliance on centralized databases and cloud services for project management, offering a lightweight, open, and resilient alternative. By making data portable and accessible through simple file operations, Threlmark enables users and developers to fully control their project information, reduce lock-in, and facilitate integrations with a variety of tools and AI agents. This could influence future design patterns for local-first applications, emphasizing data transparency and safety.
The Evolution of Local-First and File-Based Systems
Traditional project management tools often depend on cloud servers, databases, or proprietary formats, which can hinder portability, transparency, and control. Threlmark’s architecture builds on a broader movement towards local-first and offline-capable applications, emphasizing user ownership of data. Its design draws from proven patterns like atomic file operations and tolerant merging, applied here to create a robust, multi-tool ecosystem centered on disk-based state management. This development aligns with ongoing efforts to make software more open, interoperable, and resilient against data loss or vendor lock-in.
“The key decision was to make disk the contract — the source of truth — so that external tools can participate seamlessly without a central server.”
— Thorsten Meyer, creator of Threlmark
Unresolved Questions About Threlmark’s Scalability and Adoption
It is not yet clear how well this disk-based architecture performs with very large projects or in multi-user environments. The approach’s scalability, in terms of handling thousands of items or collaborative editing scenarios, remains to be tested. For more insights, see Disk Is the Contract: Inside Threlmark’s Local-First Architecture. Additionally, the level of community adoption and integration with existing tools is still emerging, and broader industry validation is pending.
Next Steps for Threlmark and Its Ecosystem
Threlmark plans to release more detailed documentation and potentially develop plugins or integrations that leverage its file-based API. To explore related concepts, check out Disk Is the Contract: Inside Threlmark’s Local-First Architecture. Future updates may include performance optimizations, multi-user support, and broader ecosystem tools that can read and modify project data directly. Observers will monitor how this architecture influences local-first workflows and whether it gains traction among developers and teams seeking open, portable project management solutions.
Key Questions
How does Threlmark ensure data safety without a database?
Threlmark uses atomic file operations, writing to temporary files and renaming them atomically, which prevents corruption even during crashes. It also employs tolerant read-merge strategies that preserve unknown fields, ensuring safe updates and forward compatibility.
Can external tools modify Threlmark data?
Yes, since all data is stored as plain JSON files in a standardized directory structure, external tools can read and write these files directly, enabling seamless integration without proprietary formats or APIs.
Is this approach suitable for large or collaborative projects?
While promising for small to medium projects, scalability and multi-user collaboration are still unproven at large scale. Further testing and development are needed to assess its effectiveness in such scenarios.
How does this architecture compare to traditional cloud-based tools?
Unlike cloud-based tools that rely on remote servers and databases, Threlmark’s local-first, disk-based approach offers full data ownership, portability, and resilience, reducing dependency on external services and vendor lock-in.
Source: ThorstenMeyerAI.com
