- specs: mobile-and-sync, collaboration, vault-launcher, e2ee, attachments-and-history, capture-and-publish, agents (brief and orchestrator notes for MiniMax and GLM agents) - research: sync landscape, security and server, mobile platform (browsed, cited) - design/mobile: 24 PaperCraft exports (dark and light) of the phone, desktop, sharing and launcher screens - .claude: project skills and path rules so delegated agents follow the repo rules; CLAUDE.md imports AGENTS.md - ARCHITECTURE and ROADMAP updated; AGENTS.md lists the approved sync dependencies Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
57 KiB
Sync product landscape and feature catalog — NotesCraft (mobile + sync)
Research date: 2026-10-20. Scope: what existing notes-app and file-sync products do well or badly
across the sync dimensions, and what NotesCraft (plain .md vault as source of truth, single owner,
many devices, self-hosted homelab sync server) should adopt.
Method
Browsed. Facts were gathered with web search and page fetch against official vendor
documentation, official pricing pages, official GitHub repositories/READMEs and official release
pages. Every URL below was accessed in 2026 (research date 2026-10-20). Claims that could not be
confirmed on an official page are written [unverified] — nothing is filled in from memory, and no
version number, price or API name is stated unless an official page stated it. Absence claims
("product has no version history") are labelled as absences and are [unverified] where no official
page positively states the absence. Third-party sources are used only for user complaints and are
labelled as such. Local grounding (SPEC.md, specs/mobile-and-sync/spec.md, crates/sync, the sync
server routes) was read from this repo to decide the "matters for NotesCraft" column.
Findings
Obsidian family
-
Obsidian Sync — selective sync is per-vault, per-device and never includes dot-files except
.obsidian. File-type toggles are on by default for Images, Audio, Video and PDF plus a "sync all other types" switch; a per-vault Excluded folders list is managed in Settings; dot-files and dot-folders are always excluded except.obsidian. Two traps are documented: adding a file to the exclude list does not remove it from the remote vault, and sync settings themselves are device-specific and do not sync, so selective sync must be configured on every device. https://obsidian.md/help/sync/settings (accessed 2026) -
Obsidian Sync — version history retention is plan-shaped and asymmetric. Notes keep 1 month on Standard, 12 months on Plus; attachments keep only two weeks. Restore is reachable from the file explorer ("Open version history"), from Settings → Sync → Deleted files (deleted and renamed files, restored to their original location) and from a separate Settings version history for config files. The local File-recovery plugin's snapshots are not synced. https://obsidian.md/help/sync/version-history (accessed 2026)
-
Obsidian Sync — conflict handling merges Markdown, wins on everything else. Markdown conflicts are merged with Google's diff-match-patch; every other file type (canvases included) is last-modified-wins; settings JSON is merged by applying local keys over remote keys. Since Obsidian 1.9.7 the behaviour is selectable: Automatically merge (default, may duplicate text) or Create conflict file, which writes
original-note-name (Conflicted copy device-name YYYYMMDDHHMM).md, keeps the remote version in the original file and puts the local edits in the conflict file. The choice is device-specific. https://obsidian.md/help/sync/troubleshoot (accessed 2026) -
Obsidian Sync — E2EE is real but its limits are published, and that honesty is the lesson. Two modes per remote vault: end-to-end encryption (default, vault password that cannot be recovered) or standard encryption with an Obsidian-managed key. Crypto is AES-256-GCM with scrypt. Obsidian itself discloses two trade-offs: deterministic file-hash encryption (same content ⇒ same encrypted hash, so an attacker who can force uploads can test guesses) and no cryptographic binding between path and content (the server sees which device wrote what, when, and the path↔ content mapping, so a compromised server could swap one file's content under another's path). https://obsidian.md/help/sync/security (accessed 2026)
-
Obsidian Sync — limits, status UX and pricing. Max file size 5 MB (Standard) / 200 MB (Plus); storage is account-wide across vaults and includes version history and attachments; hitting the limit stops syncing; no chunking protocol is published
[unverified]. Status icon has four states — Synced / Syncing / Paused / Disconnected — and the sync log is filterable by All / Errors / Skipped / Merge Conflicts and categorised General / Error / Skipped / Account, but does not persist after the app is closed. Files sync only while Obsidian runs. Pricing https://obsidian.md/sync: Sync Standard $4/user/month billed annually (1 vault, 1 GB, 5 MB max file, 1-month history) and Sync Plus $8/user/month billed annually (10 vaults, 10 GB upgradeable to 100 GB, 200 MB max file, 12-month history); devices unlimited. Official weaknesses: running a third-party sync service alongside Sync "can lead to conflicts, resulting in duplicate or corrupted files"; "Sync is not a backup"; remote vaults are deleted after 30 days of inactive subscription; storage figures lag up to 30 minutes; Windows Defender can quarantine notes containing code blocks; filenames illegal on the receiving OS are silently skipped; iCloud Drive on Windows "may lead to file duplication or corruption". https://obsidian.md/help/sync/plans, https://obsidian.md/help/sync/messages, https://obsidian.md/help/sync/faq (accessed 2026) -
Obsidian Publish is a one-way publishing pipeline, not a sync service — and is priced separately. Notes are selected (NEW / UNCHANGED / CHANGED dialog), filtered by included/excluded folders and by
publish: true|falsefrontmatter (publish: trueoverrides an excluded folder), and rendered atpublish.obsidian.md/<site-id>. Deletions must be ticked manually. There is no per-page version history[unverified], no conflict handling (publishing before syncing can overwrite a collaborator's changes), and no E2EE — the site is public or site-password protected, hosting is contracted to Cloudflare. Files up to 50 MB, site capped at 4 GB; no chunking published[unverified]. Collaborators may publish and unpublish; only the owner configures the site and manages permissions, and only the owner needs a subscription. Custom domains work only via Cloudflare (CNAME →publish-main.obsidian.md, proxy on, SSL mode Full). Pricing https://obsidian.md/publish: $8 per site per month billed annually, $10 billed monthly. https://obsidian.md/help/publish/publish, https://obsidian.md/help/publish/security, https://obsidian.md/help/publish/limitations (accessed 2026) -
Obsidian Git is "whatever you commit", it is not a sync service, and its own maintainer warns against mobile. No selective-sync UI —
.gitignoreis the policy; the plugin's own recommended block excludes.obsidian/(or just.obsidian/plugins, or justworkspace*.json), plus.trash/and.DS_Store; changing.gitignoredoes not untrack already-committed files. History is git's (Source Control View, History View, Diff View,git blame). Conflicts are native git with in-editor keep ours / theirs / both buttons and a diff3 base comparison. No E2EE (optional GPG commit signing only). Large files need Git LFS; mobile usesisomorphic-gitwhose repo size is limited by memory. Settings/plugins/themes are not synced by default. Permissions come from the Git host; there are no per-file roles. No share links or publish (only "Open file on GitHub"). The Source Control View is the status surface; there is no bandwidth saver, only cadence controls (auto commit-and-sync interval / after stopping edits / after latest commit). Headless sync is plaingit push/git pull— Obsidian's docs state plainly that "syncing isn't automatic. You must manually push and pull changes." The plugin is free and open source; the cost is the Git host. The maintainer's own words: "The Git implementation on mobile is very unstable! I would not recommend using this plugin on mobile" — no SSH auth on mobile, no rebase merge strategy, no submodules on mobile, possible crash-on-clone and "buffer overflow errors"; Snap unsupported, Flatpak not recommended. https://github.com/Vinzent03/obsidian-git, https://publish.obsidian.md/git-doc/Tips-and-Tricks, https://obsidian.md/help/sync-notes (accessed 2026) -
Obsidian ships a headless client — the newest and most copyable competitive move. Obsidian Headless (open beta) exposes
ob login,ob sync-setup,ob sync/ob sync --continuous,ob sync-config --mode bidirectional|pull-only|mirror-remote --conflict-strategy merge|conflict --file-types --configs --excluded-folders,ob sync-statusandob sync-unlink, with the same encryption as the desktop app; it requires an active Sync subscription and Obsidian explicitly warns not to run desktop Sync and Headless on the same device. The same client drives Publish (ob publish,ob publish-list-sites,ob publish-config). https://obsidian.md/help/sync/headless, https://obsidian.md/help/publish/headless (accessed 2026)
Joplin and Logseq
-
Joplin's delta sync is the best-documented change-feed protocol in the market.
GET /api/files/delta?cursor=CURSORreturns create/update/delete events plus a new cursor; events are compressed (create+update → create, create+delete → NOOP, update+delete → delete);limitis advisory; an expired or invalid cursor returns an explicitresyncRequirederror telling the client to discard the cursor and resync from the beginning — clients idle for more than 180 days hit it; a delete event for a file the client does not have must be treated as a no-op, not an error. https://joplinapp.org/help/dev/spec/server_delta_sync (accessed 2026) -
Joplin's conflict model is "conflict notebook" plus, in the newer spec, a bounded three-way merge. Classic behaviour: Joplin creates a Conflict notebook, copies the local note into it and lets the remote note replace the local one. The auto-merge spec keeps a base per sync target (
base_body/base_title, recorded after every upload/download/conflict) and merges line by line; it falls back to a conflict note when there is no base, the item is locked/read-only, a side cannot be decrypted, both sides edited identical lines, or the diff exceeds maxEditLength 5000 / timeout 1000 ms. The spec records that word-level merging was tried and dropped because it could silently duplicate text. https://joplinapp.org/help/dev/spec/conflict_auto_merge, https://joplinapp.org/help/apps/conflict (accessed 2026) -
Joplin's history and E2EE show two patterns worth stealing and one to avoid. Note history is saved every 10 minutes (plus a 7-day catch-up rule), stored as diffs (text diff for title/body, object diff for other properties), synced across devices, retained 90 days by default — and because revisions sync, the minimum interval set on any device wins, which Joplin documents as a wart. Viewing history is desktop-only; restoring copies the old version into a "Restored Notes" folder instead of overwriting. E2EE is manual and one-device-at-a-time (the first device creates the Master Key; enabling it in parallel on several devices can create several master keys), the password cannot be recovered, items are encrypted only during sync, and the data format is a "JED" header plus length-framed chunks so a block can be moved between files. https://joplinapp.org/help/dev/spec/history, https://joplinapp.org/help/apps/note_history, https://joplinapp.org/help/dev/spec/e2ee (accessed 2026)
-
Joplin's limits, pricing and sync triggers. Targets are Joplin Cloud, Nextcloud, S3 (Beta), WebDAV, Dropbox, OneDrive and the local filesystem, each a thin driver over a filesystem-like interface. Cloud caps per plan: 10 MB max note/attachment on Basic, 200 MB on Pro/Teams, unlimited on Joplin Server Business; the hard mobile limit is documented bluntly — "Resources larger than 10 MB are not currently supported on mobile. They will crash the application when synchronising". Attachment download behaviour is Always / Auto / Manual explicitly to "save disk space and network bandwidth, especially on mobile". App settings, plugins and themes are not synced (only the per-target
info.jsontravels). Publishing a note produces a shareable link that updates when the note changes; linked notes are not published and each share creates a new link. Uploads happen within seconds; downloads are polled every few minutes, and that poll model is the documented source of conflicts. Headless sync isjoplin syncfrom the terminal (cron-friendly). Pricing (EUR, https://joplinapp.org/plans): Basic 2.99/month monthly or 2.40/month annual (2 GB), Pro 5.99 / 4.79 (30 GB), Pro 100 GB 9.99 / 7.99, Teams 7.99 per user (min 2); Joplin Server Business 3.33 / 2.92 / 2.50 EUR per user per month by size band billed annually; the OSS server wants Docker and PostgreSQL 16.8+ for production (SQLite is dev-only). https://joplinapp.org/help/apps/attachments, https://joplinapp.org/help/apps/sync, https://joplinapp.org/help/apps/terminal (accessed 2026) -
Logseq's own docs forbid running two sync engines on one graph — the single most repeated warning in the whole landscape. The file version's docs say "any file sync service will enable you to synchronize your Logseq graph" (iCloud, OneDrive, Dropbox, Syncthing all work), but Logseq Sync users are told to move the graph out of any iCloud/Dropbox/OneDrive-synced folder and that "only Logseq Sync should be syncing your graph"; Self-hosted LiveSync says the same ("Do not enable this plug-in alongside another synchronisation solution (including iCloud and Obsidian Sync)"), and Obsidian warns that a third-party sync service alongside Sync causes duplicated or corrupted files. Logseq's own issue tracker records data loss because Logseq creates zero-byte files that iCloud rejects (#5802) and journals never appearing in iCloud (#5901). https://github.com/logseq/docs/blob/master/pages/Logseq%20Sync.md, https://github.com/vrtmrz/obsidian-livesync#readme, https://github.com/logseq/logseq/issues/5802 (accessed 2026)
-
Logseq splits into a file version and a DB version, and each syncs differently. Logseq OG is file-based (plain Markdown, so any file sync works, plus built-in git integration and a desktop Git Auto-Commit with 1–600 s intervals that does not push). The DB version stores a local SQLite database plus
assets/and syncs through Logseq Sync (RTC — "Real Time Collaboration"), a paid, invite-only feature that can also be self-hosted. The file version's Logseq Sync encrypted the graph with age (ChaCha20-Poly1305), including file names and paths, under a graph password that cannot be changed afterwards — and the docs admit the filename scheme is "weaker, bug good enough for filenames". Conflict handling moved from whole-page sync to Smart Merge (0.9.14): block-level, built on Myer's diff plus diff-match-patch, enabled per device, requiring a re-index, explicitly "still an experimental feature" and designed for individual users on multiple devices, not collaboration. File-version Sync kept page history for up to a year; the DB version recycles deleted pages for 30 days and keeps hourly automated backups, last 12. Beta limits: 10 remote graphs, 10 GB per graph, 100 MB per asset. Status UX is a cloud icon with a green = synced / orange = pending dot and a "Sync now" button; there is no filterable activity log[unverified]. Sync cadence is fixed: mobile every 2 seconds after you stop typing, desktop 20 seconds. File-version Logseq Sync explicitly did not support collaboration; the DB version documents RTC and shared remote graphs, with per-node granularity[unverified]. Logseq Publish (DB) publishes tologseq.iobehind Cloudflare with an optional password per page; the file version's "Export public pages" produced a static single-page app. Pricing: the file-version beta was $5/month (Backer) or $15/month (Sponsor) on Open Collective; the DB version is paid and invite-only andlogseq.com/pricingrenders no prices to a non-JavaScript client, so the current price is[unverified]. https://github.com/logseq/docs/blob/master/db-version.md, https://blog.logseq.com/logseq-0-9-14-better-sidebars-and-smart-merge-for-sync/ (accessed 2026)
Self-hosted and open-source sync engines
-
Syncthing is the reference for block-level transfer, but it has no server, no merge and no iOS client. Files are split into blocks of 128 KiB up to 16 MiB, each SHA-256 hashed into a block list, so only differing blocks transfer; there is no per-file size cap. Conflicts are never merged: the loser is renamed
<file>.sync-conflict-<date>-<time>-<modifiedBy>.<ext>, the older mtime loses, ties break on the larger first 63 bits of the device ID, and the conflict copy then propagates to every device as an ordinary file. File versioning defaults to off, is per folder/device, and only archives changes received from other devices — it "will not and can not archive the old version" of a local edit; versions land in.stversionsand there is no GUI restore dialog[unverified]. Ignore rules live in a per-folder.stignore(globs,!negation,(?i),(?d),#include; first match wins). There is no E2EE against a server because there is no server: TLS 1.2/1.3 device-to-device with certificate fingerprints as device IDs. Folder modes are Send & Receive / Send Only / Receive Only, and "each user should run their own Syncthing instance" — no per-user roles. Trigger model: watcher plus hourly full rescan randomised to 3/4–5/4 of the interval, watcher events accumulated for 10 s, deletions delayed a further minute, 256 MiB concurrent incoming cap. First-class headless CLI (syncthing serve,syncthing cli …,decrypt,paths,generate,upgrade) plus a JSON--auditlog, "Recent Changes" and Prometheus metrics. Free, open source, no device or storage limit, no hosted tier. Official caveat: no official iOS client ("iOS has significant restrictions on background processing"), P2P requires both sides online simultaneously, and on case-insensitive filesystems the winner of a case conflict is "currently not predictable". https://docs.syncthing.net/users/syncing.html, https://docs.syncthing.net/users/versioning.html, https://docs.syncthing.net/users/ignoring.html, https://docs.syncthing.net/users/faq.html (accessed 2026) -
Remotely Save proves the demand for "sync to my own MinIO" and also how a sync product fails. It is an Obsidian plugin that syncs to S3/S3-compatible (Cloudflare R2, Backblaze B2, MinIO, Storj…), WebDAV (Nextcloud, ownCloud, InfiniCloud, Synology…), Dropbox or OneDrive. Selective sync is two regex lists,
ignorePathsandonlyAllowPaths; when the allow-list is non-empty everything — including config dirs — must be listed explicitly. There is no user-facing version history or restore UI[unverified]. Free tier conflict resolution is keep-newer or keep-larger (the user picks); PRO addssmart_conflict= "merge small markdown files, or duplicate large markdown files or any-size non-markdown files". A safety valve worth copying:protectModifyPercentage(default 50) aborts the sync if more than n% of files would be modified or deleted. E2EE is optional and password-based (rclone-crypt style with per-chunk XSalsa20-Poly1305 and per-path filename encryption, or AES-256-CBC + PBKDF2), but it is not fully server-blind — the vault name is not encrypted and directories are stored as zero-byte objects. Config is not synced by default (syncConfigDiris experimental because Obsidian rewrites config mtimes on every launch). It is foreground-only — "It's technically impossible to auto sync while Obsidian is in background" — and both auto modes fail silently. Last release 0.5.25, published 2024-10-20; PRO is "FREE while beta before Jan 1, 2027" and the PRO code is source-available (PolyForm Strict). https://github.com/remotely-save/remotely-save#readme, https://github.com/remotely-save/remotely-save/blob/master/docs/sync_algorithm/sync_ignoring_large_files.md (accessed 2026) -
Self-hosted LiveSync is the only product found that does a real, conservative three-way merge. Automatic merge uses the nearest shared ancestor revision available in both histories and explicitly refuses to guess: missing or compacted history stops the merge; one side deleting what the other modifies asks the user; binary contents differ → "semantic merge is unavailable"; two devices independently creating the same path leave two leaves with no shared base, resolved by hand. Its structural constraint is the one to learn from: conflicts can only be resolved on a device that still holds the ancestor — which is exactly why the ancestor revision must be retained by the server, not just by the client. It is also the richest observability product: status bar with Activity / Status / Statistical (uploaded vs downloaded chunks) / Progress indicators, "Write logs into the file", a redacted "Generate full report for opening the issue with debug info", and a conflict inspector listing the winner and every conflict leaf with revision ids, chunk availability and delta size. Content-defined chunking exists mainly to stay under CouchDB document-size limits, and "fetch chunks on demand" is available on CouchDB only — its S3-compatible mode has no live push and no direct chunk fetch. Sync modes are LIVESYNC (continuous, CouchDB/P2P only) / PERIODIC / ONEVENTS, with the battery warning "Keep replication active in the background — Desktop only; uses more battery and network". E2EE v2 is AES-256-GCM + HKDF with an independent key for document IDs and an exportable recovery code (
sls-id-v1:), path obfuscation optional and off by default for performance, and metadata ids, revision counts and ciphertext lengths still visible. Config sync is split into two opt-in features — Customisation Sync (snippets/config/plugin files, needs a uniquedeviceAndVaultName) and Hidden File Sync (.obsidiancontent with a Merge/Fetch/Overwrite initialisation direction) — with a warning not to use both on the same files. It ships an official headless CLI (livesync-cli sync|mirror| rebuild|fetch|push|pull|lock-remote+ Dockerfile), is MIT/free, and says the server can be a Raspberry Pi. Weaknesses: chunk-hash/size/splitter mismatches can pause sync, encryption/path/ case decisions always need a human, mobile needs OS-trusted HTTPS (self-signed not supported), Cloudflare524breaks long operations, and Garbage Collection V3 can make historical revisions unreadable. https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/specs_conflict_resolution.md, https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/settings.md, https://github.com/vrtmrz/obsidian-livesync/blob/main/src/apps/cli/README.md (accessed 2026) -
Standard Notes is the reference for honest E2EE and for cursor-based item sync — and it has no merge at all. Encryption is XChaCha20-Poly1305 with Argon2 key derivation, changes are encrypted and signed, and the self-hosted server is zero-knowledge — "the entirety of the encryption and decryption process happens completely offline". The protocol splits a root key into a master key (never sent to the server) and a server password, with per-item keys. Sync is client-driven request/response carrying
sync_token,cursor_token,limitanditem_hashes; the server never pushes and a long-poll behaviour is[unverified]. There is no merge: the server returns aconflictsarray andsync_conflictitems are surfaced to the client, with the official warning that simultaneous edits "may result in the duplication of notes". History is server-side per item with a History UI (Session History for all users, Remote History paid only, revisions ≥5 minutes apart, restore-overwrite or restore-as-copy); plan ladder: free = "Current session only", Productivity = 1 Year, Professional = Unlimited; the client-side session history is ephemeral and does not survive a restart. Files are a Professional-only feature, no size limit (tested to 2 GB), 100 GB encrypted storage, and no chunking is documented. There are no shared vaults or per-note ACLs — Professional allows sharing subscription benefits with up to 5 accounts (sharing one storage quota), and real-time collaboration is refused on the grounds that "server-side collaboration would require the server to parse content". Read-only share links existed only through the separate Listed extension, and "The Listed platform will permanently shut down December 31, 2026". Pricing: Standard $0/year, Productivity $90/year, Professional $120/year. Self-hosting: Docker Compose + MySQL; v2 is "4 total containers (compared to 13 for legacy)" with "570MB in V2 vs. 1.7GB in legacy"; minimum host "Ubuntu 22.04, with 2GB RAM and 1 CPU"; there is no headless client[unverified]. https://standardnotes.com/plans, https://standardnotes.com/help/3/how-does-standard-notes-secure-my-notes, https://standardnotes.com/help/47/can-i-self-host-standard-notes, https://github.com/standardnotes/snjs/blob/main/packages/snjs/specification.md (accessed 2026)
Platform and consumer baselines
-
Anytype's differentiator is a CRDT-style merge, which is exactly what NotesCraft declared out of scope. Its model is a local encrypted object graph (spaces, not folders), so Obsidian-style per-folder selective sync does not exist — detailed per-object semantics are
[unverified]. Concurrent edits to the same block are merged automatically rather than duplicated; E2EE is an always-on product claim with a per-space recovery phrase (key-derivation parameters[unverified]). Object history with restore exists, retention window[unverified]. Spaces can be shared with member roles (exact taxonomy[unverified]); there is no verified public web publishing pipeline[unverified]; no filterable sync log[unverified]; no verified bandwidth saver[unverified]; no headless client[unverified]; and the price of the paid tier is[unverified](read https://anytype.io/pricing/ directly before quoting). Third-party reports (user complaints, not vendor-confirmed): heavy local storage/index cost, sync stalls on large graphs, and confusion between the free and paid tiers' sync limits. https://anytype.io/, https://doc.anytype.io/ (accessed 2026) -
Apple Notes / iCloud is the baseline NotesCraft must beat on mobile reliability. There is no per-note version history (only Recently Deleted, commonly 30 days on iOS; iCloud-side retention is
[unverified]) and no published conflict semantics[unverified]— the observable behaviour is a last-writer-wins outcome with no merge UI and no conflict copy, and users report edits appearing reverted across devices (third-party). Advanced Data Protection is the E2EE outlier (XChaCha-style server-independent keys, recovery key or recovery contact), but it is off by default, must be enabled on every device, and any non-Apple device in the account breaks it for that data. Notes is not a general file store: attachments have no published byte caps and no chunking protocol; large files belong to iCloud Drive. Sync status is only an OS-level indicator plus "Manage Account Storage"; there is no per-note activity log. The single most cited complaint is that Low Data Mode and Low Power Mode defer iCloud syncing on iPhone, producing multi-hour sync lag. There is no headless path. Storage: 5 GB free, iCloud+ at 50 GB, 200 GB, 2 TB, 6 TB, 12 TB, 18 TB (per-region prices[unverified]). Apple's own position — the Notes store is closed and Apple does not support third-party note apps on iCloud Drive — is the regulatory opening NotesCraft can use. https://support.apple.com/guide/notes, https://support.apple.com/guide/security/advanced-data-protection-adr558a4a1ca/web, https://support.apple.com/guide/iphone/manage-settings-for-apple-services-iph3c2c1d1e4/ios (accessed 2026) -
Notion's offline mode is a black box cache with a published warning that it is not a backup. Offline is all-or-nothing per workspace with a page-size limit (number
[unverified]); there is no per-folder toggle. Version history exists with a Restore action; free plans are documented at 7 days, other tiers[unverified]. No merge algorithm is published — behaviour is last-write-wins per page, possibly preserving disjoint block edits[unverified]— and there is no conflict-copy naming. Notion does not offer E2EE; "enhanced encryption" is admin-managed server-side key control. Upload caps and a monthly upload quota exist but the numbers are[unverified]unless read on the plan-comparison page; no chunking protocol is published. Workspace settings live server-side; appearance is a local device preference; there is no plugin/theme system. Sharing has a real role taxonomy (Full access / Can edit / Can comment / Can view plus guests), and "Publish to web" publishes a page or a whole site. Audit logs exist on paid plans; the consumer sync indicator is minimal and there is no per-file sync log. Offline mode reduces network use by syncing only pages you open. The REST/SDK API is not a sync client and cannot sync a local Markdown vault. Pricing https://www.notion.com/pricing: Free $0; Plus $10 per user/month billed annually ($12 monthly); Business $20 ($24 monthly); Enterprise quoted. User complaints (third-party): offline edits sometimes overwrite newer server content, and mobile offline mode is restricted. https://www.notion.com/help/use-pages-offline, https://www.notion.com/help/duplicate-delete-and-restore-content, https://www.notion.com/help/sharing-and-permissions (accessed 2026) -
Dropbox-style folder sync is the de-facto standard for conflict naming, version retention and delta feeds. It is file-level with a cursor-based delta feed (
files/list_folder+cursor; Google's equivalent isfiles.changes), watch + poll on the client, and no merge: the loser is namedfilename (John's conflicted copy 2024-01-01).txtand the copies then sync onward — the "conflicted copy sprawl" users complain about. Selective sync chooses top-level folders; ignore rules are extension-based, not glob-based; Google Drive offers a "Mirror vs Stream files" model instead, and iCloud Drive has no selective sync at all (only "Optimize Storage" / "Keep Downloaded"). Version history: 30 days free, 180 days paid, custom up to 365 days on Business, plus a 30-day account-wide "Rewind"; iCloud Drive has no per-file history, only 30-day Recently Deleted. Shared folders carry member roles; shared links carry view/edit, optional password and expiry; "Publish to web" exists on Google Drive. The client shows explicit sync states (up to date / syncing / paused / offline / error), a per-file Activity panel and account-level activity logs on paid plans. Bandwidth levers are a daily bandwidth limit and online-only files; Google Drive's equivalent is "Stream files"; iCloud defers upload under Low Power / Low Data Mode. There is a real CLI (dropbox start|status|filesync|exclude) wheredropbox filesyncis a cron-friendly one-way mirror; iCloud Drive has no CLI. No E2EE for user files (TLS + server-side at rest; Dropbox says so explicitly because it indexes content); iCloud Drive E2EE via ADP is the exception with the same all-Apple-device caveat. Pricing: https://www.dropbox.com/individual — Basic 2 GB $0, Standard 2 TB $11.99/user/month, Professional 3 TB $19.99/user/month, Team $20/user/month, Enterprise quoted (USD, billed monthly); Google Drive free 15 GB, Premium 2 TB $9.99/month, 30 GB $1.99/month; Workspace Business Starter $7 / Standard $14 / Plus $22 per user/month billed annually. https://help.dropbox.com/sync/resolve-file-conflicts, https://help.dropbox.com/sync/version-history, https://help.dropbox.com/sync/selective-sync, https://www.dropbox.com/cli (accessed 2026) -
Cross-cutting: every serious product separates "note sync" from "config sync", and none syncs config by default. Obsidian syncs
.obsidianbut makes community plugins opt-in; LiveSync splits it into Customisation Sync and Hidden File Sync; Remotely Save excludes config by default and callssyncConfigDirexperimental; Joplin and Logseq DB sync preferences but not plugins or themes; Standard Notes syncs preferences as encrypted items but not extensions. For NotesCraft the sane default is: notes and attachments always; settings, plugins and themes an explicit per-folder opt-in with its own conflict semantics; device-local workspace state never synced. -
Cross-cutting: the durable server-side activity log is the strongest differentiator available and almost nobody has it. Obsidian's log is rich but does not persist after the app is closed; LiveSync's is the richest but is client-local and only as durable as the app; Standard Notes has per-note history but no browsable sync-activity viewer; Logseq has a green/orange dot. With SQLite metadata and a monotonic sequence, a durable per-device log (upload / download / delete / conflict / skip, with device name, path, bytes, timestamp) is cheap and is the answer a homelab operator needs at 2 a.m.
-
Cross-cutting: background sync on mobile is the hardest problem in the landscape, and no product solves it cleanly. Obsidian syncs only while the app runs; Remotely Save is foreground-only and fails silently; Syncthing has no iOS client at all; Joplin polls on a timer; LiveSync's continuous mode is CouchDB/P2P only and warns about battery; Standard Notes never gets pushed to. NotesCraft's WorkManager / BGAppRefreshTask plan is ahead of the market, but it must be designed as three explicit modes (foreground / on-save / OS-scheduled) rather than one, and must degrade to foreground-only without losing edits.
Feature table
| Feature | Who has it | Why it matters for NotesCraft | Effort | Priority |
|---|---|---|---|---|
Cursor change feed with explicit resync_required signal + event compression |
Joplin (resyncRequired, >180-day cursor expiry), Standard Notes (sync_token), Dropbox / Google Drive (cursor delta) |
Our /changes?since=seq is already the right shape; without a resync signal a stale client silently diverges. Compression cuts long-poll payloads. |
S | P0 |
| Three-way merge against a stored ancestor, with "ask the user" fallback | Joplin (base_body/base_title, 5000-char / 1000 ms bounds), LiveSync (nearest shared ancestor) |
The decided ancestor-hash design is rare and is our differentiator; the LiveSync rule — missing ancestor ⇒ never guess — must be in the spec. | M | P0 |
| Conflict-copy naming + a single discoverable Conflicts view | Obsidian (Conflicted copy device YYYYMMDDHHMM), Syncthing .sync-conflict-…, Joplin Conflict notebook, Dropbox conflicted copy |
Our name (conflict <device> <date>).md matches ecosystem expectation; one view stops copies multiplying unnoticed. |
S | P0 |
| Durable server-side activity log (per device, per file) | Obsidian (client log, lost on quit), LiveSync (richest), Standard Notes (weakest) | Best trust signal a self-hosted service can offer; answers "what happened to my file while I was away". | M | P0 |
| Sync status with explicit states + last-sync time | Obsidian (Synced/Syncing/Paused/Disconnected), Logseq (green/orange dot), Remotely Save (last successful sync) | Status bar on desktop and a badge on mobile; without it users cannot tell "not synced" from "nothing to sync". | S | P0 |
| Three explicit sync modes (foreground / on-save / OS-scheduled) | LiveSync (LIVESYNC / PERIODIC / ONEVENTS), Joplin (upload-now, poll-download) | Mobile background limits vary per OS and per device; a user-chosen mode is honest and prevents surprise battery use. | M | P0 |
| Guard against a second sync engine on the same vault | Logseq, LiveSync, Obsidian (all warn explicitly) | iCloud-on-Windows duplication/corruption and zero-byte-file data loss are documented; NotesCraft should detect and warn. | S | P0 |
| Rename / delete detection by content hash | Joplin, LiveSync (logical deletion), Syncthing (does not) | Already designed; a rename must not cost a full re-upload and a delete must not resurrect. | S | P0 |
| Version history with a restore UI and an explicit retention policy | Obsidian (1 month Standard / 12 months Plus; attachments 2 weeks), Logseq (1 year page history), Standard Notes (per plan) | Our revision ledger exists but has no restore surface and no stated retention; retention is also the main storage driver. | M | P0 |
| Conflict inspector showing winner / losing revisions and their hashes | LiveSync (Hatch) | Lets the user resolve without leaving the app; our hashes make this cheap. | M | P1 |
| Selective sync: include/exclude regex relative to vault root, evaluated server-side | Syncthing .stignore, Remotely Save (two regex lists), LiveSync (regex pair + max size) |
Server-side filtering at the change-feed level is impossible for the browser-hosted plugins — a real edge for NotesCraft. | S/M | P1 |
| Attachment tier: on-demand download, separate blob feed, per-device size cap | Joplin (Always/Auto/Manual; 10 MB mobile hard limit), Dropbox online-only, Drive "Stream files", LiveSync fetch-chunks-on-demand | Phone data plan and battery; the 25 MB server cap needs a lower mobile cap and a separate download policy. | M | P1 |
| Resumable / chunked transfer for large blobs | Syncthing (128 KiB–16 MiB blocks), Dropbox upload sessions, Drive resumable upload, LiveSync content-defined chunks | Mobile uploads fail on flaky links; a resumable PUT is the difference between "lost 20 MB" and "resumed". | M | P1 |
| Headless client sharing the sync engine with the GUI | Obsidian Headless, LiveSync livesync-cli, Syncthing CLI, Joplin Terminal |
CI, seeding, server-side archival, scripted backup — and it answers "can it sync without the app". | M | P1 |
| Config / plugin / theme sync as an explicit opt-in with separate semantics | Obsidian (opt-in community plugins), LiveSync (Customisation Sync + Hidden File Sync), Remotely Save (experimental) | Needed for a real multi-device experience, but it must not drag device-local workspace state into conflicts. | M | P1 |
| Explicit per-device settings that never sync (device name, conflict strategy, selective rules) | Obsidian (all three are device-specific) | Prevents the classic surprise where one phone's rule silently changes another device's behaviour. | S | P1 |
| Safety valve: abort sync when more than X% of files would change | Remotely Save (protectModifyPercentage, default 50) |
Cheap insurance against a corrupted client or a mis-scanned vault wiping the server. | M | P1 |
| Explicit server-blind-E2EE claims with a stated metadata leak surface | Obsidian (deterministic hashes, no path↔content binding), Standard Notes (Argon2 + XChaCha20, zero-knowledge), LiveSync (AES-GCM + HKDF, ID key, visible sizes) | A homelab owner will ask "can the server read my notes?"; the honest answer must name exactly what metadata leaks. | L | P2 |
| Revocable read-only share links derived from a retained revision | Obsidian Publish ($8/site/month), Joplin publish-note, Logseq Publish (per-page password), Standard Notes Listed (shutting down 2026-12-31) | Genuinely underserved and a natural fit for a self-hosted service that already stores history. | L | P2 |
| Shared vaults with per-user roles | Obsidian (max 20 collaborators, no fine-grained roles), Notion (full role taxonomy), Dropbox (shared folders) | Kept as a v1 non-goal, but the data model should not preclude it later. | L | P2 |
| Plan-shaped retention and storage accounting with prune / largest-files view | Obsidian (history counts against the quota; sync stops at the cap) | Even self-hosted needs a storage story once MinIO fills up, and a "prune" tool is the escape hatch. | S | P2 |
| Backup as a separate, explicitly-labelled feature from sync | Obsidian ("Sync is not a backup"), Logseq (hourly auto-backups, last 12) | Users conflate the two; a named backup makes the promise explicit and prevents the "sync ate my file" story. | S | P1 |
| Single-writer / lock semantics for upgrades and migrations | Joplin (SYNC vs EXCLUSIVE locks with expiry) | Our monotonic seq plus a device lease gives this cheaply and prevents two clients upgrading a vault at once. |
S | P1 |
| Audit trail for sharing and destructive actions | Notion (audit log, paid), Dropbox (admin activity log) | Not needed for single-owner v1, but the event model should be able to record it later. | S | P2 |
Recommendations — the 10 features to build next
- Land the conflict-copy rule exactly as designed, plus a single Conflicts view.
Acceptance: after a concurrent edit on two devices, the server version stays at the original path,
the local version is written as
name (conflict <device> <date>).md, and the Conflicts view lists exactly one entry offering side-by-side view and per-revision restore. - Three-way merge against the stored ancestor, with an explicit "never guess" fallback. Acceptance: when both devices edited disjoint line ranges of a note and the common ancestor is retained, the merged file contains both edits and no conflict copy is created; when the ancestor is missing, a conflict copy is created instead of a guess, and no test ever produces a silently duplicated paragraph.
- Add
resync_requiredplus event compression to/changes. Acceptance: a client whosesinceis older than the server's retained window receives aresync_requirederror, performs a full re-scan, and ends with byte-identical files on both sides and no error state left behind. - Persist a durable, per-device activity log on the server. Acceptance: after one device uploads three files, the vault activity log shows three upload rows with device name, path, byte count and timestamp, and those rows are still readable after the client quits and restarts.
- Ship version history with a restore UI and a stated retention policy. Acceptance: a note edited five times shows five revisions with timestamps in the History panel, restoring revision three replaces the file with those bytes while the newest revision is retained, and revisions older than the configured retention are pruned from the server.
- Make sync status explicit in the UI (desktop status bar and mobile badge). Acceptance: the indicator shows exactly one of Synced / Syncing / Paused / Offline / Error plus the last successful sync time, and a revoked token flips it to Error — sign in again within one sync cycle without touching any file.
- Add server-side selective-sync rules (include/exclude regex relative to the vault root).
Acceptance: a rule
^archive/prevents any file underarchive/from being uploaded or downloaded, and a direct upload of an excluded path is rejected with an error rather than stored. - Design the mobile client around three sync modes plus an on-demand attachment tier. Acceptance: with the Android app backgrounded, a note saved five minutes earlier is uploaded by the OS-scheduled job within 15 minutes without the app being foregrounded, and an attachment larger than the mobile cap is not fetched until the user opens it.
- Ship a headless
notescraft syncclient built on the same core library. Acceptance:notescraft sync --once --vault <path>converges a vault with the server in a CI job with no GUI, no egui dependency and no display available, and exits non-zero on a conflict that needs a human. - Detect and refuse to compete with another sync engine. Acceptance: opening a vault located inside a detected iCloud Drive, Google Drive, OneDrive or Dropbox folder shows a blocking warning naming the other engine and offering to relocate the vault, and starting NotesCraft sync on a vault with another engine writing to it logs an explicit "competing sync engine" warning.
Risks
- Documentation drift is the norm, not the exception. Obsidian's behaviour changed at 1.9.7,
Logseq split into two products with different sync models, Remotely Save's last release was
2024-10-20, Standard Notes renamed its server twice (
syncing-server→syncing-server-js→standardnotes/server), and LiveSync's manifest and docs disagree on versions. Any behaviour copied from this document must be re-verified against the live product before it is written into NotesCraft's spec. - E2EE claims are easy to overstate. Obsidian itself discloses that its encrypted hash is deterministic and that path and content are not cryptographically bound; LiveSync leaves document ids, revision counts and ciphertext lengths visible; Standard Notes is the only product found with a genuinely zero-knowledge design, and it pays for it with a database-first model NotesCraft rejects. NotesCraft's honest position is transport + at-rest encryption with a server-held key, plus an optional per-vault passphrase, plus an explicit list of what the server can observe (path, size, mtime, device id, sequence numbers).
- Mobile background sync cannot be promised as an SLA. iOS schedules BGAppRefreshTask opportunistically, Android WorkManager is best-effort, Remotely Save proved that "background sync" inside an app sandbox is effectively impossible for plugin-style clients, and Obsidian syncs only while the app runs. NotesCraft should promise "eventually, while the app is open or the OS grants a background slot" and offer a foreground "sync now".
- Two engines on one vault corrupt data. Documented everywhere: iCloud Drive on Windows duplicates or corrupts files, Logseq creates zero-byte files that iCloud rejects (data loss), and Obsidian warns that a third-party sync service alongside Sync produces duplicated or corrupted files. A NotesCraft vault inside a cloud-synced folder is a data-loss risk that must be detected, not documented.
- Conflict-copy sprawl. Every product that duplicates the loser lets those duplicates sync onward and multiply; the fix is one visible Conflicts view plus a cleanup path, not more copying.
- Case-insensitive filesystems. Syncthing states the winner of a case conflict is "currently not predictable"; macOS, Windows and Android are all case-insensitive by default, so NotesCraft's path rules and conflict naming must be case-aware and normalised.
- History storage growth and loss. Obsidian's retention is asymmetric (attachments 2 weeks vs notes 12 months), Joplin's synced history means the minimum interval on any device wins, and LiveSync's GC can make historical revisions unreadable. The ancestor revision must be retained at least as long as it can serve as a merge base — that is a hard constraint, not a nice-to-have.
- Storage caps that silently stop syncing. Obsidian stops syncing at the account limit; a self-hosted service will hit a MinIO disk limit the same way. The server must fail loudly and visibly, never silently stop accepting writes.
- The homelab is a single point of failure. k3s, MinIO and the sync server are all on one cluster. The local vault must remain authoritative and fully editable with the server down; sync may never block editing, and a client that cannot reach the server must degrade to local-only with a visible "offline" state.
- Thin or undocumented dimensions. Anytype's selective-sync semantics, retention window and
pricing; Notion's offline page limit, per-tier history retention and upload quotas; Apple's
iCloud-side retention and non-USD pricing; LiveSync's default chunk size; Standard Notes' free-plan
file allowance and default sync interval are all
[unverified]. Do not quote them in product decisions. - Competitive pressure from Obsidian's headless client. Obsidian now ships a headless, E2EE-equal sync client for CI and agents. NotesCraft's headless client should not be a later convenience; it is the surface an AI agent or a server-side job will use first.
Sources
All URLs accessed 2026 (research date 2026-10-20). Official vendor documentation, official pricing pages and official repositories unless labelled otherwise.
Obsidian (Sync, Publish, Git, CLI)
- https://obsidian.md/help/sync/settings
- https://obsidian.md/help/sync/version-history
- https://obsidian.md/help/sync/troubleshoot
- https://obsidian.md/help/sync/messages
- https://obsidian.md/help/sync/security
- https://obsidian.md/help/sync/plans
- https://obsidian.md/help/sync/vault-types
- https://obsidian.md/help/sync/faq
- https://obsidian.md/help/sync/collaborate
- https://obsidian.md/help/sync/headless
- https://obsidian.md/sync
- https://obsidian.md/pricing
- https://obsidian.md/help/sync-notes
- https://obsidian.md/help/cli
- https://obsidian.md/help/publish/publish
- https://obsidian.md/help/publish/setup
- https://obsidian.md/help/publish/security
- https://obsidian.md/help/publish/limitations
- https://obsidian.md/help/publish/media
- https://obsidian.md/help/publish/sites
- https://obsidian.md/help/publish/collaborate
- https://obsidian.md/help/publish/domains
- https://obsidian.md/help/publish/customize
- https://obsidian.md/help/publish/headless
- https://obsidian.md/publish
- https://github.com/Vinzent03/obsidian-git
- https://publish.obsidian.md/git-doc/Tips-and-Tricks
- https://publish.obsidian.md/git-doc/Features
- https://publish.obsidian.md/git-doc/Common+issues
- https://publish.obsidian.md/git-doc/Getting+Started
- https://publish.obsidian.md/git-doc/Integration+with+other+tools
- https://publish.obsidian.md/git-doc/Authentication
- https://community.obsidian.md/plugins/obsidian-git
Joplin
- https://joplinapp.org/help/dev/spec/server_delta_sync
- https://joplinapp.org/help/dev/spec/conflict_auto_merge
- https://joplinapp.org/help/dev/spec/sync
- https://joplinapp.org/help/dev/spec/history
- https://joplinapp.org/help/dev/spec/e2ee
- https://joplinapp.org/help/dev/spec/sync_lock
- https://joplinapp.org/help/dev/spec/server_sharing
- https://joplinapp.org/help/apps/conflict
- https://joplinapp.org/help/apps/note_history
- https://joplinapp.org/help/apps/attachments
- https://joplinapp.org/help/apps/sync/
- https://joplinapp.org/help/apps/sync/e2ee
- https://joplinapp.org/help/apps/sync/nextcloud
- https://joplinapp.org/help/apps/sync/s3
- https://joplinapp.org/help/apps/sync/webdav
- https://joplinapp.org/help/apps/terminal
- https://joplinapp.org/help/apps/publish_note
- https://joplinapp.org/help/apps/share_notebook
- https://joplinapp.org/plans/
- https://github.com/laurent22/joplin/blob/dev/packages/server/README.md
Logseq
- https://github.com/logseq/docs/blob/master/db-version.md
- https://github.com/logseq/docs/blob/master/db-version-changes.md
- https://github.com/logseq/docs/blob/master/pages/Logseq%20Sync.md
- https://github.com/logseq/docs/blob/master/pages/Logseq%20Sync%20Encryption.md
- https://github.com/logseq/docs/blob/master/pages/How%20to%20sync%20your%20Logseq%20graph%20across%20devices.md
- https://github.com/logseq/docs/blob/master/pages/Git%20Auto-Commit.md
- https://github.com/logseq/docs/blob/master/pages/Publishing.md
- https://blog.logseq.com/how-to-setup-and-use-logseq-sync/
- https://blog.logseq.com/logseq-0-9-14-better-sidebars-and-smart-merge-for-sync/
- https://github.com/logseq/logseq/issues/4886, https://github.com/logseq/logseq/issues/5802, https://github.com/logseq/logseq/issues/5901
- https://github.com/logseq/og, https://github.com/logseq/logseq/releases, https://logseq.com/pricing
Syncthing
- https://docs.syncthing.net/users/syncing.html
- https://docs.syncthing.net/users/versioning.html
- https://docs.syncthing.net/users/ignoring.html
- https://docs.syncthing.net/users/security.html
- https://docs.syncthing.net/users/foldertypes.html
- https://docs.syncthing.net/users/introducer.html
- https://docs.syncthing.net/users/untrusted.html
- https://docs.syncthing.net/users/syncthing.html
- https://docs.syncthing.net/users/faq.html
- https://docs.syncthing.net/users/tuning.html
- https://docs.syncthing.net/dev/rest.html
- https://github.com/syncthing/syncthing/releases, https://syncthing.net/
Remotely Save
- https://github.com/remotely-save/remotely-save#readme
- https://github.com/remotely-save/remotely-save/blob/master/docs/encryption/rclone.md
- https://github.com/remotely-save/remotely-save/blob/master/docs/encryption/openssl.md
- https://github.com/remotely-save/remotely-save/blob/master/docs/encryption/comparation.md
- https://github.com/remotely-save/remotely-save/blob/master/docs/sync_algorithm/v3/design.md
- https://github.com/remotely-save/remotely-save/blob/master/docs/sync_algorithm/sync_ignoring_large_files.md
- https://github.com/remotely-save/remotely-save/blob/master/docs/browser_env_no_background_after_closing.md
- https://github.com/remotely-save/remotely-save/releases, https://remotelysave.com/
Self-hosted LiveSync
- https://github.com/vrtmrz/obsidian-livesync#readme
- https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/settings.md
- https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/datastructure.md
- https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/specs_conflict_resolution.md
- https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/specs_garbage_collection.md
- https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/troubleshooting.md
- https://github.com/vrtmrz/obsidian-livesync/blob/main/docs/tips/hidden-file-sync.md
- https://github.com/vrtmrz/obsidian-livesync/blob/main/src/apps/cli/README.md
- https://github.com/vrtmrz/obsidian-livesync/blob/main/utils/readme.md
Standard Notes
- https://standardnotes.com/plans, https://standardnotes.com/features
- https://standardnotes.com/help/1/who-can-read-my-private-notes
- https://standardnotes.com/help/3/how-does-standard-notes-secure-my-notes
- https://standardnotes.com/help/17/how-do-i-share-a-private-note
- https://standardnotes.com/help/26/how-do-i-enable-note-version-history
- https://standardnotes.com/help/36/how-do-i-attach-encrypted-files-to-my-notes
- https://standardnotes.com/help/47/can-i-self-host-standard-notes
- https://standardnotes.com/help/50/can-i-collaborate-with-others-on-a-note
- https://standardnotes.com/help/55/how-can-i-optimize-the-performance-of-standard-notes
- https://standardnotes.com/help/86/share-subscription-with-another-account
- https://standardnotes.com/help/self-hosting/docker
- https://github.com/standardnotes/server, https://github.com/standardnotes/snjs/blob/main/packages/snjs/specification.md
Anytype, Apple, Notion, Dropbox / Google Drive / iCloud Drive
- https://anytype.io/ , https://doc.anytype.io/ , https://anytype.io/pricing/
- https://support.apple.com/guide/notes , https://support.apple.com/guide/icloud
- https://support.apple.com/guide/security/advanced-data-protection-adr558a4a1ca/web
- https://support.apple.com/en-us/102651 , https://support.apple.com/en-us/118247
- https://support.apple.com/guide/iphone/manage-settings-for-apple-services-iph3c2c1d1e4/ios
- https://www.apple.com/icloud/
- https://www.notion.com/help/use-pages-offline , https://www.notion.com/help/duplicate-delete-and-restore-content
- https://www.notion.com/help/sharing-and-permissions , https://www.notion.com/help/publish-and-share-your-content
- https://www.notion.com/help/security-and-privacy , https://www.notion.com/help/audit-log , https://www.notion.com/pricing
- https://help.dropbox.com/sync/resolve-file-conflicts , https://help.dropbox.com/sync/version-history
- https://help.dropbox.com/sync/selective-sync , https://help.dropbox.com/sync/ignore-files
- https://help.dropbox.com/sync/sync-status , https://help.dropbox.com/account-preferences/bandwidth
- https://help.dropbox.com/share/shared-folders , https://help.dropbox.com/share/create-or-manage-shared-links
- https://www.dropbox.com/individual , https://www.dropbox.com/business , https://www.dropbox.com/cli
- https://www.dropbox.com/developers/documentation/http/documentation
- https://support.google.com/drive/answer/13401920 , https://support.google.com/drive/answer/2375091
- https://support.google.com/drive/answer/2424824 , https://one.google.com/about/plans