📊 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 employs a unique local-first architecture where JSON files on disk serve as the definitive data source, enabling interoperability, safety, and restartability. This approach challenges traditional database reliance and offers new flexibility for project management tools.
Threlmark’s core architectural innovation is that it uses JSON files stored on disk as the single source of truth for its project management system, without relying on a server or database. This design enables high portability, safety, and interoperability, fundamentally redefining how project data is managed and shared.
Threlmark operates as a Next.js application that manages project data through a structured directory of JSON files stored locally, primarily in the ~/.threlmark folder. The key design decision is that the disk layout itself functions as the API, with each project, card, and artifact represented by individual JSON files. This approach removes the need for a centralized server or database, making the system inherently portable and restartable.
The system uses atomic file writes—writing to temporary files and renaming them atomically—to ensure data integrity even during crashes. Updates are performed through read-merge-write cycles, preserving compatibility with future extensions by tolerating unknown fields and maintaining a forward-compatible contract. External tools can read and write these files directly, enabling seamless integration without permission barriers or proprietary formats.
This architecture also includes mechanisms for self-healing and consistency. For example, lane ordering is stored separately and reconciled with actual items upon each read, automatically correcting discrepancies without manual intervention. Shared items and archived projects are organized in dedicated directories, maintaining clarity and accessibility across multiple projects.
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.
JSON file editor for Windows
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.portable project management software
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
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.
atomic file write tools
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
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.
local-first data storage solutions
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
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.
Advantages of Disk-Based Data Management in Threlmark
This approach offers several significant benefits: every artifact is inspectable and diffable, making debugging and version control straightforward; data portability is enhanced, allowing easy backups, migrations, and tool integrations; and the system’s restartability ensures no in-memory state is lost, increasing reliability. By avoiding a traditional database, Threlmark demonstrates a new paradigm where simplicity and transparency support robust project management and AI integration.
Traditional vs. Disk-First Data Architectures
Most project management tools rely on centralized databases or cloud services to store state, which can introduce lock-in, complicate backups, and hinder interoperability. Threlmark, by contrast, embraces a local-first philosophy, inspired by battle-tested file-based systems, where the directory structure and JSON files serve as the definitive data source. This design aligns with the broader trend toward decentralized, user-controlled data management and supports AI-driven automation by providing a clear, accessible data contract.
Prior efforts in local-first architectures have struggled with data integrity and concurrency issues. Threlmark addresses these with atomic file operations and a tolerant merge strategy, ensuring safe concurrent updates and forward compatibility. Its architecture is a deliberate departure from traditional server-centric models, emphasizing control, transparency, and extensibility.
“The core idea is that the disk layout itself is the API, making the data portable, inspectable, and safe without a server or database.”
— Thorsten Meyer, creator of Threlmark
Remaining Questions About Threlmark’s Scalability and Extensibility
While the architecture demonstrates clear benefits, it remains to be seen how well it scales with very large projects or complex multi-user environments. The system’s reliance on local files may pose challenges for collaborative workflows across multiple devices or users, and integration with existing enterprise tools is still under exploration. Additionally, the long-term management of schema evolution and conflict resolution in highly concurrent scenarios is not fully documented.
Future Developments and Community Adoption of Threlmark’s Architecture
Thorsten Meyer and the Threlmark team plan to continue refining the system, focusing on multi-user support, enhanced automation, and broader integrations. Community feedback and real-world testing will inform how the architecture can be adapted or scaled for larger teams and more complex workflows. Additionally, open-source contributions and documentation are expected to improve accessibility and understanding of the approach.
Key Questions
How does Threlmark ensure data safety without a database?
Threlmark employs atomic file writes—writing to a temporary file and then renaming it atomically—to prevent corruption during crashes. It also uses read-merge-write cycles with tolerant normalization to preserve data integrity and forward compatibility.
Can Threlmark handle multiple users working on the same project?
Currently, Threlmark’s architecture is optimized for single-user or local workflows. Support for multi-user collaboration across devices is an area for future development, and how well it scales in such scenarios remains to be seen.
How does this architecture compare to traditional cloud-based project tools?
Unlike cloud-based tools that rely on centralized servers and databases, Threlmark’s local-first approach offers greater control, transparency, and portability, but may require additional setup for collaborative or multi-device workflows.
What are the main benefits of using disk as the contract?
Using disk as the contract makes data inspectable, portable, interoperable, and restartable. It simplifies backups, migrations, and integrations, and removes dependencies on proprietary or cloud services.
Source: ThorstenMeyerAI.com
