📊 Full opportunity report: Disk Is the Contract: Inside Threlmark’s Local-First Architecture on ThorstenMeyerAI.com — validation score, market gap, and execution plan.
Get smart everyday buys delivered free — and shop member deals
- Fast, free delivery on millions of items
- Access to Prime Big Deal Days deals on October 6–7
- Prime Video, Amazon Music and more included
TL;DR
Threlmark’s new approach uses disk-based JSON files as the central data contract, avoiding databases and enabling seamless multi-tool integration. This design emphasizes portability, safety, and external participation.
Threlmark’s latest architecture design centers on using disk-stored JSON files as the definitive source of truth, eliminating the need for a server or database. This approach allows external tools and AI agents to interact directly with project data, making workflows more portable, safe, and open.
Threlmark is built as a Next.js app that manages project data entirely through files stored on disk, specifically JSON files in a designated directory (~/.threlmark). The core principle is that the disk layout itself functions as the API, with no server or cloud dependency. This design choice enables multiple tools to read and write data directly, fostering interoperability and avoiding vendor lock-in. The main directory contains a manifest (threlmark.json), dependency graphs (links.json), and per-project folders housing metadata, lane configurations, and individual task cards as separate files. External suggestions, agent reports, and handoffs are stored in dedicated subfolders, maintaining a clear, inspectable structure. Safety is achieved through atomic file writes—writing to temporary files before renaming to prevent corruption—and through a read-merge-write process that preserves data integrity and forward compatibility. The system’s architecture ensures restartability, as all state is stored in files, not memory, enabling seamless recovery and migration.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.
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/<file>.json
→ ingested on readRobust even if the server’s down at finish time.
A small formula, and an honest hosting caveat
Because items are globally addressable (<projectId>/<itemId>), 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.
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.
Why Disk-Based Data Matters for Project Management
This architecture shifts the paradigm of project management tools by prioritizing data portability, transparency, and external collaboration. It enables users to integrate their workflows with external tools and AI agents without relying on proprietary servers or lock-in, fostering a more open ecosystem. Additionally, the safety mechanisms reduce risks of data corruption, making workflows more reliable. For developers and organizations, this approach simplifies backup, migration, and interoperability, potentially influencing future design choices in productivity tools.JSON file editor for project management
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
The Evolution of Local-First Architectures in Productivity Tools
Traditional project management tools often depend on centralized servers, databases, or cloud services, which can limit portability and control. Threlmark’s approach builds on the growing trend of local-first software, emphasizing user ownership of data and resilience. Its design echoes principles seen in other file-based systems, but applies them specifically to complex workflows involving AI agents and multi-tool integrations. The decision to treat the disk layout as the API is a deliberate departure from conventional database-driven architectures, aiming to empower users and developers alike.“The core idea is simple: the on-disk layout is the API, which cascades into how concurrency, external participation, and AI automation are handled.”
— Thorsten Meyer
As an affiliate, we earn on qualifying purchases.
Unresolved Questions About External Tool Integration
While the architecture is designed for openness, it is still unclear how extensively external tools and third-party AI agents are currently integrated or how they will evolve in practice. The robustness of conflict resolution and security measures in collaborative scenarios remains to be tested in real-world use cases.As an affiliate, we earn on qualifying purchases.
Next Steps for Broader Adoption and Tool Support
Threlmark plans to release detailed documentation and examples to facilitate external tool integration. Future development may include formal APIs or plugins to streamline collaboration, as well as user feedback to refine safety and concurrency mechanisms. Monitoring how the community adopts and adapts this architecture will shape its evolution.As an affiliate, we earn on qualifying purchases.
Key Questions
How does Threlmark ensure data safety without a database?
It uses atomic file writes—writing updates to temporary files before renaming them—and a read-merge-write process that preserves data integrity and forward compatibility.
Can external tools modify project data without conflicts?
Yes, since each task card is stored as a separate JSON file, external tools can update individual items atomically without race conditions, and the system self-heals lane ordering on read.
What are the advantages of this disk-based approach?
It offers portability, transparency, interoperability, and restartability, enabling easy backups, migrations, and integrations with any tool that can read or write JSON files.
Is this architecture suitable for large or complex projects?
The design is optimized for small to medium-sized workflows where transparency and external collaboration are priorities. Scalability considerations are still under exploration.Source: ThorstenMeyerAI.com
Fall Picks
fall essentials
As an affiliate, we earn on qualifying purchases.
