Why I stopped fighting Obsidian sync

I lost about four weekends to this. Four. Not consecutive — the kind of weekends where you sit down to write down a thought and end up running git reflog instead. This is the order I tried things in, which is also the order in which I was wrong.

How it started

A Saturday morning. Coffee. Two open tabs: a half-finished note on the laptop, the same note on the phone, both edited last night, both saved, and somehow now containing different sentences. The phone version had the link I needed. The laptop version had the paragraph I’d written before bed. There was no menu option titled “merge these like a reasonable person.”

I closed the lid and told myself this was a one-off. It was not a one-off. Over the next year I would do a small version of this same morning enough times to develop a Pavlovian response to the word “conflict.”

The setup is unremarkable: three devices (Linux desktop, Windows laptop, Android phone), one vault (call it ~3,000 markdown files plus the usual sediment of plugins). The job is unglamorous: when I write something on one device, the others should know. The job should not have eaten four weekends.

Attempt 1 — Git, because of course Git

This is text. Of course it goes in Git. I was almost smug about it.

For about a week it was fine. Then one Tuesday evening I forgot to pull on the laptop before opening the vault, edited a note that my phone had already edited that morning, hit save, and Obsidian — innocent, hopeful Obsidian — wrote what I’d typed straight into a file that already had a perfectly good newer version on a remote somewhere. By Saturday I was looking at:

<<<<<<< HEAD
Idea about cat tracker batteries
=======
Idea about LTE-M coverage in rural areas
>>>>>>> origin/main

Both halves are mine. Both halves are real. Neither half wants to argue with the other in YAML at 8am.

The thing about Git for notes is that the failure mode is you. Git is fine. Git is doing exactly what Git is for. What Git is for is deliberate, manual merges of code, by an engineer who is paying attention. Notes are continuous, automatic, and written in the half-second between thoughts. There is no engineer paying attention. There is me, on a phone, in a kitchen, with one hand.

I ran Git for three months. Two devices was tolerable. Three was not. Termux was where the wheels came off — I will spare you the screenshots.

Attempt 2 — Self-hosted LiveSync, because of course self-hosted

The next move felt sophisticated, which should have been the warning. CouchDB in a Docker container on a homelab box. The LiveSync plugin on every device. Chunk-level real-time replication. My data, my hardware, my problem.

Reader, it was my problem.

The model is fine in the abstract: every file is sliced into chunks, chunks sync to a remote CouchDB, conflicts are resolved per chunk. If every device finishes pushing before any device starts pulling, the world is harmonious. If you close the laptop mid-sync because dinner is ready and then pick up the phone in the car twenty minutes later, the chunks have opinions about each other that no human wants to read.

I started keeping a corruption log. I don’t mean I made one note about it. I mean I kept a corruption log, with entries:

2025-08-14  vault opened in safe mode, 17 conflict markers
2025-08-22  daily note ate its own frontmatter, restored from backup
2025-09-03  chunk-not-found error, "fetch remote" hung at 78%

That log is the moment I should have stopped. I did not stop. The sunk cost of having built the infrastructure was doing a thing to my brain. I told myself the problem was discipline — that if I just waited for sync to finish, every time, on every device, before touching another, this would all be fine. The protocol was sound. My patience was not. Patience that you have to summon every time you switch devices is not patience. It is a tax.

I stopped using LiveSync the weekend it ate a daily note I’d written on a train. The note wasn’t important. The principle was.

Attempt 3 — Syncthing, the grown-up option

Syncthing is the answer most people land on after Git. Fundamentally different idea: peer-to-peer file replication, not version control. Newest file wins. When there’s a true conflict, the loser is preserved as filename.sync-conflict-YYYYMMDD-HHMMSS.md. You never lose anything; you just have to look at conflict files now and then.

For two months, this was the best thing I had tried. I was almost ready to declare victory.

Then two things happened. The first was Android. Syncthing on Android is — I will be polite — a project. Battery optimisation kills the daemon, the share-folder UI is hostile, and you spend more time confirming notifications than you spend reading the notes the notifications are about.

The second was the conflict files. Not many. A handful per week. Each one a small decision: was this the version where I added the link, or the version where I deleted the typo? The answer was usually obvious. The cost was that I was now doing janitorial work on my own notes, weekly, forever. The whole point of a notes system is that it disappears. Syncthing didn’t disappear. It just got out of the way most of the time.

I will say this for Syncthing: it never corrupted anything. It is the only one of the four that I can say that about without an asterisk. If the Android story were better I might still be using it.

Attempt 4 — Obsidian Sync, which I had been refusing on principle

I had put this off for two years. On principle. The principle was a stack of things: it’s a subscription, it’s not self-hosted, the data leaves my hardware, I run my own everything, who do they think I am.

The principle was real. It was just expensive.

Add up the time on the previous three. Conservatively: an hour a week of janitorial work, plus the occasional Saturday I lost outright. That’s fifty hours a year, plus the genuine cognitive overhead of carrying the sync problem around in my head every time I sat down to write. At $8/month the math finally became impossible to flatter. The question stopped being “do I want to pay for sync?” and became “is my hour worth less than eight dollars?”

I paid. The setup was four clicks. The phone caught up in a minute. The conflict count, six months in, is zero. End-to-end encrypted, version history per note, selective sync for the folders I don’t want on the phone. It is so much better than the previous three options that I am slightly annoyed.

What I had been resisting wasn’t the cost. It was admitting this was a problem I should not have been solving myself.

The four options, side by side

What I actually learned

Three things, all of which I’d have said were obvious before I knew they were true.

Tools for X beat tools used as X. Git is for deliberate source-code merges. LiveSync is for real-time replication by users with sync discipline. Syncthing is for cross-device folder mirroring on operating systems that respect daemons. Obsidian Sync is for syncing Obsidian. The fourth one is the tautology I should have honoured a year and a half earlier.

Operational burden compounds, and you under-rate it every time. A 30-second sync ritual is invisible the first day, annoying the first week, and a deal-breaker by the first month. I told myself “I’ll just be careful” enough times that I should know better than to believe me when I say it.

There is a moment when self-hosting becomes a hobby, not a strategy. I love running my own infrastructure. I run more than I probably should. Notes sync was the wrong fight: high-frequency, high-stakes (a corrupted note is a lost thought), and the off-the-shelf solution was good enough that “good enough” was actually best. The principle of running my own everything is a principle worth having, right up until it starts making me bad at the thing the infrastructure was supposed to support.

The thing I should have noticed sooner

The signal was the friction itself. Every time my sync setup made me think about my sync setup, that was a tax I was paying on every note I tried to take. Subtract that tax and the notes get noticeably better — not because the tool wrote them, but because I wasn’t thinking about the tool when I did.

If you’re four months into your own sync odyssey and still patching: it might just be time to stop patching. The fact that you can fix it doesn’t mean you should be the one fixing it. I’d have saved myself four weekends if someone had told me that on a Saturday morning in March.

Vault size at the time of writing: ~3,000 notes. Devices: Linux desktop, Windows laptop, Android phone. Current setup: Obsidian Sync, plus a nightly Git push to a private repo, just in case. Yes, belt-and-braces. No, I am not sorry.