📊 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 local-first architecture makes disk storage the ultimate data contract, removing reliance on databases. This design improves offline capabilities, data portability, and system transparency, with confirmed technical implementations. The approach shifts complexity from centralized systems to file integrity and concurrency management.
Threlmark’s latest architecture treats the local disk as the definitive source of truth, replacing traditional databases with a file-based approach that enhances offline usability, simplifies synchronization, and improves data portability. You can read more about this approach in Disk Is the Contract: Inside Threlmark’s Local-First Architecture.
Threlmark’s system operates on a principle where each data item, such as project cards or metadata, is stored as an individual file on the disk. The system employs atomic write operations—writing to temporary files before renaming—to prevent corruption during crashes or interruptions. This approach ensures data safety and integrity without locking mechanisms.
Furthermore, the directory structure itself acts as an explicit data contract, making the organization transparent and easily accessible for external tools or manual editing. This design enables seamless integration and interoperability, as any tool can read or modify files directly, provided it adheres to the established structure.
Developers have implemented self-healing mechanisms that reconstruct system state by reading individual files, which reduces risk of data inconsistency and simplifies recovery from partial failures. Threlmark’s approach emphasizes local-first principles—prioritizing local storage, offline capability, and user control—over reliance on cloud or centralized databases.
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.
external SSD portable drive
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.high-capacity USB flash drive
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 organization software for disk storage
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.
offline data backup storage
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 Matters
This architecture shifts the paradigm of data management by removing dependency on centralized databases and cloud services, making systems more resilient, portable, and transparent. It allows users to work offline without losing data consistency, and simplifies data recovery and debugging. For developers, it offers a clear, explicit contract for data structure, facilitating integration with external tools and reducing vendor lock-in. However, it also introduces challenges in managing concurrent edits and ensuring conflict resolution, which Threlmark addresses with specific safety patterns.
Background and Evolution of Local-First Data Architectures
Traditional project management tools rely heavily on centralized databases or cloud services, creating dependencies on network connectivity and vendor-specific formats. The concept of local-first architecture has gained traction as a way to improve resilience and user control, as detailed in the original analysis. The concept of local-first architecture has gained traction as a way to improve resilience and user control. Threlmark’s approach is part of this movement, emphasizing that local disk storage can serve as the authoritative data source. This aligns with broader trends in open data, offline-first design, and user sovereignty over data.
Earlier systems often struggled with synchronization conflicts, data corruption, and limited offline functionality. Threlmark’s design addresses these issues by adopting file-based storage, atomic operations, and explicit directory structures, making their system more robust and transparent.
“Treating the disk as the contract fundamentally simplifies synchronization and enhances offline usability, making data more portable and systems more resilient.”
— Thorsten Meyer, Threlmark developer
Remaining Challenges and Open Questions
While Threlmark’s approach has been implemented successfully, it remains unclear how the system handles complex merge conflicts during concurrent edits from multiple tools or users. The scalability of managing many small files and the potential filesystem overhead are also still being evaluated. Additionally, the long-term robustness of self-healing mechanisms in diverse real-world scenarios has yet to be fully tested.
Upcoming Developments and Future Plans
Threlmark plans to further refine conflict resolution strategies and optimize file management for large projects. They are also exploring integrations with external tools to leverage the explicit directory structure as a formal data contract. Monitoring user feedback and real-world deployment will inform future enhancements to improve conflict handling, performance, and usability.
Key Questions
How does Threlmark prevent data corruption during saves?
Threlmark uses atomic write operations, writing data to a temporary file before renaming it to replace the original, ensuring safe updates even during crashes.
Can external tools modify data in Threlmark’s system?
Yes, as long as they adhere to the directory structure and data contract, external tools can read or write files directly, enabling interoperability.
How does Threlmark handle concurrent edits?
The system employs conflict-tolerant merging and self-healing mechanisms, but complex merge conflicts from multiple sources may still require manual resolution.
Is this approach scalable for large projects?
Managing many small files can introduce filesystem overhead, but Threlmark is actively working on optimizing performance for larger datasets.
What are the main advantages of this architecture?
It improves offline usability, data portability, transparency, and resilience, reducing vendor lock-in and simplifying recovery.
Source: ThorstenMeyerAI.com
