Developers love flexibility, speed, and the freedom to work from anywhere. But local development setups are often tied to a specific device, OS quirks, or limited hardware. That’s where remote development environments shine — especially ones like VS Code Server (or code-server) and platforms like Coder.
In this post, I’ll explain the advantages of remote dev environments, share my experience deploying Coder at my workplace, and provide a step-by-step guide to setting up a VS Code Server (using code-server) that you can access from anywhere.
The Challenges of Traditional Local Development#
For years, the standard practice has been to install everything needed for development directly onto our local laptops or desktops: the IDE, compilers, interpreters, SDKs, databases, dependencies – the whole stack. While familiar, this approach comes with several significant drawbacks:
- The “Works On My Machine” Nightmare: This is perhaps the most classic problem. Subtle differences in operating systems, installed library versions, environment variables, or configuration between developers’ machines lead to bugs that are hard to reproduce and fix, wasting countless hours.
- Painfully Slow Setup & Onboarding: Setting up a new machine or onboarding a new developer can take hours, sometimes days. Installing the correct versions of all necessary tools, cloning repositories, configuring paths, and resolving inevitable conflicts is a major time sink and barrier to productivity.
- Hitting Hardware Limits: Laptops, especially portable ones, often lack the CPU power, RAM, or fast storage needed for demanding tasks like compiling large codebases, running extensive test suites, or managing multiple development services concurrently. This results in slow performance, frustrating waits, and reduced productivity.
- Tethered to Specific Hardware: Your entire development capability is tied to that one physical machine. If your laptop breaks, gets lost, stolen, or you simply don’t have it with you, you can’t easily work. Switching between a desktop and a laptop means trying to keep two environments in sync.
- Laptop Battery Woes: Running compilers, local servers, and other development tools constantly can drain laptop batteries incredibly fast, forcing you to stay tethered to a power outlet.
- System Bloat and Conflicts: Over time, your local machine accumulates numerous versions of SDKs, runtimes, and project-specific dependencies. This “dev environment creep” can slow down your system, consume disk space, and increase the likelihood of tool conflicts.
- Security Headaches: Source code, configuration files, and potentially sensitive API keys or credentials reside on multiple individual machines. If any one of these devices is compromised or lost, it poses a significant security risk. Enforcing consistent security practices across many local setups is also challenging.
- Operating System Hurdles: Sometimes, development requires tools or configurations specific to a different OS (e.g., needing Linux for specific Docker functionalities when you primarily use Windows or macOS). This often forces developers into complex workarounds like virtual machines or dual-booting.
These friction points are exactly what remote development environments aim to solve.
What Exactly is a Remote Development Environment?#
Think of it like this: instead of running your code editor, compilers, linters, and debuggers directly on your local laptop or desktop, you run them on a separate, often more powerful, machine (the “server”). You then connect to this server from your local device (the “client”) – often just using a web browser or a lightweight client application. Your code lives and runs on the server, but you interact with it seamlessly through the familiar VS Code interface.
Why Use a Remote Development Environment?#
- True Portability: Just open a browser — your dev environment is ready to go on any device.
- Consistency Across Devices: Your development environment (settings, extensions, themes, keyboard shortcuts) remains identical no matter which machine you access it from. Log in via browser, and your VS Code is right there.
- Pick Up Right Where You Left Off: Close your laptop lid or browser tab – your long-running compilations, tests, or data processing tasks keep churning away safely on the server. When you reconnect (even from a different device!), your workspace, terminals, and running processes are exactly as you left them, ready for you to continue instantly. No more restarting builds because your commute ended!
- Access to Server Resources & OS Flexibility: Easily interact with databases, services, or specific hardware configurations available only on the remote server. Run your environment on Linux servers regardless of your local OS.
- Simplified Local Setup: Keep your personal machine clean. No need to install numerous SDKs, runtimes, or dependencies locally just for development. Prevents system bloat and enable faster onboarding.
- Enhanced Battery Life: Since the heavy lifting happens on the server, your local device consumes significantly less power. Addresses battery drain issues.
- Backup and Recovery: Servers are easier to back up and restore. If something fails, redeploy with saved configs, avoiding the hassle of rebuilding a local setup.
Real-World Impact: Deploying Remote Development in Our Workplace#
The individual benefits are great, but deploying a code-server-based remote development solution truly transformed our team’s workflow. Before, we constantly battled the “it works on my machine” syndrome, spent days onboarding new developers, and had developers with less powerful laptops struggling with large builds.
Here’s what changed after we set up centralized code-server instances for our developers:
- Standardization Nirvana: Every developer gets access to the exact same, pre-configured environment. This eliminated inconsistencies.
- Lightning-Fast Onboarding: New team members are productive within minutes, not days.
- Resource Equity: Complex builds run on powerful central servers, leveling the playing field and reducing hardware costs.
- Enhanced Security Posture: Code stays within our secure server infrastructure.
- Uninterrupted Productivity: Developers pick up exactly where they left off, regardless of location or device changes.
The shift required some initial setup, but the gains in consistency, speed, security, and developer satisfaction were undeniable.
How to Deploy Code-Server (VS Code in the Browser)#
For a lightweight, DIY alternative, here’s how to deploy code-server, an open-source tool that runs VS Code on a server, accessible via browser. I’ve used this for personal projects and love its simplicity.
Prerequisites:
- A Linux server (Ubuntu/Debian recommended).
- SSH access to the server.
- sudo or root privileges.
- Optional: a domain name and HTTPS via Nginx or Cloudflare Tunnel
Install code-server:
curl -fsSL https://code-server.dev/install.sh | sh
Start as a Systemd Service
sudo systemctl enable --now code-server@$USER
Now edit your config at ~/.config/code-server/config.yaml
bind-addr: 127.0.0.1:8080
auth: password
password: yoursecurepassword
cert: false
You keep the defaults abd just change the password
Add a Reverse Proxy (Nginx Example)
server {
listen 80;
server_name code.yourdomain.com;
location / {
proxy_pass http://localhost:8080;
proxy_set_header Host $host;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection upgrade;
proxy_set_header Accept-Encoding gzip;
}
}
Secure with HTTPS using Let’s Encrypt or you can refer this guide to for a setup through Cloudflare tunnel.
Access Your Code Server#
- Visit http(s)://code.yourdomain.com
- Log in with your password.
- Use VS Code in your browser, with files, terminals, and tasks preserved across sessions.
Conclusion#
Whether you’re a freelancer, a remote team member, or just tired of configuring dev tools on every machine you use — a remote development environment is a massive productivity boost.
With tools like code-server and Coder, you can streamline your workflow, improve consistency, and make “works on my machine” a thing of the past.
If you haven’t tried it yet, you’re missing out on a better way to build software.