File
SMF·DROPBOX-PLUS
Received on
31.07.2026
Reviewed on
28.09.2026
Exhibits annexed
3
Questions
4

SMF·DROPBOX-PLUS

Can a prompt replace Dropbox Plus?

Cloud storage & backup — file sync

Not yet Verdict recorded on 28.09.2026 · Verified on 31.07.2026
Price
€9.99/moSource: www.dropbox.com · Checked on July 31, 2026
Per year
€119.88
Build time
One sitting
Votes
0 votes
YesAlmostNot yet (checked)

Exhibit tracking slip

Exhibit A The prompt
Exhibit B What you lose
Exhibit C Why people still pay: sync engine reliability
Exhibit Q Questions

Verdict

Sync looks trivial and is not. A correct engine has to handle two machines editing offline, clock skew, case-insensitive filesystems, files locked by an application, renames that look like a delete and a create, and partial uploads on a dropped connection — and it has to do all of it without ever losing a byte. Dropbox has spent a very long time on that, and the storage underneath is its own cost. The consolation is a sync that is honest about conflicts instead of pretending they do not happen.

Exhibit B — What you lose

Exhibit A — The prompt

Received on31.07.2026
Build a file sync engine and treat conflict handling as the feature, not the edge case.

Stack: a client daemon plus a server with object storage and Postgres. Docker Compose. Consider standing on an existing peer-to-peer sync engine and building the reporting around it — say in the README which route you took.

Client: watch a folder with the OS filesystem notification API, plus a full scan on start and a periodic scan as a safety net, because notification APIs miss events under load. Chunk files by content, hash each chunk, upload only unknown chunks.

Metadata per file: path, size, modification time, content hash, and a **version vector per device** rather than a single timestamp. Timestamps lie — clocks drift, and filesystems round differently.

Conflict handling, which is the whole point:
- A conflict is when two devices have versions with neither vector dominating the other. Detect it explicitly; do not compare timestamps and pick.
- On conflict, **keep both**: the local file stays, the other arrives as `name (conflict from DEVICE 2026-07-31 14:02).ext`, and an entry appears in a conflict log with both hashes and both times.
- Never delete or overwrite on conflict. Never merge text automatically.
- A conflicts screen lists unresolved ones with a diff for text files and a keep-this-one action that archives the other rather than deleting it.

The edge cases that must be handled and tested, because these are where real sync engines lose data:
- Case-insensitive filesystems: `Report.txt` and `report.txt` arriving on macOS from Linux.
- Renames detected as rename rather than delete-plus-create, by content hash.
- A file being written while it is read — retry on hash mismatch rather than uploading a torn copy.
- Path length and illegal-character differences between operating systems.
- Deletes propagating, with a trash folder and a retention period so a propagated delete is recoverable.

Status: last sync time per device, pending bytes, and a loud indicator when a device has not synced in longer than a threshold.

Write tests for each edge case above, and specifically for a concurrent edit on two offline devices producing two files and one conflict entry, with zero bytes lost.

Do not build selective sync, placeholders, or a mobile client.

Opening prefills the prompt — press enter to run it.

Exhibit B — What you lose

  • B.1 the storage itself, and its durability
  • B.2 a sync engine hardened against a decade of filesystem edge cases
  • B.3 selective sync and on-demand file placeholders
  • B.4 the mobile apps and their offline handling
  • B.5 sharing links, comments and requests for files

Prior art

Exhibit C — Why people still pay: sync engine reliability

Because sync fails quietly, and the money buys somebody who has already met every way it fails. A homemade engine that loses one file has failed at the only thing it does.

Questions

Why version vectors instead of modification times?

Because clocks disagree, filesystems round to different precisions, and a file copied by some tools keeps its old timestamp. Comparing times to decide a winner is how sync engines delete the wrong version, and the bug is invisible until it matters.

Is keeping both copies not annoying?

It is mildly annoying and it never loses data. Every automatic resolution strategy is a guess about which human was right, and being wrong is unrecoverable — so the annoyance is the correct trade.

Which edge case bites first?

Case sensitivity, if you mix macOS and Linux. Two files that are distinct on one machine and the same on another will loop forever unless you handle it explicitly, and that loop can burn a lot of bandwidth before anyone notices.

How do I get everything out of Dropbox?

The account export produces a full archive, or you can simply copy the local folder if you have full sync rather than online-only files. Shared folders owned by other people do not come across, and version history stays behind.

Receipt

Already built this yourself?