📊 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’s new approach uses disk-based JSON files as the single source of truth, enabling portable, inspectable, and restartable project management without a server. This design aims to improve data control and tool interoperability.
Threlmark has introduced a novel architecture that treats disk-based JSON files as the sole contract for project data, eliminating the need for a server or cloud storage. This approach enables users to manage multi-project roadmaps with complete data portability and resilience, marking a significant shift from traditional cloud-dependent systems.
The core of Threlmark’s design is that all project information, including cards, boards, dependencies, and external suggestions, is stored in plain JSON files within a dedicated directory, defaulting to ~/.threlmark. This directory contains a manifest, dependency graph, project metadata, lane configurations, individual card files, and shared resources, all accessible and modifiable by any compatible tool. The architecture emphasizes four key properties: inspectability, portability, interoperability, and restartability. Each artifact is a simple file that can be viewed, diffed, or backed up with standard tools. The system avoids databases, instead relying on atomic file writes—using temporary files and rename operations—to prevent corruption. Updates to files are performed with read-merge-write cycles, ensuring forward compatibility by preserving unknown fields and accommodating schema evolution.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.
portable JSON file viewer
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.
Real-World Android App Projects with Kotlin and Jetpack Compose: Build Production-Style Android Apps with Modern Architecture, API Integration, State Management, Local Data Storage, Practical Projects
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.
64GB USB Flash Drive for iPhone Photo Stick Thumb Drive, 2-in-1 USB C + USB A, External Storage Jump Drive for Picture Video Data Backup, High Speed Memory Stick USB Drive for iPhone/iPad/Android/PC
Unique design: This flash drive for iphone uses high-quality metal materials and the latest upgraded chip technology. It…
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.
JSON diff and merge tools
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 Disk-Based Data Matters for Project Management
This architecture offers significant advantages in data control and resilience. By avoiding centralized servers, users retain full ownership of their project data, simplifying backups and migrations. The open file format also facilitates integration with other tools and custom workflows, empowering users to build a more flexible and reliable project management environment. This approach could influence future tool design by prioritizing local-first, file-based data models.
The Evolution of Project Data Storage and Threlmark’s Approach
Traditional project management tools often rely on cloud servers or proprietary databases, which can obscure data ownership and complicate backups or integrations. Threlmark’s design draws inspiration from battle-tested file-based systems, emphasizing local storage and atomic operations to enhance safety and interoperability. This approach aligns with broader trends toward local-first applications but is notable for applying these principles to multi-project roadmapping and AI integration, marking a departure from typical SaaS models.
“The on-disk layout is the API, and it’s deliberately home-based rather than repo-relative, making it a shared hub that every app can point to.”
— Thorsten Meyer, Threlmark developer
Remaining Questions About Threlmark’s File-Based System
It is not yet clear how well this architecture scales with very large projects or how it performs under high concurrency. Additionally, the user experience for managing complex dependencies and external integrations remains to be fully tested in real-world scenarios. The long-term stability of schema evolution and compatibility is also still being observed.
Next Steps for Threlmark’s Local-First Architecture Adoption
Threlmark plans to release more detailed documentation and developer tools to facilitate broader adoption and integration. Future updates may include enhanced support for collaborative workflows, more robust conflict resolution, and performance optimizations. Observers will be watching how the system handles larger, more complex projects over time.
Key Questions
How does Threlmark ensure data safety without a database?
It uses atomic file writes—saving data to temporary files and renaming them—to prevent corruption during crashes or interruptions.
Can external tools easily integrate with Threlmark’s data?
Yes, because all data is stored in plain JSON files, any tool that can read and write JSON can participate, making the system highly interoperable.
What are the main advantages of this disk-based approach?
It provides full data ownership, easy backups and migrations, transparency, and resilience against server outages or vendor lock-in.
Is this architecture suitable for large-scale projects?
It remains to be seen how well it scales with very large or highly complex projects, as performance and concurrency are still being evaluated.
Source: ThorstenMeyerAI.com
