· · Daniel A
Sync Without Conflicts | How Last-Write-Wins Keeps Your Notes Simple
Multi-device note sync often uses Last-Write-Wins (LWW) to resolve conflicts. By comparing timestamps, the system automatically keeps the most recent edit and discards older versions. This eliminates 'conflicted copy' files common in apps like Obsidian or Joplin, providing a seamless, offline-first experience for personal knowledge management without manual merging.
Multi-device note sync is the backbone of modern personal knowledge management. In 2026, we expect our thoughts to move seamlessly from a phone during a commute to a desktop at the office. However, the technical reality of keeping two different versions of the same file in agreement is complex. When you edit a note on your laptop while your phone is offline, and then edit the same note on your phone, the system faces a conflict. How it resolves that conflict determines whether you stay in your flow or spend ten minutes manually merging text.
The most common and reliable method for individual users is known as Last-Write-Wins (LWW). While it sounds simplistic, it is often the superior choice for speed and privacy compared to complex operational transformation or manual merging.
Why Does Multi-Device Note Sync Create Conflicts?
Conflicts occur because of latency and offline access. If every notes app required a constant, high-speed internet connection to function, conflicts would be rare. But a high-quality offline-first notes app allows you to write even when you are in a tunnel or on a plane.
When you regain connectivity, the app must reconcile the changes made locally with the changes stored on the server. If both the local version and the server version have changed since the last sync, the system reaches a fork in the road. It cannot simply overwrite one with the other without a specific rule, or it risks deleting your data.
In many file-based systems, this results in the dreaded conflict file. According to research on cross-platform apps in 2026, users of tools like Obsidian or Logseq often encounter files named note (conflicted copy).md when using third-party sync services like Dropbox or iCloud. The user is then forced to open both files, compare them line by line, and manually delete the redundant one.
How Does Last-Write-Wins (LWW) Actually Work?
Last-Write-Wins is a conflict resolution strategy that relies on timestamps. Every time you modify a note, the application attaches a metadata tag containing the exact time of the edit (down to the millisecond).
When the sync engine detects two different versions of the same note, it compares these timestamps. The version with the most recent timestamp is declared the winner. The system automatically updates the database to reflect the latest version and discards the older one.
The LWW Logic Flow
- User edits Note A on Device 1 at 10:00:05 AM.
- User edits Note A on Device 2 at 10:00:10 AM while Device 2 is offline.
- Device 2 reconnects at 10:05:00 AM.
- The sync engine sees two versions. It compares 10:00:05 against 10:00:10.
- The 10:00:10 version is kept; the 10:00:05 version is overwritten.
This approach prioritizes the most recent intent of the user. For personal notes, where it is rare for a single person to be typing on two devices at the exact same second, LWW provides a frictionless experience that feels like "it just works."
Is Last-Write-Wins Better Than Manual Merging?
For most users, yes. Manual merging is the primary alternative, often found in developer-centric tools. While manual merging prevents any data loss, it introduces significant cognitive load.
If you use a tool like Joplin with a generic cloud provider, you might find yourself managing sync conflicts frequently. As noted by industry experts in 2026, Joplin requires a sync service like OneDrive or Dropbox, and these generic services are not optimized for the specific structure of note databases, often leading to duplicated conflict files.
LWW eliminates this maintenance work. It assumes that if you wrote something new, that is what you want to see. In a keyboard-first workflow, speed is the priority. Stopping to resolve a sync conflict is the ultimate speed killer.
How Does LWW Handle Offline-First Architecture?
The true test of a sync engine is how it handles long periods of offline use. An offline-first architecture uses a local database, such as IndexedDB, to store your notes directly in the browser or app cache.
When you are offline, all your searches and edits happen against this local cache. When you reconnect, the app performs a sync. If the app uses LWW, it can resolve hundreds of changes in seconds. It simply iterates through the modified notes, checks the timestamps against the server, and pushes the latest versions.
This is why apps that use LWW feel faster. There is no "waiting for sync" spinner that blocks you from working. The resolution happens in the background, and because the rule is deterministic (the latest time always wins), there is no need to prompt the user for input.
Does LWW Work With Client-Side Encryption?
Implementing sync is significantly harder when the server cannot read your data. In a zero-knowledge notes environment, the server only sees encrypted blobs of text. It cannot look inside the note to see which lines changed.
This makes LWW even more valuable. Because the server cannot perform complex "diffing" (comparing text differences), it relies on the unencrypted metadata · the timestamp · to decide which encrypted blob to keep.
For example, when using AES-256-GCM encryption, the content is locked before it leaves your device. The sync engine manages these locked boxes. LWW allows the system to swap the old box for the new box based on the timestamp on the outside of the box. This maintains high security without sacrificing the convenience of multi-device sync.
What Are the Risks of Last-Write-Wins?
The primary risk of LWW is the "lost update" scenario. This happens if you make a significant change on Device A, and then a few seconds later (before Device A can sync), you make a different change on Device B. If Device B's change is technically "later," the changes from Device A will be overwritten.
However, in the context of a personal knowledge management system, this risk is minimal. Most users do not jump between devices within a five-second window to edit the same paragraph. The trade-off · losing a few seconds of work once a year versus dealing with conflict files every week · is one that most power users are happy to make.
How Does SimplyBoard Handle Sync?
SimplyBoard is designed for users who value both speed and privacy. It utilizes an offline-first approach with an encrypted IndexedDB cache. This means your notes are always available, even without an internet connection, and search is instantaneous because it happens locally.
For multi-device note sync, SimplyBoard employs a robust last-write-wins resolution. This ensures that your workspaces stay in sync across your laptop, tablet, and phone without ever bothering you with "conflicted copy" messages. Because SimplyBoard uses client-side encryption, your notes are encrypted with a key derived from your password using Argon2id before they ever reach the server. The LWW sync happens on the encrypted packets, keeping your data private and your workflow uninterrupted.
Whether you are using the list view for tasks or the visual canvas for brainstorming, the sync remains invisible. You can move from a desktop board to a mobile list seamlessly, knowing that the latest version of your thought is the one that will be waiting for you.
Which Sync Strategy Should You Choose?
If you are a developer working on a shared codebase, you need Git-style merging. But if you are a professional managing a "Second Brain," you need a system that stays out of your way.
- Choose Manual Merging (Obsidian/Joplin via Cloud) if you absolutely cannot risk losing a single character and don't mind managing file duplicates.
- Choose Apple Notes if you are entirely within the Apple ecosystem and don't require end-to-end encryption for all metadata.
- Choose Standard Notes if you want high security but are comfortable with a more rigid, document-based structure.
- Choose SimplyBoard if you want the speed of LWW sync combined with zero-knowledge encryption and a search-first interface that works offline.
In 2026, the best note-taking app is the one you don't have to think about. By using Last-Write-Wins, modern apps remove the friction of sync, letting you focus on the content of your notes rather than the mechanics of their storage.
Frequently asked questions
What is last-write-wins in note syncing?
Last-Write-Wins (LWW) is a conflict resolution strategy where the sync engine compares the timestamps of two competing versions of a note. The version with the most recent timestamp is saved as the truth, while the older version is overwritten. This allows for fast, automatic synchronization across multiple devices without requiring the user to manually merge changes or manage duplicate files.
Is last-write-wins better than manual merging?
LWW is highly reliable for personal use because it is rare for one person to edit the same note on two devices simultaneously. It prevents the clutter of 'conflict files' and works perfectly with end-to-end encryption. While there is a small risk of losing an update if edits occur seconds apart on different offline devices, the gain in workflow speed usually outweighs this risk.
How does sync work when I am offline?
Offline-first apps like SimplyBoard store notes in a local database (IndexedDB). When you edit a note offline, it is timestamped locally. Once you reconnect to the internet, the sync engine compares these local timestamps against the server version. Using LWW, it pushes your latest offline edits to the cloud, ensuring your other devices receive the most recent updates immediately.
Does Standard Notes use last-write-wins?
Standard Notes uses high-level encryption to protect data, but sync behavior can vary based on the specific editor used. Generally, privacy-focused apps prefer deterministic sync methods like LWW because they allow the server to resolve conflicts between encrypted blobs of data without needing to 'see' the text inside, maintaining the user's zero-knowledge privacy.
How does Apple Notes handle multi-device sync?
Apple Notes uses a proprietary synchronization engine via iCloud. While it generally handles conflicts smoothly by merging changes at a character level, it is not a zero-knowledge system by default. For users seeking higher privacy, an app that uses client-side encryption (like AES-256-GCM) alongside LWW sync offers a more secure alternative for sensitive information.
How do I stop getting conflicted copy files in my notes?
A conflict file is a duplicate document created when a sync service (like Dropbox or iCloud) cannot decide which version of a file is correct. This happens often with file-based apps like Obsidian. You can avoid them by using a note-taking app with a built-in database and a Last-Write-Wins resolution policy, which handles these decisions automatically in the background.
