📊 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 local disk as the primary data source, avoiding traditional databases. This design simplifies synchronization, improves offline capabilities, and enhances data portability. The system relies on files and directory structures as the contract for data integrity.
Threlmark has introduced a novel local-first architecture where the disk becomes the definitive source of truth, eliminating the need for traditional databases or cloud servers. This approach is detailed in the original analysis. This approach emphasizes direct file-based data management, making systems more resilient, portable, and easier to inspect. The development aims to simplify data synchronization, improve offline usability, and foster interoperability across tools.
The core of Threlmark’s design is that each piece of data, such as project cards or metadata, is stored in individual files within a structured directory layout. These files are updated atomically—first written to a temporary file, then renamed—to prevent corruption during crashes or interruptions. The directory structure itself acts as an explicit contract, providing transparency and enabling external tools to read or modify data without proprietary interfaces.
This system leverages one file per item, reducing race conditions and simplifying concurrency management. For a deeper dive into this architecture, see Disk Is the Contract: Inside Threlmark’s Local-First Architecture. When a user edits a card, only that specific file updates, avoiding conflicts with other simultaneous edits. The architecture also incorporates self-healing mechanisms that reconstruct views from individual files, ensuring consistency even if some files are missing or corrupted. Developers highlight that this approach enhances offline capabilities and data portability, as users can directly manipulate plain files or integrate with other tools that respect the directory structure.
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.
offline file-based data storage solutions
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 disk storage for data synchronization
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.
JSON file management 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.
version control for local files
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 Treating Disk as the Single Source Matters
This shift fundamentally changes how data persistence and collaboration are handled in project management tools. By avoiding centralized databases, Threlmark reduces vendor lock-in and increases transparency. Users can work offline without losing data, and external tools can seamlessly read or modify project files, fostering a more open ecosystem. The approach also enhances system resilience, as data remains accessible even if the application crashes or disconnects from the internet.
However, this model introduces new challenges, such as managing concurrent file edits and ensuring data consistency. Developers must implement robust conflict resolution and atomic write techniques. Overall, this design promotes faster, more reliable, and more flexible systems, aligning with the principles of local-first software.
The Evolution of Data Storage in Project Tools
Traditional project management applications rely heavily on centralized databases and cloud servers, which can lead to vendor lock-in, synchronization issues, and offline limitations. The benefits of local-first design are explained in Disk Is the Contract: Inside Threlmark’s Local-First Architecture. Recent movements toward local-first architectures aim to address these issues by prioritizing local storage and direct file management. Threlmark’s approach aligns with this trend, emphasizing the disk as the ultimate authority for data integrity and accessibility.
Previous efforts in local-first design have used various data formats and synchronization protocols. Threlmark’s innovation lies in formalizing the directory structure as a contract, making data more transparent and easier to extend or integrate with external tools. This approach also benefits from mature file system features like atomic operations and self-healing, reducing complexity compared to centralized solutions.
“Treating the disk as the contract for data simplifies synchronization and enhances offline resilience, making the system more transparent and portable.”
— Thorsten Meyer, Threlmark Developer
Unresolved Challenges and Areas for Further Development
While the architecture offers many benefits, several aspects remain under development or unclear. It is not yet confirmed how well the system handles complex merge conflicts during concurrent edits, especially in collaborative environments. The scalability of managing many small files on large projects is also still being evaluated. Additionally, the robustness of self-healing mechanisms in diverse failure scenarios needs further testing.
Developers acknowledge that conflict resolution and conflict detection in a file-based system pose unique challenges compared to traditional databases, and solutions are still evolving.
Future Steps for Threlmark’s Local-First System
Threlmark plans to refine conflict resolution strategies and improve the robustness of its self-healing processes. The team aims to develop tooling that simplifies manual conflict resolution and provides better visibility into data integrity. They also intend to explore larger-scale deployments to assess performance and reliability. Community feedback will likely shape future enhancements, especially around collaboration features and integration with external tools.
Key Questions
How does Threlmark ensure data consistency with files?
Threlmark employs atomic write operations—writing to temporary files before renaming—to prevent corruption. It also uses tolerant merging strategies to handle concurrent edits and missing data gracefully.
Can external tools modify Threlmark data?
Yes, the explicit directory structure acts as a contract, allowing external tools to read and write data directly, provided they follow the established format.
What are the main benefits of this approach?
It improves offline usability, reduces vendor lock-in, simplifies data inspection, and enhances data portability across tools.
What challenges does this architecture face?
Managing concurrent file edits, conflict resolution, and scaling with large projects are ongoing challenges that developers are actively addressing.
Source: ThorstenMeyerAI.com
