📊 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 the definitive data source, avoiding traditional databases. It improves offline usability, data portability, and system transparency, with some challenges in concurrency management.
Threlmark’s new architecture design treats local disk storage as the definitive source of truth, eliminating the need for traditional databases or cloud servers. This approach simplifies data synchronization, enhances offline usability, and ensures data portability, making the system resilient and transparent.
Threlmark’s system operates on a principle where each data item is stored as a separate file on the user’s disk, as detailed in the original analysis. This design allows direct editing, easy inspection, and external tool integration without vendor lock-in. To ensure data safety, Threlmark employs atomic file writes—writing to a temporary file before replacing the original—and tolerant merging to handle concurrent edits and data inconsistencies. The directory structure acts as a formal contract, outlining how data is organized and accessed, which supports interoperability and manual editing. This approach shifts complexity from centralized databases to file integrity and conflict resolution, offering advantages in resilience and flexibility but requiring careful handling of concurrent modifications and filesystem overhead. For more insights, see Disk Is the Contract: Inside Threlmark’s Local-First Architecture.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 2TB 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-2T00-G25
- High-Speed NVMe Performance: Up to 1050MB/s read, 1000MB/s write
- Durable and Water-Resistant: IP65 rated, 3-meter drop protection
- Portable and Secure: Includes carabiner loop for easy attachment
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.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.
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.
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.
Impacts of Disk-First Data Management
This architecture fundamentally changes data persistence and collaboration models by removing reliance on centralized databases. It enhances offline capabilities, data portability, and transparency, which are critical for resilient and flexible tools. However, it introduces challenges in managing concurrent file access and ensuring data consistency, requiring sophisticated conflict resolution mechanisms. For users and developers, this means more control and fewer vendor dependencies but also a need for careful handling of file operations and directory structures.
Background on Local-First and Data Contracts
Traditional project management tools often depend on cloud servers and proprietary databases, which can lead to vendor lock-in and limited offline functionality. The local-first movement advocates for storing data locally and syncing as needed. The local-first movement advocates for storing data locally and syncing as needed, improving resilience and user control. Threlmark’s approach exemplifies this by making the disk the primary data contract, inspired by principles from the local-first paradigm and file-based data management. This design aligns with recent trends toward open, portable, and user-controlled data systems, offering an alternative to monolithic cloud-based solutions.
“Treating the disk as the contract simplifies synchronization and makes data more portable and transparent.”
— Thorsten Meyer, Threlmark Developer
Unresolved Challenges in File-Based Data Handling
It is still unclear how Threlmark plans to handle large-scale data or highly concurrent environments. While atomic writes and tolerant merging address many issues, the system’s performance and conflict resolution strategies under heavy use remain to be fully demonstrated. Additionally, the impact of manual file edits on system stability and data integrity requires further observation.
Future Developments and Adoption Roadmap
Threlmark is expected to release more detailed documentation and tools to support manual editing, conflict resolution, and integration with external systems. User feedback and real-world testing will shape future enhancements, especially around scalability and multi-user collaboration. Monitoring how the system performs in diverse environments will be key to assessing its broader applicability.
Key Questions
How does Threlmark ensure data integrity without a database?
Threlmark employs atomic file writes—writing changes to temporary files before replacing originals—and tolerant merging to prevent corruption and handle concurrent edits.
Can users manually edit data files?
Yes, the directory structure and file-based storage are designed for transparency, allowing manual edits if users understand the data format and structure.
What are the main benefits of this architecture?
It offers offline capability, data portability, system transparency, and resilience against cloud or server outages.
What challenges does this approach face?
Managing concurrent edits, ensuring consistency across many small files, and handling filesystem overhead are key challenges.
Will this system scale to large projects?
Scalability remains an open question; further testing and development are needed to confirm performance in large, complex environments.
Source: ThorstenMeyerAI.com
