Who it’s for#

I think it’s suitable for these people:

• Already writes a lot of content in Obsidian
• Has a small server that’s online 24/7
• Willing to handle HTTPS, reverse proxy, and backups themselves
• Wants to be able to write notes anytime, anywhere

This way, even if your computer isn’t with you, you can easily write articles on your phone, and it’ll sync up once you’re back on your computer.

Deploying the Backend#

The backend repository is here:

https://github.com/haierkeys/fast-note-sync-service

It’s a Go-based backend, and the repository description states it’s a high-performance, low-latency note sync, online management, and remote REST API service platform.

I’ll start by creating directories:

1
sudo mkdir -p /srv/stacks/fast-note-sync
2
sudo chown -R $USER:$USER /srv/stacks/fast-note-sync
3
cd /srv/stacks/fast-note-sync

Then, I’ll deploy it according to the official documentation, choosing Docker, binary, or source compilation. Whichever method I pick, I’ll try to make the service only listen on the local address, then expose HTTPS using a reverse proxy or Tunnel.

The idea is:

1
Fast Note Sync Service
2
  -> 只监听 127.0.0.1:<服务端口>
3
  -> Caddy / Nginx / Cloudflare Tunnel
4
  -> notes.example.com

If using Docker Compose, at least keep these habits:

• Persist data directories to the current service directory
• Don’t commit configuration files to public repositories
• Don’t directly expose service ports to the public internet
• Back up data directories before updating

Your notes are in the sync service; it shouldn’t be running exposed.

Connecting a Domain#

You can use Caddy / Nginx, or Cloudflare Tunnel.

For example, domain:

1
notes.example.com

Structure:

1
notes.example.com
2
  -> HTTPS
3
  -> 127.0.0.1:<服务端口>
4
  -> fast-note-sync-service

If you don’t have a domain yet, you can check out:

Get a free domain for your new blog, then show your face in the webmaster community

I don’t recommend direct access:

1
http://服务器IP:<服务端口>

At least HTTPS, preferably with additional access protection.

Initializing Account and Plugin#

The process described in the backend README is roughly:

1. Open the Web management interface
2. Register an account on first visit
3. Copy API configuration from the backend
4. Paste the configuration into Obsidian plugin settings

Manually download main.js、styles.css、manifest.json from GitHub Releases and place them into:

1
.obsidian/plugins/fast-note-sync/

Then go to the plugin page and activate it. You’ll need to create and copy a token from the web interface, then paste it into the remote configuration. It usually starts up after a short while.

Backup is More Important Than Sync#

This sentence needs to be written separately. Sync will propagate deletions, and it will also propagate errors.

Fast Note Sync itself supports version history, recycle bin, backup, mirroring, Git sync, and other features, but you still need your own fallback plan.

If you’re already syncing Obsidian with Git, don’t immediately add another layer of real-time sync. First, figure out who is the primary sync and who is the backup.

My Thoughts on MCP and REST API#

Fast Note Sync Service now also offers REST API and MCP support.

This is very appealing to me. Because a lot of my content is in Obsidian, if AI clients can read and write notes through controlled interfaces in the future, then it won’t just be a sync tool, but an entry point to my personal knowledge base.

But this also comes with risks.

If AI can read and write your notes, it means permission boundaries need to be clearer:

• Don’t expose the MCP interface to the public internet
• Don’t grant write permissions to untrusted clients
• Don’t mix private diaries, account information, or keys in an open Vault
• For important Vaults, start with read-only access, and only consider write access after confirming the process.

‘AI integration’ is not a reason to immediately grant full permissions.

Is it Resource-Intensive on a 2C2G Server?#

For normal personal use, it should be fine.

What truly consumes resources are the number of attachments, sync frequency, and whether you’re stuffing an entire multi-gigabyte asset library into Obsidian.