Save Both: Why Sync Conflict Resolution Should Never Destroy Data

The Problem Everyone Ignores

Sync conflicts happen more often than people realise. You start writing on your phone during a commute, then open your laptop at home and continue writing before the phone syncs. Now two versions exist with different content. What happens next?

Most apps offer two choices: "Keep Local" or "Keep Remote." One version wins. The other is destroyed forever. You might not even know which had the better content.

Why "Last Write Wins" Is Dangerous

Some apps don't even ask. They use "last write wins" — whichever device synced most recently overwrites everything else. Google Keep does this. Apple Notes does this (mostly). The result: silent data loss that you don't discover until you're looking for content that no longer exists.

For a note-taking app that people trust with important information, silent data loss is unacceptable.

Our Approach: Save Both

xNotePadAI's sync conflict resolution offers three options:

Save Both (default)

Both versions are preserved. The conflicting version is saved as a tagged duplicate. Nothing is lost. You decide later which to keep.

Keep Local

Your current device's version wins. The remote version is discarded. Use when you know your local version is correct.

Keep Remote

The server version wins. Your local changes are discarded. Use when another device has the better version.

The key principle: the default action should never destroy data. "Save Both" means you can always recover. The other options exist for when you're certain — but they're never the default.

How We Detect Conflicts

Every note carries a SHA-256 content checksum. When syncing, the local checksum is compared against the server checksum. If they differ and neither is a direct descendant of the other, that's a conflict.

This is more reliable than timestamp comparison (clocks drift) or version numbers (can get out of sync). Content hashing means: if the bytes are different, it's a conflict. No false positives. No missed conflicts.

The Encrypted Sync Challenge

Conflict detection is harder when content is encrypted. You can't diff ciphertext meaningfully. Our solution: checksums are computed on plaintext before encryption, then stored alongside the ciphertext as metadata. The server can detect conflicts without ever reading the content.

This preserves zero-knowledge properties while still enabling intelligent sync. The server knows "these are different" without knowing "what's different."