Disk Is the Contract: Inside Threlmark’s Local-First Architecture

📊 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 adopts a local-first architecture where disk storage is the definitive data source, allowing for portable, restartable, and interoperable project management. This approach eliminates the need for a central server or database.

Threlmark has implemented a pioneering local-first architecture that makes disk storage the definitive source of truth for project data, eliminating the need for a server or cloud database. This design choice enables a highly portable, restartable, and interoperable system that manages project flow entirely through files on disk, fundamentally shifting how project tools can operate without centralized infrastructure. Disk Is the Contract: Inside Threlmark’s Local-First Architecture

The core of Threlmark’s approach is that all project data resides in plain JSON files stored locally, with the filesystem layout serving as the API. This includes a manifest, dependency graph, project metadata, and individual roadmap cards, each stored as separate files. The system’s architecture ensures that every artifact is inspectable, portable, and compatible across tools and environments, as there is no reliance on a database or cloud services.

Two key patterns uphold data safety: atomic file writes, which prevent corruption during crashes, and read-merge-write updates, which preserve data integrity and forward compatibility. The design also features a self-healing board that reconciles actual files with project state, automatically handling missing or removed items without conflicts, ensuring consistency and resilience.

Disk is the contract: inside Threlmark’s architecture — ThorstenMeyerAI.com
ThorstenMeyerAI.com
Threlmark · Technical Deep-Dive
Threlmark · 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.

Next.js · TypeScript · JSON-on-disk · MIT · part 2 of the Threlmark series
01The core decision

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.

~/.threlmark/ ├─ threlmark.json # manifest ├─ links.json # dependency graph ├─ projects// │ ├─ project.json # meta + wipLimits │ ├─ board.json # lane ordering │ ├─ items/.json # ONE card per file ← source of truth │ ├─ suggestions/ # the Inbox (drop-zone) │ ├─ handoffs/ # recorded agent handoffs │ ├─ reports/ # agent report drop-zone │ └─ ROADMAP.md # human-readable mirror ├─ shared/items/ # cards many projects ref └─ archive/ # archived, still readable

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.

02Making files safe
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

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

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.

Pattern 1

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.

write .tmp-pid-rand fsync rename() over target
Pattern 2 · one file per item

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.

The payoff: an external tool never touches 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.
03Derived, never stored
Free Fling File Transfer Software for Windows [PC Download]

Free Fling File Transfer Software for Windows [PC Download]

Intuitive interface of a conventional FTP client

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.

priority = max(0, round(impact·3 + evidence·2 + fit·2effort·1.5))
a 5 / 5 / 5 / 4 card 29
work-item age
now − lane-entry time. Past threshold (dev 7d, ranked 21d, idea 60d) → stale.
cycle time
first DevelopmentDone. Derived from append-only transitions[].
throughput
items reaching Done per ISO week, 8-week window.
WIP
count per lane; over the cap shows 3 / 2 in red.
04The closed agent loop · press play
Real-World Android App Projects with Kotlin and Jetpack Compose: Build Production-Style Android Apps with Modern Architecture, API Integration, State Management, Local Data Storage, Practical Projects

Real-World Android App Projects with Kotlin and Jetpack Compose: Build Production-Style Android Apps with Modern Architecture, API Integration, State Management, Local Data Storage, Practical Projects

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.

Ranked
Add price-drop alertsscore 31 · ready
Development
Handed off 🤖
Done
▶ preferred — REST
POST /api/projects/:id/
items/:itemId/report

Direct call. Applied immediately.

▶ fallback — filesystem
drop reports/.json
→ ingested on read

Robust even if the server’s down at finish time.

🤖 claude done: price-drop alerts shipped · typecheck + lint + build passed — card moved to Done
05Portfolio score & deployment
Backup Pro 27 - Backup solution - Image Backup - Data backup programme, rescue in case of malware attack, defective hard drive or Windows crashes - compatible with Windows 11, 10

Backup Pro 27 – Backup solution – Image Backup – Data backup programme, rescue in case of malware attack, defective hard drive or Windows crashes – compatible with Windows 11, 10

Backup, save and restore data – it's easy! Rescue in the event of a malware attack, defective hard…

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.

score = priority · statusWeight (+ 0.1 · blockedCount · priority)
1.3
development
1.0
ranked
0.85
idea
0.15
done
Path 1

Static read-only demo

Seeded data, writes to localStorage. Try-before-you-clone.

Path 2

Personal Node instance

Password-gated, persistent backed-up THRELMARK_DATA_DIR.

Path 3

Multi-tenant SaaS

Add accounts + per-tenant isolation. A separate build.

The elegant part: the store interface 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.
ThorstenMeyerAI.com
Threlmark · open source (MIT) · github.com/MeyerThorsten/threlmark · part 2 of a series · file layout, formula, weights & agent-loop channels are Threlmark’s actual mechanics.

Why Disk as the Single Source of Truth Matters

This architecture radically reduces dependencies on centralized servers, enabling users to maintain complete control over their project data. It enhances portability—users can back up, sync, or migrate their data easily—and fosters interoperability, allowing diverse tools to participate by simply reading and writing files. This approach also improves resilience, as the system is restartable and not reliant on in-memory state, which is crucial for long-term project management and automation with AI agents.

By avoiding traditional databases, Threlmark demonstrates a model where simplicity, transparency, and user control are prioritized. This could influence future project management tools, especially in environments where privacy, portability, and local control are paramount.

Background of Threlmark’s Local-First Design Principles

Traditional project management tools often depend on centralized servers or cloud services, which can fragment data, complicate portability, and introduce reliance on external providers. Threlmark’s design builds on the idea of a single-product roadmap, initially a localStorage-based kanban, and extends it into a multi-project hub that emphasizes data openness and flow management. The concept of ‘disk as the contract’ stems from a desire to simplify architecture, improve resilience, and enable external tools and AI agents to participate seamlessly by reading and writing files directly.

This approach aligns with broader trends toward local-first software, where user data remains on their device and is accessible without network dependencies, but with added emphasis on project flow and automation.

“The on-disk layout is the API. That one choice cascades into everything else—how concurrency is handled, why there’s one file per card, and how external tools can participate without permission.”

— Thorsten Meyer

Remaining Questions About Threlmark’s Architecture

While the architecture is well-documented, it is not yet clear how this approach performs at scale or in complex multi-user environments. Details about how external tools and AI agents handle conflicts or concurrent modifications in real-world scenarios are still emerging. Additionally, more information on Threlmark’s architecture and the long-term stability and community adoption of this file-based model remain to be seen.

Next Steps for Adoption and Development

Further testing and real-world deployments will clarify the robustness of Threlmark’s architecture. Developers and users can expect updates on how external tools integrate, how the system manages larger projects, and potential enhancements to automate workflows. The project’s open design invites community participation to refine and extend its capabilities.

Key Questions

How does Threlmark ensure data safety without a database?

Threlmark uses atomic file writes, where data is written to a temporary file and renamed atomically, preventing corruption during crashes. It also employs read-merge-write patterns to preserve data integrity and forward compatibility.

Can external tools modify Threlmark data?

Yes, since all data is stored as plain JSON files, any tool that can read and write files can participate, making the system highly interoperable.

What are the advantages of this local-first approach?

It offers portability, resilience, transparency, and user control. Data can be backed up, migrated, or synced easily, and the system does not depend on external servers or cloud services.

Is this approach scalable for large projects?

Scalability at large scale is still under observation. While the design is promising for small to medium projects, real-world testing will determine its effectiveness for larger, more complex workflows.

Source: ThorstenMeyerAI.com

You May Also Like

FAANG Simulator

A new tool called FAANG Simulator aims to help investors model potential outcomes of investing in Facebook, Apple, Amazon, Netflix, and Google stocks.

999% Uptime: Myth vs. Achievable Goal?

Discover why aiming for 99.9% uptime may be more myth than reality and what truly makes systems resilient.

Establishing a Quality Policy for Your Software Team

Navigating the steps to establish a robust quality policy can dramatically improve your software team’s success; learn how to implement effective strategies now.

RHEO On The Web: Find Your Flow

Discover RHEO’s web version — a private, instant, browser-based fluid simulation for calm, breathing, and creative play, accessible without downloads.