📊 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 system design treats local disk storage as the ultimate data contract, avoiding traditional databases. This approach improves offline capability, data portability, and system transparency. The article examines how this architecture functions and its potential benefits and challenges.
Threlmark’s new architecture treats local disk storage as the definitive source of truth, eliminating the need for traditional databases or cloud servers. This approach is discussed in the original analysis. This design allows for simplified synchronization, enhanced offline usability, and greater data portability, marking a significant shift in how project data is managed and maintained.
Threlmark’s approach centers on storing each data item as an individual file within a well-defined directory structure, with atomic write operations ensuring data integrity. This setup enables seamless offline work, easy manual inspection, and external tool integration without vendor lock-in. The architecture emphasizes that the disk itself is the contract: data is directly stored, read, and modified via plain files, avoiding reliance on proprietary databases or cloud services. To safeguard against data corruption, Threlmark employs techniques like atomic file writes—writing to a temporary file before renaming—and tolerant merging that preserves essential fields during updates. The system’s design supports concurrent edits by multiple tools without conflicts, thanks to one-file-per-item management, which reduces race conditions and simplifies recovery from corruption or missing files. The directory structure functions as a formal contract, making the system transparent and extensible, allowing manual edits and external integrations to operate smoothly. For more details, see this internal resource.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.

SANDISK 1TB Extreme Portable SSD (Old Model) – Up to 1050MB/s, USB-C, USB 3.2 Gen 2, IP65 Water and Dust Resistance, Updated Firmware – External Solid State Drive – SDSSDE61-1T00-G25
Get NVMe solid state performance with up to 1050MB/s read and 1000MB/s write speeds in a portable, high-capacity…
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.offline data storage device
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 synchronization software
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 file write 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 (), the Portfolio ranks everything together by a status-weighted score — finishing beats starting, blockers get a boost.
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 Architecture Changes Data Management
This architecture shifts the paradigm of data persistence from centralized databases to a decentralized, file-based approach. It enhances resilience by allowing work to continue offline and simplifies data portability—users can directly manipulate project files with any text editor or external tool. This reduces vendor lock-in and increases transparency, making the system easier to inspect, extend, and troubleshoot. However, it also introduces new challenges in managing file conflicts, ensuring consistency, and handling filesystem overhead. Overall, this design could lead to more reliable, flexible, and user-controlled tools, especially in environments where offline access and data transparency are critical.
Background and Evolution of Local-First Design in Threlmark
Threlmark’s architecture is inspired by the broader local-first movement, which emphasizes storing data locally to ensure offline access, reduce dependency on cloud services, and improve user control. Learn more about local-first principles in this overview. Traditionally, project management tools rely on centralized databases or cloud servers, creating potential points of failure and vendor lock-in. Recent developments in file-based synchronization, atomic file operations, and conflict resolution have made local-first systems more robust and practical. Threlmark’s approach builds on these innovations, applying them to a comprehensive project management solution that prioritizes data transparency and resilience. The system’s design also aligns with trends in open data and interoperability, allowing users and external tools to interact with project data directly through the filesystem.
“Treating the disk as the contract simplifies synchronization and makes data more portable and accessible.”
— Thorsten Meyer, Threlmark developer
Unresolved Challenges and Potential Limitations
While Threlmark’s approach offers many advantages, some aspects remain uncertain. It is not yet clear how well the system handles complex merge conflicts in real-world scenarios or how it scales with very large datasets. Additionally, managing filesystem overhead and ensuring consistent directory structures across multiple tools require careful design. The long-term impact on performance and user experience, especially in collaborative environments, is still being evaluated. Developers and early adopters are testing these limits, but comprehensive data on robustness and scalability is pending.
Future Developments and Adoption Roadmap
Threlmark plans to refine conflict resolution mechanisms and optimize performance for larger datasets. The team is also working on developing best practices for directory structure management and external tool integration. As the system matures, wider adoption by developers seeking resilient, offline-capable tools is expected. Ongoing feedback from early users will inform enhancements, particularly around handling complex merges and scaling. The project aims to demonstrate that a disk-as-contract architecture can serve as a viable alternative to traditional database-driven systems in various productivity and collaboration workflows.
Key Questions
How does Threlmark ensure data consistency with files?
Threlmark employs atomic write operations—writing updates to temporary files before renaming them—to prevent corruption and race conditions. It also uses tolerant merging to preserve essential data fields during updates, ensuring consistency even with concurrent edits.
Can I manually edit project files without breaking the system?
Yes. Threlmark’s directory structure is designed to be transparent, allowing manual edits. However, users should understand the data format and follow best practices to avoid conflicts or corruption.
What are the main tradeoffs of this architecture?
While it offers offline resilience, transparency, and portability, managing many small files can introduce filesystem overhead and complexity in maintaining relationships between files. Conflict resolution and scalability are ongoing challenges.
Is this approach suitable for large or collaborative projects?
It is promising for small to medium projects and environments emphasizing offline work and transparency. Larger or highly collaborative projects may require additional conflict management strategies and performance optimizations.
Source: ThorstenMeyerAI.com