TL;DR
Threlmark treats local disk storage as the primary source of truth, enabling offline use, seamless sync, and easy interoperability without relying on a central server. This approach simplifies data management and enhances privacy.
Imagine a project management tool that works perfectly offline, never loses your data, and plays nicely with any other tool you throw at it. That’s what Threlmark achieves with its radical idea: treat your disk as the contract.
By building around plain JSON files stored locally, Threlmark flips the usual cloud-centric model. It’s a system where your data lives on your device first—no server needed, no lock-in, just simple, powerful, and portable.
The question is: how does this actually work? And why should you care? Buckle up—this isn’t just tech talk. It’s a new way to think about data, collaboration, and building smarter apps.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.
Seagate One Touch 8TB External Hard Drive Desktop HDD – USB-C Compatible with Most Windows and macOS, Rescue Recovery (STNB8000400)
No wall warts: Work freely with its bus-powered USB-C. No wall outlet required.
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.
![Free Fling File Transfer Software for Windows [PC Download]](https://m.media-amazon.com/images/I/41Vq6ZqHfjL._SL500_.jpg)
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.
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.
Information Technology Project Management (MindTap Course List)
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.
Key Takeaways
- Treat your disk as the source of truth—your data files are the contract that all tools agree on.
- Use one file per item to avoid conflicts and simplify concurrent edits across devices.
- Atomic writes and tolerant merging protect data integrity and future-proof your system.
- Background sync leverages existing cloud services, removing the need for a dedicated backend.
- Local-first design enhances privacy, reduces backend costs, and makes apps more resilient.
Why Making Disk the Contract Changes Everything
When your data lives on disk, it becomes the ultimate authority. No server, no cloud, just a folder of JSON files that tell your app what to do. This simple shift means your data is always accessible, always under your control.
Take Threlmark. Its entire project structure—cards, links, dependencies—are stored as files. When you open your app, it reads these files directly. No middleman, no database, just raw, inspectable data. For example, editing a task in your project updates a single JSON file. It’s fast, reliable, and transparent.
This approach also makes data portable. You can copy your entire project to a different machine, sync it with Dropbox, or even hand it over to another tool. The data isn’t locked in a proprietary format or cloud service. It’s just files—simple, open, and forever.
Why does this matter? Because it shifts control back to the user. Data ownership becomes straightforward—no vendor lock-in, no opaque cloud silos. Offline access is guaranteed because your data resides locally, and you’re not dependent on network connectivity or proprietary APIs. The tradeoff is that the app must handle data consistency and conflict resolution itself, which can be complex, but this is mitigated by the system’s design choices, like atomic operations and merging strategies. Ultimately, this approach promotes transparency, resilience, and user empowerment.
How Threlmark’s File Layout Turns Disk Into a Living Contract
Threlmark’s design is a masterclass in simplicity. At its core, it’s a directory full of JSON files, each with a specific purpose.
At the top level, you find a manifest (`threlmark.json`) and links (`links.json`). Each project has its own folder with metadata (`project.json`), lane setup (`board.json`), and individual cards (`items/
Need to suggest a new idea? Drop a JSON file into the `suggestions/` folder. Want to record an AI’s handoff? Use the `handoffs/` directory. Every artifact is just a file—inspectable, editable, and versionable.
How does this establish a clear data contract? By defining a consistent and predictable structure, the file layout acts as a shared schema that all tools and processes can rely on. This makes data inspection straightforward—developers and tools can understand the current state directly from the files. Moreover, because files are portable and self-describing, moving data between environments or integrating with other tools becomes trivial. The simplicity of this layout reduces the risk of hidden dependencies, makes debugging easier, and ensures that the data’s integrity is maintained through straightforward file operations. It’s a system that emphasizes transparency and ease of understanding, which are critical for long-term maintainability and interoperability.
Atomic Writes and Tolerant Merging Keep Data Safe and Forward-Compatible
Handling files safely might sound tricky, but Threlmark relies on two key patterns: atomic writes and tolerant merging.
Atomic writes mean you write to a temporary file and then rename it. This way, even if your computer crashes mid-save, you never get half-written data—just the old or the new, never corrupted.
For example, when updating a task, the app first writes to `task.tmp`, then moves it over. It’s quick, reliable, and safe.
The second pattern, tolerant merging, lets you update files without losing unknown data. If a new version adds a field, old tools still read the file without breaking. This forward compatibility is crucial for evolving your app without breaking existing workflows.
Why does this matter? Because in real-world scenarios, systems are rarely perfect. Power outages, crashes, or network issues can corrupt data. By using atomic operations, Threlmark ensures that only complete, valid files are ever read by the app, preventing corruption and data loss. Tolerant merging allows different versions of files to coexist and evolve gracefully, avoiding lock-in to specific schemas or formats. This means your data can grow, adapt, and survive over time without breaking compatibility, making the system resilient and future-proof.
One File Per Item: How It Solves Concurrency and Keeps Your Data Consistent
Instead of storing all tasks in one big list, Threlmark uses one file per item. This simple idea solves a huge problem: race conditions.
Imagine two devices editing the same task at once. If they both tried to update a giant list, conflicts could overwrite each other. But with one file per task, each change is atomic and isolated.
When you save a task, it’s just a quick `rename()` operation—no locks needed. The system then self-heals on read, reconciling the lane order with actual task files.
Why is this important? Because in collaborative environments, conflicts are inevitable. By isolating each item into its own file, Threlmark reduces the scope of potential conflicts, making conflict resolution simpler and more reliable. It also enables offline edits and concurrent modifications without complex locking mechanisms—since each change is atomic, the risk of corruption or overwrites diminishes significantly. In real-world terms, this means teams can work across multiple devices smoothly, with the system intelligently merging changes and maintaining consistency, even in less-than-ideal network conditions.
Sync Without a Server: How Threlmark’s Background Process Keeps Everything in Sync
Threlmark’s secret sauce is its approach to syncing: it’s background, automatic, and doesn’t rely on a central server.
Changes are saved locally, then the system quietly syncs them across devices—using whatever cloud or sync service you prefer. Think Dropbox, Syncthing, or even plain file sharing.
When a device goes offline, it simply keeps working. When back online, the app detects new files, reconciles differences, and updates the project state.
This method relies on the fact that local storage and file-based sync are inherently resilient, but it also introduces challenges around conflict resolution and data consistency. The background process must intelligently detect changes, merge updates, and resolve conflicts without user intervention. This is why Threlmark’s design emphasizes simple, atomic file operations and tolerant merging—so the sync process can be reliable and predictable. The advantage? It removes the need for a dedicated backend, reducing complexity and costs, while still offering seamless collaboration. In real-world scenarios, this means you can work offline, switch devices, and trust that your data will synchronize correctly once reconnected, making the entire system more robust and user-friendly.
Security and Privacy: How Local Storage Protects Your Data
When your data lives on disk, it’s inherently more private. No cloud provider or third-party server has access unless you give it to them.
In Threlmark, all data is stored as plain JSON files on your device. You control what gets shared, and you can encrypt the entire folder if needed.
For example, a developer working with sensitive project info can keep everything encrypted locally, then selectively sync only what’s necessary. No one else can peek at your files without your permission.
This approach aligns with stronger data ownership, giving you peace of mind and control. Because your data isn’t stored on a remote server by default, you’re less vulnerable to breaches or leaks. If you choose to encrypt your files, you add an extra layer of security, making it even harder for unauthorized access. The tradeoff is that you must manage your own security practices, but this tradeoff favors privacy and user control over reliance on third-party providers. In practice, this means you can audit your data, back it up securely, and move it easily—knowing that your privacy is built into the core design of your system.
Why Developers Are Loving Local-First Architecture Now
Developers are increasingly drawn to local-first because it reduces backend complexity and cuts costs. Instead of building and maintaining a massive server, they focus on the local app and background sync.
Threlmark is a perfect example. Its architecture removes the need for a traditional database or API. All core data lives on disk, and sync happens in the background, making the app faster and more resilient.
According to recent trends, this approach also simplifies offline support, conflict handling, and collaboration. Plus, it’s easier to reason about, test, and upgrade.
For example, a startup can roll out a project management tool that works offline from day one, with minimal backend fuss, and easily scale as needed. This shift also democratizes app development—small teams or solo developers can build robust, offline-capable apps without heavy infrastructure investments, fostering innovation and agility in software creation.
Frequently Asked Questions
What does ‘disk is the contract’ mean in practice?
It means your data is stored as plain files on your device, and these files define the entire state of your app. All tools, apps, and processes read and write directly to these files, making your data transparent, portable, and resilient.
How does Threlmark handle conflicts when multiple devices edit the same item?
Threlmark uses one file per item, so each change is atomic. When conflicts occur, the system reads current files, merges changes, and self-heals on read. This reduces conflicts and makes collaboration smooth.
Can Threlmark work without an internet connection?
Absolutely. Since all data is stored locally, you can work offline indefinitely. Sync happens in the background when connected, so your work continues seamlessly.
Is there still a server involved in Threlmark’s architecture?
Threlmark minimizes server reliance. The primary data lives on your disk, and external sync services handle device-to-device communication. The server role is reduced to a passive conduit, not a central authority.
How secure is data stored locally on multiple devices?
Local storage enhances privacy—your data isn’t stored on a remote server unless you explicitly sync it there. You can encrypt files and control access, making it inherently more secure.
Conclusion
Threlmark’s approach proves that sometimes, the simplest idea is the most powerful: make disk the contract, and everything else follows. It’s a straightforward, elegant way to build apps that are robust, private, and easy to extend.
When data lives on your disk, you hold the keys—no lock-in, no middleman. That’s a future worth building for. So ask yourself: what if your app’s data was just a folder of files? The possibilities are endless.
