Featured image
Info

Homelab Series Index

Digital freedom: creating an ecosystem of personal services without relying on big tech.

  1. Homelab: Necessity or Whim?
  2. Homelab: Proxmox and LXC Containers
  3. Homelab: Immich Setup
  4. Homelab: Navidrome Setup
  5. Homelab: Secure Remote Access
  6. Homelab: Migration from iCloud to Immich
  7. Homelab: AFFiNE Setup
  8. Homelab: KISS Backup Strategy
  9. Homelab: Network Migration and Wireguard
  10. Homelab: UPS and Network UPS Tools
  11. Homelab: From AFFiNE to Obsidian with Syncthing

When a Tool Doesn’t Keep Its Promises Link to heading

In the article about AFFiNE I started with enthusiasm: an all-in-one, self-hosted platform that combined notes, whiteboards, and databases. On paper, it seemed like the perfect solution. After months of daily use, reality turned out differently.

Why I Abandoned AFFiNE Link to heading

AFFiNE is an ambitious project with good intentions, but currently presents concrete limitations that make it difficult to adopt as a primary tool.

Warning

Limitations encountered with AFFiNE

  • Limited data export: There is no simple way to mass export all documents. Export works document by document, making migration to other tools a manual and tedious process.
  • Project maturity: Unstable features, updates that occasionally break existing configurations, and a user experience that changes frequently between versions.
  • Unusable database from mobile: Impossible to add rows to databases from smartphones. For a tool that should be the organizational center of digital life, not being able to enter data on the fly from the phone is a serious limitation.
  • Disguised vendor lock-in: Despite being open source, the proprietary data format effectively creates a dependency on the tool. Open source doesn’t automatically mean open data.

The lesson learned: software can be open source in code but closed in data. True digital freedom requires open and portable formats.

Obsidian: Markdown Files and Nothing Else Link to heading

The choice fell on Obsidian for one fundamental reason: data is simple Markdown files in a filesystem folder. No database, no proprietary format, no server to maintain.

Info

Why Obsidian

  • Pure Markdown files: Every note is a .md file readable with any text editor
  • Zero lock-in: If Obsidian shuts down tomorrow, the files remain perfectly usable
  • Mature plugin ecosystem: Active community with thousands of plugins for every need
  • Works offline: No dependency on servers or internet connection
  • Available on all platforms: Desktop (Linux, Mac, Windows) and mobile (Android, iOS)

Obsidian is not open source, but this is an acceptable compromise: the data is in a completely open format. Even without Obsidian, the files remain accessible and usable. The real lock-in risk is not in the software, but in the data format.

Installation Link to heading

Installation is trivial: download Obsidian from the official website, install it, and point it to a folder. That folder becomes the “vault” – the entire note archive. No need to configure databases, Docker containers, or backend services.

On the phone, the Obsidian app for Android or iOS works the same way: select a folder and start writing.

The Synchronization Problem Link to heading

Obsidian offers a paid synchronization service (Obsidian Sync) that works well, but contradicts the homelab philosophy: why entrust file synchronization to a cloud service when we have a perfectly functioning infrastructure?

The solution: Syncthing, a peer-to-peer synchronization tool, open source, that works without central servers.

Syncthing: Peer-to-Peer Synchronization Link to heading

Syncthing synchronizes folders between devices directly, without going through any cloud. Each device communicates with others through an encrypted protocol, and data never passes through third-party servers.

Info

How Syncthing works

  • Each device has a unique Device ID (a cryptographic key)
  • Shared folders are configured between two or more devices
  • Synchronization happens directly between devices, in real-time when they are reachable
  • Data is encrypted in transit (TLS)
  • Supports local discovery (LAN) and remote via public relay servers (only to establish the connection, data remains direct when possible)

Setup on Desktop (Linux/Mac) Link to heading

On Linux, Syncthing is available in the repositories of virtually every distribution. On Mac it’s installed via Homebrew:

# Linux (Debian/Ubuntu)
sudo apt install syncthing

# Mac
brew install syncthing

After installation, start Syncthing:

syncthing

The web interface is reachable at http://127.0.0.1:8384. From here you manage everything: adding devices, configuring folders, monitoring status.

Basic Configuration Link to heading

Configuration is simple:

  1. Start Syncthing on both devices
  2. Exchange Device IDs: each device shows its own ID in the dashboard. Add the Device ID of the other device on each one
  3. Share the folder: on one of the devices, add the Obsidian vault folder as “Shared Folder” and select the other device as recipient
  4. Accept the share: on the other device a notification will appear to accept the shared folder. Choose the local path where to save the files
  5. Wait for synchronization: Syncthing will start transferring files automatically
Tip
Practical advice: At the first connection between two devices, the initial synchronization may seem slow. Syncthing indexes all files before transferring them. Subsequent synchronizations are almost instantaneous because they transmit only the differences.

Setup on Android Link to heading

Syncthing for Android is available on F-Droid (recommended) and Google Play. The app is called Syncthing-Fork, an actively maintained fork by the community that has replaced the original app which is no longer updated.

F-Droid: Syncthing-Fork
Google Play: Syncthing-Fork

Once installed, configuration follows the same principle: exchange Device ID with the desktop and share the vault folder.

Warning
Be careful with Android permissions Syncthing-Fork needs full storage access to work correctly. In recent Android versions, it’s necessary to grant the “Access to all files” permission in the app settings. Without this permission, synchronization may fail silently.

Configuration Tips for Android Link to heading

Using Syncthing on Android requires some adjustments to balance synchronization and battery consumption.

Tip

Android battery optimization

  • Disable battery optimization for Syncthing-Fork: Android Settings –> Apps –> Syncthing-Fork –> Battery –> “No restrictions”. Without this setting, Android kills the background process and synchronization doesn’t happen.
  • Run Conditions: In Syncthing-Fork settings, configure run conditions. I recommend activating synchronization only on WiFi to avoid mobile data consumption, and keeping synchronization active even with low battery if the vault is not too large.
  • Vault folder on internal storage: Place the Obsidian vault in the phone’s internal memory (e.g. /storage/emulated/0/Obsidian/MioVault), not on SD card. Synchronization performance on SD card is significantly worse.
Note
Synchronization conflicts: If you edit the same note simultaneously on two devices, Syncthing doesn’t overwrite but creates a conflict file (e.g. nota.sync-conflict-20260204.md). Just open both files, decide which version to keep, and delete the conflict. In practice, with a single user, conflicts are very rare.

Daily Workflow Link to heading

The resulting workflow is natural:

  1. Desktop: I open Obsidian, write notes, organize projects. Files live in a local folder.
  2. Phone: I open Obsidian on Android, notes are already synchronized. I can add notes on the fly, checklists, ideas.
  3. Syncthing: Works in the background, synchronizes changes between devices in a few seconds when they’re on the same network, or through relay when away from home.

No need to think about it: it just works. No cloud account, no service to pay for, no data leaving the perimeter of your own devices.

Lessons Learned Link to heading

The transition from AFFiNE to Obsidian has reinforced a key principle of the homelab approach: simplicity wins. An app that works on Markdown files synchronized peer-to-peer is more reliable, more portable, and more resilient than an architecture with PostgreSQL database, Redis, and Docker containers.

The most sophisticated solution is not always the best. Sometimes, text files and good synchronization are all you need.