📊 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, file-based architecture for project management, where the disk itself is the source of truth. This design enables portability, safety, and interoperability without relying on a cloud or database. The system’s core is a simple on-disk layout that manages flow and external integrations seamlessly.
Threlmark has unveiled a new architecture that makes the local disk the authoritative source for project data, eliminating the need for servers or cloud storage. This approach allows external tools and AI agents to interact directly with JSON files on disk, ensuring data portability, safety, and interoperability, and enabling a self-healing, restartable workflow.
The core of Threlmark’s design is that all project data resides in plain JSON files stored on the user’s disk, specifically in a dedicated directory (~/.threlmark). The system’s key decision is that the disk itself acts as the contract, meaning all external tools, the UI, and AI agents read and write to the same files following a strict discipline. This approach removes reliance on centralized databases or cloud services, instead emphasizing local control and portability.
Files include a manifest (threlmark.json), dependency graphs (links.json), project metadata (project.json), lane configurations (board.json), individual roadmap cards (items/
Two key patterns underpin the safety of this file-based system: atomic writes, achieved through renaming temporary files to prevent corruption during crashes, and read-merge-write updates that preserve data integrity and forward compatibility, allowing newer tools to add fields without breaking existing ones.
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-based project management software
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.local-first project management tools
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.
file-based data backup for project workflows
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.
atomic write file 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.
Why Local-First, File-Based Architecture Matters
This design shifts the paradigm of project management tools by removing dependency on centralized servers, enabling true data portability and user control. You can learn more in Disk Is the Contract: Inside Threlmark’s Local-First Architecture. It allows users to back up, migrate, and integrate their project data with any tool capable of reading JSON files, reducing vendor lock-in. The approach also enhances safety and reliability, as the system is restartable and resilient to crashes, with no in-memory state to lose. For developers and teams, this means more flexible workflows and easier external automation, including AI integration, without complex API or database management.
The Evolution of Project Data Management and Threlmark’s Approach
Traditional project management tools often rely on cloud-based servers or proprietary databases, which can fragment data and limit portability. Many teams use multiple disconnected tools, leading to siloed information and difficulty tracking priorities across projects. Threlmark’s architecture addresses these issues by adopting a local-first philosophy, inspired by principles from file-based systems and open data standards. This approach aligns with recent trends emphasizing user sovereignty over data, interoperability, and resilience, but it is rare in project management software at this scale.
Earlier efforts in local-first design have focused on individual apps or personal productivity tools, but Threlmark extends this philosophy to multi-project roadmaps, managing flow and external AI agents without a central server. The system’s design choices, such as one file per item and self-healing boards, are deliberate responses to concurrency, safety, and interoperability challenges that have historically plagued file-based systems. For more details, see our deep dive into Threlmark’s architecture.
“The core idea is simple: the disk is the API. Every external tool, AI agent, or user interacts with the same set of files, making the entire system transparent, portable, and restartable.”
— Thorsten Meyer, creator of Threlmark
Unanswered Questions About Threlmark’s Architecture Scalability
While the system’s design is well-documented, it remains unclear how Threlmark handles very large projects or high concurrency scenarios in practice. The effectiveness of the self-healing board reconciliation and the performance implications of file-based operations under heavy use are still to be tested at scale. Additionally, the integration with external tools and AI agents is promising but requires further real-world validation to confirm robustness and security.
Next Steps for Adoption and External Integration
Threlmark’s developers plan to release more detailed documentation and potentially open-source parts of the system to encourage community contributions. Future updates may include performance benchmarks, expanded external tool support, and user feedback on managing larger, more complex projects. Observers will watch for real-world case studies demonstrating the system’s scalability and resilience in diverse workflows.
Key Questions
How does Threlmark ensure data safety without a database?
Threlmark uses atomic file writes—writing to temporary files and renaming them atomically—to prevent corruption. It also employs read-merge-write patterns that preserve data integrity and forward compatibility, ensuring safe updates even during crashes.
Can external tools and AI agents modify Threlmark data?
Yes, because all data is stored in plain JSON files, any tool capable of reading and writing JSON can participate, making the system highly interoperable and open to automation.
What are the limitations of this architecture?
Handling very large projects or high concurrency scenarios may pose challenges. The system’s performance and scalability under heavy load are still under evaluation, and real-world testing will clarify these aspects.
Is Threlmark suitable for team collaboration?
While designed for local-first workflows, its portable and open file structure could support collaborative workflows if integrated with synchronization tools, but this is not yet a core feature. Read more about the underlying architecture in this detailed article.
Source: ThorstenMeyerAI.com
