📊 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 architecture uses the local disk as the primary data contract, avoiding traditional databases and enabling resilient, portable, and offline-capable project management. This approach shifts complexity to file integrity and concurrency handling.
Threlmark has adopted a novel architecture where the local disk is treated as the definitive source of truth for all data, foregoing traditional databases. This design simplifies synchronization, enhances offline usability, and makes data portable across tools, marking a significant shift in how project management systems can operate. For a detailed overview, see the original analysis.
Threlmark’s approach centers on storing each data item as a separate file within a structured directory layout, with atomic file operations ensuring data safety. This method eliminates reliance on centralized databases or cloud servers, allowing users to edit files directly with any text editor and see changes reflected system-wide. The system employs techniques like atomic writes—writing to temporary files before renaming—and tolerant merging to handle concurrent edits and prevent data corruption. The directory structure itself acts as a formal contract, enabling external tools to read and modify data without special permissions, fostering interoperability and extensibility. This architecture offers resilience against crashes and network failures, as data remains accessible and consistent through file-based synchronization. However, managing many small files introduces filesystem overhead and requires careful design of directory layouts and update logic to prevent conflicts and maintain performance.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 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.file-based data synchronization 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.
atomic file write utilities
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 disk storage management 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 Treating Disk as the Single Source of Truth Is a Game-Changer
This approach fundamentally alters the way data persistence and collaboration are handled in project management tools. By removing the dependency on centralized databases or cloud services, Threlmark offers a system that is more resilient to failures, easier to extend, and free from vendor lock-in. Users can work offline seamlessly, and data portability is enhanced, making the system suitable for diverse workflows and environments. While shifting complexity to file integrity and concurrency control, this design enables faster, more transparent, and more flexible tools that can adapt to various external integrations and user needs.
The Evolution of Data Storage in Local-First Tools
Traditional project management systems rely heavily on centralized databases or cloud-based storage, which can introduce points of failure, vendor lock-in, and limited offline capabilities. The concept of local-first architecture has gained traction as a way to address these issues, emphasizing local storage, data portability, and resilience. Threlmark’s implementation builds upon these principles by treating each data item as a separate file, with the entire system governed by a clear directory structure acting as a formal data contract. This approach aligns with broader trends in the software community that favor transparency, user control, and offline-first capabilities, but it also introduces new challenges in managing file-based concurrency and consistency.
“Treating the disk as the contract means every piece of data lives in a file, making the system more resilient, portable, and transparent.”
— Thorsten Meyer, Threlmark developer
Unresolved Challenges in File-Based Data Management
While Threlmark’s approach offers many advantages, it remains unclear how well it scales with very large datasets or complex concurrency scenarios. Managing numerous small files can introduce filesystem overhead, and manual conflicts or manual edits might lead to inconsistencies if not carefully handled. For more insights, see the original analysis.
Future Developments and Testing of the Architecture
Threlmark plans to further refine its file management techniques, improve conflict resolution algorithms, and develop tools to automate consistency checks. Community feedback and real-world usage will shape future updates, with potential integration of more advanced merge strategies and performance optimizations. Monitoring how the architecture performs at scale and in collaborative settings will be key to understanding its broader applicability.
Key Questions
How does Threlmark handle concurrent edits from multiple tools?
Threlmark employs atomic writes and tolerant merging strategies to manage concurrent edits, reducing the risk of conflicts and data corruption.
Can I manually edit data files without breaking the system?
Yes, since data is stored as plain files, manual editing is possible, but it requires understanding the file structure and potential merge conflicts.
What are the main advantages of this architecture?
It offers improved resilience, offline capability, data portability, and transparency, with reduced reliance on centralized servers or vendor lock-in.
Are there any limitations to using a file-based system?
Managing many small files can introduce filesystem overhead, and conflict resolution in complex scenarios may require additional tooling and careful design.
What is the next step for Threlmark’s development?
The team aims to optimize conflict handling, improve performance at scale, and develop tools for easier manual and automated data management.
Source: ThorstenMeyerAI.com
