The safest pattern is to keep the project on the server, connect through an SSH-based IDE, and make a separate local backup before touching the live files. Use VS Code Remote – SSH or JetBrains Gateway for full remote development; use SSHFS for occasional file access; use rsync when you need a complete local copy or rollback archive.
Need a server to try this on? Antihost offers Linux VPS plans with NVMe storage, full root access and a 14-day free trial.
Do not treat an IDE connection as a backup. First pull the source into a dated local destination, verify that the copy opens, then make a small change, review the diff, run the project’s normal checks on the server, and keep the pre-edit copy until the change is accepted.
As an Amazon Associate I earn from qualifying purchases.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
What the remote-editing setup should accomplish
A remote IDE connection and a backup solve different problems. The IDE gives you an editor, terminal, extensions, indexing, debugging, and build tools against the server’s environment. The backup gives you an independent rollback point if an edit, deployment, disk failure, or mistaken command damages the working tree.
With SSH-based development, the source can remain entirely on the server. Your local computer displays the editor and sends authenticated requests through SSH; it does not have to hold a second working copy. That is useful when a project is too large for a laptop, depends on server-only libraries, or must be tested on the same operating system as the production or game-server environment.
#1 Best Overall
- Get NVMe solid state performance with up to 1050MB/s read and 1000MB/s write speeds in a portable, high-capacity drive(1) (Based on internal testing; performance may be lower depending on host device & other factors. 1MB=1,000,000 bytes.)
- Up to 3-meter drop protection and IP65 water and dust resistance mean this tough drive can take a beating(3) (Previously rated for 2-meter drop protection and IP55 rating. Now qualified for the higher, stated specs.)
- Use the handy carabiner loop to secure it to your belt loop or backpack for extra peace of mind.
- Help keep private content private with the included password protection featuring 256‐bit AES hardware encryption.(3)
- Easily manage files and automatically free up space with the SanDisk Memory Zone app.(5). Non-Operating Temperature -20°C to 85°C
A practical division of labor is:
- VS Code Remote – SSH: a full editor and terminal operating against a remote folder.
- JetBrains Gateway: a local JetBrains Client connected to an IDE backend running on the server.
- SSHFS: a mounted view of the remote filesystem for browsing and occasional individual-file changes.
- rsync: an incremental way to copy a complete tree, create a rollback archive, or maintain a deliberate local synchronization.
Choose one of the first two for regular development, and use rsync independently for the pre-edit backup. SSHFS is a convenience layer, not a replacement for a verified backup.
Requirements and decisions before you connect
Confirm the two ends of the SSH connection
Your computer needs an OpenSSH-compatible client. The remote machine needs a reachable SSH server and an account permitted to read and modify the project directory. Confirm the hostname, username, port if it is not the default, and the exact path you intend to open. If the server is behind a firewall or private network, establish that connectivity before troubleshooting the IDE.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Separate live files from backup storage
Create the backup on a different local disk when possible, such as an external SSD. A backup written into the same server directory, or onto the same disk that might fail, does not provide meaningful rollback protection. Give each pre-edit copy a dated directory name and record the hostname, source path, deployment or commit identifier, and backup time in a small text file beside it.
Decide what belongs in the copy
Identify the source directory rather than copying an entire home directory or server. Exclude caches, generated build output, credentials, private keys, logs, and other data that should not enter a general-purpose backup. Keep secrets in the storage and access system intended for them; a local working copy can expand the number of places a secret exists.
Protect the backup from mirror behavior
A rollback copy should normally be a new destination, not a destructive mirror. The rsync --delete option removes files from the destination when they no longer exist at the source. That can be appropriate for a disposable local mirror, but it is unsafe for an archive of the pre-edit state. Use a new dated destination or omit --delete when preserving older files matters.
Rank #2
- MADE FOR THE MAKERS: Create; Explore; Store; The T7 Portable SSD delivers fast speeds and durable features to back up any endeavor; Build your video editing empire, file your photographs or back up your blogs all in an instant
- SHARE IDEAS IN A FLASH: Don’t waste a second waiting and spend more time doing; The T7 is embedded with PCIe NVMe technology that brings fast read and write speeds up to 1,050/1,000 MB/s¹, making it almost twice as fast as the T5
- ALWAYS MAKE THE SAVE: Compact design with massive capacity; With capacities up to 4TB, save exactly what you need to your drive – from large working files to game data and everything in between
- ADAPTS TO EVERY NEED: Whether using a PC or mobile phone, count on the T7 for extensive compatibility²; It’s a true team player when it comes to heavy-duty application usage or file-saving
- HI RESOLUTION VIDEO RECORDING: Record Ultra High Resolution (4K 60fs) videos directly onto the T7 Portable SSD with your favorite camera or mobile devices; Supports iPhone 15 Pro Res 4K at 60fps video and more³
Workflow 1: edit in VS Code with Remote – SSH
Microsoft describes Remote – SSH as an extension that opens a remote folder on a machine, virtual machine, or container with an SSH server and provides the normal VS Code feature set. Commands and extensions run on the remote operating system. The extension installs VS Code Server there and communicates through an authenticated SSH tunnel, so the project does not need to be stored locally for direct editing.
Recommended Free Tools
Connect and open the correct folder
- Install an OpenSSH-compatible client locally and verify that the server accepts your account.
- In VS Code, install the Remote – SSH extension.
- Open the Remote Explorer or the command palette and choose Remote-SSH: Connect to Host…. Enter or select the SSH host in the form your account uses, such as
user@hostname. - Accept the host-key prompt only after checking that the hostname and key fingerprint match the server you intended to reach.
- After the remote window opens, choose File > Open Folder… and select the project directory on the server. Check the path shown in the Explorer and run a terminal command such as
pwdbefore editing.
Opening a folder is not the same as downloading it. The editor, terminal commands, and installed remote extensions operate against the server’s files and dependencies.
Make the backup before the first edit
Leave the remote window open, but use a local terminal for the backup. Pull the source into a new local destination. A representative command documented by Microsoft is:
rsync -rlptzv --progress --delete --exclude=.git user@hostname:/remote/source/code/path .For a rollback archive, change the final destination to a new dated directory and remove --delete. For example:
mkdir -p ~/server-backups/project-2026-10-15-1430
rsync -rlptzv --progress --exclude=.git user@hostname:/remote/source/code/path ~/server-backups/project-2026-10-15-1430/The date and time in that path are an example naming convention; use the actual run time for your copy. Add exclusions for caches, build artifacts, secrets, and other data you deliberately decided not to retain. If the destination already contains files, perform a dry run or review mode first so that you can see what would change before writing.
Free tools Windows power users keep installed
One-click scans. No signup required.
Rank #3
- Solid state performance with up to 800MB/s read speeds in a portable drive. (Based on internal testing; performance may be lower depending on host device, interface, usage conditions and other factors. 1MB=1,000,000 bytes.)
- Back up your content and memories on a storage solution that fits seamlessly into your mobile lifestyle.
- Take it with you on your adventures—up to two-meter drop protection means this durable drive can take a beating. (Based on internal testing.)
- Secure it to your belt loop or backpack for extra peace of mind thanks to the tough rubber hook.
- From Sandisk, a brand professional photographers trust to take on assignments.
Work in small, reviewable increments
- Open one file or one tightly related set of files.
- Make the smallest change that can solve the problem.
- Use the Source Control view or a remote terminal to inspect the diff. Confirm that generated files, credentials, and unrelated configuration did not change.
- Run the project’s normal tests, build, lint, or game-server validation commands on the remote host, where the correct dependencies and operating system are available.
- Exercise the affected feature in a staging or maintenance window when the files control a running service.
- Deploy or restart only after reviewing the result. Keep the original local copy separate until the change has passed its checks.
Creating and verifying a safe local backup with rsync
Why rsync is suited to repeated backups
Rsync compares the source and destination and transfers files that need updating instead of copying the entire tree every time. That makes it useful for a large project, a second pre-edit snapshot, or a local copy used by tools that cannot work efficiently over a remote mount.
A conservative first run
- Create a fresh destination on a separate local disk or external SSD.
- Review the source path and exclusions. Make sure you are pulling from the intended host and not a similarly named test machine.
- Run rsync in a dry-run or review mode if your installed version and wrapper provide one, especially when reusing a destination.
- Run the transfer without
--deletefor an archival snapshot. - Check that key files open from the local destination. Record the server hostname, source path, deployment or commit identifier, and timestamp beside the copy.
Rsync’s archive-style flags preserve the file attributes represented by -rlpt; compression and verbose progress are represented by -zv and --progress. The exact permissions and ownership you can preserve depend on the account and filesystem, so treat a successful transfer as a content backup rather than proof that every server permission can be recreated on another machine.
When --delete is appropriate
Use --delete only when the destination is disposable or intentionally mirrors the source. It is useful for maintaining a clean local working tree, but it can erase an older file from the destination during a later synchronization. Never use it casually on the only rollback copy. A new dated destination for each pre-edit snapshot is the simplest protection against that mistake.
What to verify after the transfer
- The destination contains the expected top-level directories and key configuration or source files.
- Files open locally without obvious truncation or encoding problems.
- The destination is on the intended disk and has enough free space for the tree.
- The recorded hostname and path identify exactly which server state was captured.
- The original backup remains untouched while you edit the live tree.
Workflow 2: SSHFS for occasional file access
SSHFS mounts the remote filesystem so local applications can browse it as though it were a directory. It is convenient for looking through a project, downloading a file, or making an occasional single-file edit without setting up a full remote IDE.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteSSHFS is slower for bulk operations. Large directory scans, dependency trees, asset collections, and repeated builds can make a mount feel unresponsive, and a local tool may issue many small reads and writes across the network. Use rsync when you need a complete tree locally or when a local build tool performs extensive filesystem operations.
Rank #4
- NONSTOP SPEED: Race through projects with our fastest SSD for creators; Load, edit and transfer with sustained read and write speeds of up to 2,000MB/s1; The T9 Portable SSD performs at high speeds even during longer processes
- DYNAMIC THERMAL GUARD: When you’re elbow-deep in a passion project, the T9 Portable SSD stays cool; Its advanced thermal solution withstands and controls heat to keep the SSD at ideal temperatures—even in heavy use2
- ADAPTS TO EVERY NEED: Whether you’re using a desktop, camera or a gaming console3, count on the T9 Portable SSD for extensive compatibility; It’s a true team player when it comes to heavy-duty application usage or file-saving
- STRONG. SOLID. STABLE: From concept to completion – the T9 Portable SSD gives you the longevity to last through heavy use with one convenient drive that dares to go the distance
- WORKS LIKE MAGIC: Your T9 Portable SSD performs like new with the always up-to-date Magician Software; With firmware updates, extra encryption and continual monitoring of your drive health, it works like a charm
Use the mount as a view, not as your only safety net
Mounting a directory does not create a second copy. If an editor saves a bad change through the mount, the server file changes immediately. Pull a dated rsync copy first, then use SSHFS for the narrow task. Unmount the filesystem when finished and avoid running destructive cleanup commands against a path you could mistake for a local directory.
Workflow 3: JetBrains Gateway and a remote IDE backend
JetBrains Gateway is a lightweight launcher that connects to a remote server, downloads or starts the backend components there, and opens the project in JetBrains Client. The remote host stores the source code and runs the backend IDE; the local client supplies the interface.
This model is useful when indexing, builds, debugging, and execution should use the server’s CPU, operating system, SDKs, and dependencies. It is not the same as an SFTP editor that merely moves individual files. The backend remains remote, so local disk space is not a requirement for the project tree, but the server must have enough resources for the IDE and the workload.
Connection sequence
- Confirm SSH access and the project path before opening Gateway.
- Start Gateway and choose the remote-development connection option.
- Enter the server and authentication details, then select the project directory.
- Allow Gateway to install or start the compatible backend components on the server.
- Open the project in JetBrains Client and verify the displayed path and configured SDK before changing files.
- Create the local rsync backup independently, then edit, build, debug, and review from the remote backend.
If the backend cannot start, check disk space, available memory, supported operating-system requirements, and whether the account can write to the directory used for backend components. Fixing the IDE connection does not restore files; that is the purpose of the separate backup.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Choosing between Remote – SSH, SSHFS, rsync, and Gateway
| Method | Where code lives during editing | Best use | Main trade-off |
|---|---|---|---|
| VS Code Remote – SSH | Remote server | Full IDE editing, terminal, extensions, and debugging on the host | Requires SSH access and remote-side VS Code Server setup |
| SSHFS | Remote filesystem mounted locally | Occasional single-file edits and browsing | Slower for bulk reads and writes |
| rsync | Local synchronized copy plus remote tree | Backups, local tools, and complete-tree workflows | Requires an explicit sync direction and careful conflict handling |
| JetBrains Gateway | Remote backend with a local client | JetBrains indexing, build, debug, and deployment on the server | Uses remote backend resources and needs a Gateway-compatible setup |
For most server-side projects, the combination is Remote – SSH or Gateway for editing plus rsync for the rollback copy. Choose SSHFS only when the convenience of a mounted path outweighs its slower bulk performance.
Best Value
- Capacity Display Variance: 500GB external ssd often appears as around 465GB on Windows. MacOS can show full 500 GB capacity. This is binary calculation difference and doesn’t affect SSD hard drive actual physical storage
- 1050 MB/s Speed: Instantly access to your files with blazing-fast 10Gbps external SSD read up to 1050MB/s and write up to 1000MB/s. LED Light indicates USB SSD instant activity
- Data Security: Solid state drives S.M.A.R.T. health diagnostics and adaptive TRIM optimizing data block management ensures consistent write speeds and extends the longevity of the portable SSD
- USB-C & USB-A Cable: Both cables featuring rapid USB 3.2 Gen2, this USB SSD effortlessly bridges devices, enabling seamless cross-platform file transfers and backup between computers, smartphones, tablets and iPhone
- Always Fast: No slowdowns for large file transfers. With SLC caching (25% of current available capacity allocated as high-speed cache), this external SSD delivers steady 10Gbps for transfers within the cache capacity
A disciplined edit, test, and deploy cycle
Before touching the live tree
- Confirm the server, account, and exact source directory.
- Create and verify a dated local copy.
- Record the current deployment or commit identifier.
- Identify whether the service needs a maintenance window or restart.
During the change
- Change one small, related unit at a time.
- Inspect the diff after every save group.
- Do not overwrite configuration with a local file whose environment-specific values you have not checked.
- Keep the backup destination separate from any synchronization target used for development.
After validation
- Run the normal checks on the remote host.
- Review the final diff and the files modified by the build or deployment process.
- Apply the deployment or restart procedure appropriate to the project.
- Observe the service or game server for the expected behavior.
- Retain the pre-edit copy until acceptance is complete, then follow your own retention and disposal policy.
There is no universal retention period, backup frequency, recovery-point objective, recovery-time objective, or performance benchmark established for this workflow. Set those values according to the server’s importance and your ability to recreate its state.
Recovery when an edit goes wrong
If the file is wrong but the service is still running
Stop making further edits. Capture the current state if it may help diagnosis, compare it with the pre-edit copy, and restore only the affected files from that dated destination. Re-run the normal checks before restarting or redeploying.
If the service fails after deployment
Use the recorded deployment or commit identifier and the pre-edit backup to identify exactly what changed. Restore the smallest known-good set, run validation on the server, and restart according to the service’s normal procedure. Do not turn the rollback archive into a mirror with --delete while attempting to recover.
If the local backup is incomplete
Do not assume a successful rsync exit means every desired item belongs in the archive. Recheck exclusions, permissions, free space, and the source path. Pull a new snapshot into a new destination rather than overwriting the only copy, and explicitly capture any files that were intentionally excluded but are required for recovery.
Troubleshooting common remote-edit failures
The IDE cannot connect
- Test the same account and hostname with a plain SSH connection.
- Confirm that the SSH server is reachable and that the account can access the project directory.
- Check host-key changes carefully instead of accepting an unexpected key automatically.
- For VS Code, verify that the remote operating system can install and run VS Code Server.
- For Gateway, verify that the remote backend components can be installed or started and that the server has sufficient resources.
Files appear stale or edits do not show
- Confirm that the IDE opened the intended absolute path.
- Check whether another process rewrites generated files.
- Close duplicate mounts or remote sessions that point to different hosts.
- Use a remote terminal to print the file path and modification time, then compare it with the editor’s workspace.
Rsync would remove files
Stop and inspect the command before proceeding. If the destination is a rollback archive, remove --delete and use a fresh dated directory. If it is a disposable mirror, confirm that the source and destination are correct and that deleting destination-only files is intentional.
Bulk operations are painfully slow
Move the complete-tree operation to rsync rather than SSHFS. Keep the IDE backend on the server when builds and indexing depend on server-side dependencies, and reserve mounted editing for small, interactive tasks.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
