← ALL ARTICLES
CONFLICTS

Four copies of the same link.

Nobody duplicates a bookmark on purpose. You end up with a folder called Reading inside a folder called Reading because two devices disagreed about reality and something had to give.

8 NOVEMBER 20267 MIN READ

The short version

  • Duplicates are the visible symptom of a conflict between two devices that both changed the same tree while out of touch.
  • Import is additive. An HTML import never reconciles — it adds. Importing the same file twice doubles everything, silently.
  • "Last write wins" on a whole tree destroys work instead of duplicating it, which is worse and much harder to notice.
  • MarkSync syncs a single encrypted snapshot and expects you to pull before you push — blunter than a merge, but it does not invent a fifth copy of anything.
01

The five failure modes you have probably seen

  • Exact duplicates. The same URL, the same title, twice in the same folder.
  • Folders inside themselves. Reading / Reading / Reading, each level holding a slightly different subset.
  • Resurrection. You delete thirty dead links; a week later they are back.
  • Silent loss. The opposite problem. An afternoon of tidying up simply is not there any more, and nothing warned you.
  • Shuffled order. Your careful arrangement comes back alphabetised, or reversed, or sorted by date added.

These look like five different bugs. They are mostly one problem wearing different clothes.

02

The root cause: no stable identity

Sync has to answer one question for every item: is this thing on device A the same thing as that thing on device B, or a different thing? If each bookmark carries a stable identifier that both devices agree on, the question is easy. If it does not, the system has to guess — usually by comparing URL and title and position.

Guessing fails in both directions, and both failures are familiar. Guess "different" when they are the same, and you get a duplicate. Guess "same" when they are different, and you lose one of them. The reason a bookmark edited on your laptop reappears after you deleted it on your phone is that the system could not tell "this was deleted" from "this has not arrived yet".

Deletion is the hard case

An addition is self-describing: the item is there, so it must have been added. A deletion is an absence, and an absence looks exactly like a thing that has not been synced yet. Systems that do not record deletions explicitly — as tombstones — cannot distinguish the two, which is why deletions are the single most common thing to come back from the dead.

03

The things that make it worse

Importing an HTML file

This is the biggest single source of duplicates, and it is worth being blunt about: browser bookmark import does not merge, it appends. Import the same export twice and you have two of everything. Import a file on two devices that then sync to each other, and you have two of everything, twice.

Offline edits on two devices

Tidy your bookmarks on the train, with no signal, while your desktop at home has already pushed a change. Now there are two divergent histories and one of them is going to lose. Which one depends on implementation details you have no visibility into.

Clock skew

Anything that resolves conflicts by timestamp is trusting the clocks on your devices. A phone whose clock is two minutes fast will win arguments it should lose, and a freshly reinstalled machine can have a clock that is wrong by hours.

Reinstalling a browser

A fresh profile signs in, finds an empty local tree and a full remote one, and has to decide which is authoritative. Some implementations treat the empty local state as a legitimate change — which is how people occasionally sync their way to no bookmarks at all.

Two sync tools at once

Running a browser's native sync and a third-party extension on the same profile means two systems are each writing the bookmark tree while watching the other do it. They will fight, and you will get the duplicates.

04

How MarkSync approaches it

MarkSync does not try to be clever here, and that is the design choice. Rather than continuously merging two trees item by item, it syncs one encrypted snapshot of your bookmarks. A device pulls the current state, applies it locally, and pushes its own state when you change something.

The trade-off is explicit:

  • What you get: no speculative merging, so no invented duplicates and no silent reconciliation of two trees that were never meant to be reconciled. What you see is what one known-good device last pushed.
  • What it asks of you: sync before you start editing on a different device. If two devices both edit from a stale copy, the later push is the one that stands — the model is simple enough that you can predict it, which is more than can be said for most merges.

Because everything is encrypted on your device before it is sent, the service is not involved in any of this. It is storing a blob; it has no opinion about your folder structure.

Back up before anything big. MarkSync can export your bookmarks, and a reorganisation is exactly the moment to use it. A snapshot model is predictable, but it will not undo an afternoon for you.

05

Practical rules that prevent most of this

  • Pull before you edit, push when you are done. Two minutes of discipline removes the entire category.
  • Do a big clean-up on one device only, and let it finish syncing before you touch another.
  • Never import the same HTML file twice, and check what is already there before importing at all.
  • Run one sync system per profile. If you are using MarkSync, turn the browser's own bookmark sync off.
  • Export before a migration, a reinstall or a reorganisation. It costs nothing and it is the only real undo you have.

If the duplicates arrived because you were trying to keep two different browsers in step, the underlying problem is the one in why browser sync won't help you.

Keep reading