What's the best way to back up and sync writing files across a laptop and desktop locally?

Syncthing is a free, open-source application that synchronizes folders directly between devices over your local network or the internet, without routing data through a central server. Once configured, it watches a designated folder on each computer and propagates changes automatically, so your laptop and desktop stay in step. It is ideal for writers who want a set-it-and-forget-it solution and do not need a detailed version history.

Git is a version control system that tracks every change to a set of files. You can host a repository on a local network drive, or push to a private remote if you choose. Pushing and pulling between machines gives you fine-grained control and a readable history of your drafts, which is valuable for long-form projects. The trade-off is that Git has a learning curve and requires manual commands or a GUI client.

Other options include rsync (a command-line tool for one-way or bidirectional mirroring) and standard file-copy utilities, but these are generally better suited to backup than to keeping two machines in sync. For most writers, Syncthing and Git cover the widest range of needs without relying on the cloud.

A reliable local backup strategy starts with the 3-2-1 rule: keep at least three copies of your writing files, on two different types of media, with one copy stored offsite. For example, you might have the working files on your laptop's internal SSD, automatic snapshots on an external USB drive, and a second external drive kept at a different location. This protects against hardware failure, theft, fire, and accidental deletion.

To automate the process, use built-in backup tools or simple scripts. On macOS, Time Machine can create hourly, daily, and weekly versions on an external drive. On Windows, File History offers similar versioned backups. For cross-platform control, rsync (available on Linux, macOS, and Windows via WSL or Cygwin) can mirror folders with a single command, and you can schedule it with cron or Task Scheduler.

• Choose your backup drive: Use an external SSD or HDD with enough capacity to hold multiple versions of your work.
• Set a schedule: Automate backups to run at least once a day, ideally after each writing session.
• Verify your backups: Periodically restore a file from backup to confirm the process works.
• Keep an offsite copy: Rotate a second drive to a safe location outside your home or office.

Because local backups are entirely in your hands, they pair naturally with offline-first writing tools like NeoGlint, which stores all data as local files. That makes it straightforward to point any backup utility at your Spaces folder without worrying about cloud sync conflicts.

Cloud services like Dropbox or Google Drive often create conflicted copies when two machines edit the same file before syncing. Without the cloud, the same risk exists, but local tools give you more control over how conflicts are handled. Syncthing, for instance, detects when a file has changed on both sides and renames the older version with a “sync-conflict” tag, preserving both copies so you can manually reconcile them. Git takes a different approach: it attempts to merge changes automatically, and if it cannot, it marks the file as conflicted and asks you to resolve the differences.

The simplest way to avoid conflicts is to establish a workflow where you only edit on one machine at a time and ensure syncing completes before switching devices. For writers who frequently move between a laptop and desktop, this may mean running a sync manually before packing up. Some tools, like Syncthing, can run continuously in the background and notify you when syncing is complete.

Version control systems like Git are particularly good for writing because they store a complete history, so even if a conflict occurs, you can recover any previous draft. However, they require discipline: you must commit and push changes regularly. For writers who prefer a simpler setup, Syncthing’s automatic conflict renaming is often sufficient, especially if you couple it with a separate backup routine.

Automatic sync tools like Syncthing continuously monitor folders and propagate changes as they happen. This is ideal for writers who move between a laptop and desktop multiple times a day and want their latest work available without thinking about it. However, automatic sync can create conflicts if you edit the same file on both machines before syncing completes. It also means deletions propagate immediately, so an accidental delete on one machine can quickly remove a file everywhere.

Manual sync, using tools like Git or rsync, requires you to explicitly push changes from one machine and pull them on the other. This adds a step to your workflow but gives you a chance to review what is being transferred and to write a commit message describing the change. For long-form writing projects, that review step can be valuable—it forces you to pause and consider the state of your draft. Manual sync also makes it easier to maintain a deliberate backup strategy because you control when and how data moves.

The right choice depends on your working style. If you often jot down notes on your laptop and then continue on your desktop without wanting to run commands, automatic sync is more convenient. If you prefer to keep a clear history of your revisions and only sync when you are ready, manual sync is safer. Many writers combine both: automatic sync for research notes and manual version control for the main manuscript.

Because NeoGlint stores everything as local files, either approach works without modification. You can point Syncthing at your Spaces folder or initialize a Git repository inside it. The tool does not lock you into a particular sync method, which keeps your options open as your needs change.

Syncing locally eliminates the risk of a cloud provider scanning or leaking your data, but it does not automatically protect you from physical theft, malware, or unauthorized network access. If your laptop is stolen, an unencrypted drive exposes all your drafts. To mitigate this, enable full-disk encryption on both machines—BitLocker on Windows, FileVault on macOS, or LUKS on Linux. This ensures that even if the hardware falls into the wrong hands, the files remain unreadable.

When syncing over a network, use encrypted connections. Syncthing encrypts all traffic between devices using TLS, so data cannot be intercepted on your local network. If you use rsync over SSH, the connection is encrypted as well. Avoid syncing over unencrypted protocols like plain FTP or SMB without a VPN. For an extra layer, you can place your writing folder inside an encrypted container such as VeraCrypt, though this may interfere with automatic sync tools that need to access files in real time.

Finally, manage permissions carefully. On a shared computer, ensure your writing folder is only accessible to your user account. If you use a network drive, restrict access to specific devices or users. These measures are straightforward but often overlooked. Writers handling sensitive material—journalists, researchers, or anyone working under confidentiality—should treat local sync as one part of a broader security practice.

• Enable full-disk encryption: BitLocker, FileVault, or LUKS.
• Use encrypted sync: Syncthing and rsync over SSH do this by default.
• Set folder permissions: Limit access to your user account only.
• Consider encrypted containers: For extra protection of highly sensitive files.

A local-first writing setup requires ongoing attention to remain reliable. Without a cloud provider handling uptime and redundancy, you are responsible for verifying that backups are running, syncs are completing, and hardware is healthy. A simple maintenance routine can prevent small issues from becoming data loss.

Start with a weekly review: check that your automatic backup tool has completed its last run and that no errors are reported. If you use Syncthing, open its web interface and confirm that both devices are connected and up to date. For Git, run a quick status check to ensure there are no uncommitted changes. Once a month, perform a deeper check: verify the integrity of your backup drive by running a disk utility, and confirm that your offsite copy is current. Rotate offsite drives every few months if you use physical media.

Twice a year, test a restore. Pick a recent file, delete it from your working folder, and recover it from backup. This confirms that your backups are not corrupt and that you know the recovery steps. Also review your software versions—sync tools and backup utilities receive updates that fix bugs and improve security. Keep a simple document or note describing your setup: which tools you use, where your files are stored, and how to restore them. If something goes wrong, that documentation will save you time and stress.

1. Weekly: Check backup logs and sync status.
2. Monthly: Verify backup drive health and update offsite copy.
3. Quarterly: Rotate offsite drives if applicable.
4. Biannually: Test a full restore and update software.

This routine takes only a few minutes each week but provides confidence that your writing is protected. Because local-first tools give you full control, they also give you full responsibility—but with a lightweight process, that responsibility is easy to manage.