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’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 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 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

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.

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
Amazon

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.

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
Amazon

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.

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
Amazon

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.

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 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

You May Also Like

Best Thermal Paste and Pads for High-TDP GPUs

Top thermal interface materials for high-TDP GPUs, including long-lasting pastes and reusable pads, ideal for 24/7 AI workloads and sustained use.

Best Low-Noise PC Cases for Airflow and Sound Dampening

Explore top PC cases balancing airflow and sound dampening, ideal for high-power workstations and quiet setups. Updated for 2026 with expert insights.

When a Content Network Starts Publishing to Itself

A large content network’s automated system began publishing heavily to a few sites, neglecting others, revealing systemic issues in distribution logic.

Cybersecurity operations signal monitor: A backdoor in a LinkedIn job offer

Cybersecurity researchers identified a backdoor in a LinkedIn job posting, raising concerns about targeted cyber threats and organizational vulnerabilities.