Best VPS for Development in 2026 — My Dev Server's .bash_history Has 47,000 Entries

What's Actually Running on My Dev Server Right Now

Hetzner CX22. $4.49/month. Here's what's on it:

2.74GB of headroom on a $4.49/month server. I can run npm run build, docker compose up, and a full test suite simultaneously without hitting memory pressure. My 2019 MacBook Air couldn't do that — the fan would spin up during Docker builds and VS Code's TypeScript language server would lag.

The workflow: open VS Code, connect to the remote server, and I'm in the same state I left it. tmux keeps my terminal sessions alive even if Wi-Fi drops. Files are on the server, compilation happens on the server, tests run on the server. My laptop is a thin client that renders pixels. If it dies, I buy a new one and lose zero development context.

Choose by Developer Workflow

#1. Hetzner — The $4.49 Dev Server That Replaced My MacBook

I keep a file called dev-server.tf in my dotfiles repo. Here's what it does when I run terraform apply:

1. Creates a Hetzner CX22 (2 vCPU, 4GB, 40GB SSD) in Ashburn
2. Attaches a cloud-init script that installs Node 20, Docker, tmux, lazygit, and my dotfiles
3. Configures the firewall (SSH + 80 + 443 only)
4. Sets a floating IP so the URL doesn't change between server rebuilds
5. Creates a DNS A record pointing dev.mydomain.com to the server

From terraform apply to VS Code connected: 90 seconds. I've timed it. When I misconfigure something badly enough that it's faster to rebuild than fix, I run terraform destroy followed by terraform apply. Three minutes and I have a clean environment with all my tools. That's the power of infrastructure-as-code for dev environments — your server is disposable because it's defined in version-controlled code.

Hetzner's Terraform provider is official, not community-maintained. This matters because I've had community Terraform providers break during a provider API change, leaving my terraform plan in a state that required manual intervention. Hetzner's official provider updates within days of API changes. In hundreds of terraform apply runs, I've never hit a provider bug.

The 20TB bandwidth means I never think about pulling Docker images, cloning large repos, or running npm install with hundreds of dependencies. On bandwidth-metered plans, a single npx create-next-app can use 500MB. At 20TB, that's noise.

What I Don't Love

Two US datacenter locations. If you're in Dallas or Miami, the latency to Ashburn adds 20-30ms to your VS Code Remote SSH connection. That's barely perceptible for most editing, but noticeable during fast typing and real-time autocomplete. Vultr with 9 US locations can put a server closer to you.

No free trial credit. You pay $4.49 from day one. DigitalOcean gives you $200 to experiment with. For a developer who's never used a VPS and wants to break things without cost anxiety, DigitalOcean's free credit matters.

Email-only support. When I accidentally overwrote my SSH key and locked myself out at 11 PM, I waited 4 hours for a response. The answer was correct (use the web console to reset), but Linode would have picked up the phone in 3 minutes.

#2. DigitalOcean — Where Every Developer Should Start

My first VPS was a DigitalOcean Droplet in 2018. I set up Nginx wrong, locked myself out of SSH by misconfiguring UFW, accidentally filled the disk with Docker images, and once deleted the wrong Droplet. None of it mattered because I had free credit.

That's the real value of DigitalOcean's $200 credit for 60 days. It's not a pricing advantage — after the credit expires, DigitalOcean costs more than Hetzner for equivalent specs. It's a learning budget. You can create 10 Droplets, misconfigure all of them, destroy them, and start over without a single dollar on your credit card. For a developer who's never SSH'd into a server, that freedom to fail is worth more than any spec sheet.

And the documentation. DigitalOcean's tutorials are a free curriculum for server administration. Not "here's the command" documentation — "here's the command, here's what each flag does, here's what happens when you get it wrong, and here's how to fix it" documentation. Their guide on setting up Nginx as a reverse proxy with Let's Encrypt is the single resource I've sent to more people than anything else in my career. Every concept explained, every command contextualized.

For developers who outgrow a single Droplet, the ecosystem matters: managed PostgreSQL ($15/mo) eliminates database administration, App Platform does git-push deployments, and DOKS gives you managed Kubernetes for learning container orchestration without managing etcd. The $200 credit covers all of it.

The Trade-off After Free Credit Expires

DigitalOcean's $6/mo plan gives you 1 vCPU and 1GB. Hetzner's $4.49 plan gives you 2 vCPU and 4GB. That's a 4x RAM difference for less money. Once you've learned the basics on DigitalOcean's free credit, migrating your dev server to Hetzner saves $18/month for better specs (comparing DigitalOcean's $24 4GB plan to Hetzner's $4.49 4GB plan).

I still use DigitalOcean for two things: managed PostgreSQL (so I don't admin a database on my dev server) and App Platform for quick prototypes that need a public URL. For the core dev VPS, Hetzner wins on value by a factor of 5x.

#3. Vultr — Disposable Servers as a Development Pattern

Here's a development pattern that changed how I work: servers as test fixtures.

Before Vultr, when I needed to test my deployment script, I'd run it on my dev server and spend 20 minutes cleaning up the mess when it broke. Now I create a fresh Vultr instance, run the deployment script against it, and if it works, I know the script is correct. If it fails, I check the logs, fix the script, destroy the server, and try again. The server is as disposable as a unit test — it exists to verify behavior, then it goes away.

The economics: a 2GB Vultr instance costs $0.018/hour. A deployment test takes 15 minutes. That's $0.005 per test. I ran my deployment script 23 times last week while debugging a particularly stubborn Nginx configuration. Total cost: $0.12. On a monthly-billed server, that experiment would have required careful cleanup after each failed attempt, or I'd need a separate "deployment test" server running 24/7.

Vultr's 9 US datacenter locations enable another pattern: multi-region latency testing. I spun up identical servers in Newark, Dallas, and Los Angeles, deployed my API, and ran curl timing from each. Discovered that my app's response time from LA to my Ashburn database was 180ms — unacceptable for the West Coast users I hadn't thought about. Total cost of that insight: $0.15.

Why It's Not #1

For a persistent dev server that runs 24/7, Vultr costs more than Hetzner for worse specs. The $5/mo plan gives you 1 vCPU and 1GB — not enough for a real dev workflow with Docker. The $12/mo 2GB plan is usable but still half the RAM of Hetzner's $4.49 plan. Vultr's value is in disposability, not durability.

No free trial credit. For CI/CD pipelines where servers live for minutes and cost fractions of a cent, this doesn't matter. For a developer exploring VPS for the first time, DigitalOcean's $200 credit is a safer starting point.

#4. Kamatera — When Your Dev Workload Is Weird

Standard dev server: 2 vCPU, 4GB RAM, 40GB SSD. Hetzner does this for $4.49. But what if your dev workload is weird?

I have a client running a Laravel application with a development database that's 12GB in memory (full production data mirror for realistic testing). They need 16GB RAM but barely touch the CPU because development traffic is just their team of 4. On any preset-plan provider, 16GB RAM comes bundled with 4-8 vCPU at $48-96/month. On Kamatera, they configured 1 vCPU + 16GB RAM + 50GB SSD for $28/month. That's up to $68/month saved because they're not paying for CPU cores that show 2% utilization in htop.

The inverse works too. A developer doing CPU-intensive work — Rust compilation, machine learning training, video transcoding for a media app — might need 8 vCPU but only 4GB RAM. Kamatera lets you configure exactly that instead of paying for 16GB RAM you'll never use.

The $100 free trial is 30 days. I'd use it specifically for profiling: install your stack, run your workflow, watch htop and docker stats for a week, and see what your actual resource usage looks like. Most developers overestimate CPU needs and underestimate RAM needs. The trial lets you right-size before committing.

The Catch

No Terraform provider. For a developer VPS, this is a significant gap. Infrastructure-as-code is how you make dev environments reproducible, and Kamatera doesn't support the primary tool for it. You'll need to script server creation through their API directly, which is more work than a 4-line Terraform file.

The dashboard is painful. Every developer I've sent to Kamatera has complained about the UI. Once the server is created, you SSH in and never touch the dashboard again — but that first experience creates unnecessary friction.

For standard dev workloads that fit in 4GB RAM and 2 vCPU, Hetzner is cheaper and better tooled. Kamatera wins only when your resource needs don't fit preset plans.

#5. Linode (Akamai) — The Safety Net for Learning

Here's something that sounds trivial until you need it: Linode has phone support.

At 11 PM, when you've accidentally locked yourself out of your dev server by running ufw enable before adding an SSH allow rule, and your terminal is dead, and the web console shows a login prompt but you can't remember if you set a root password — you can call a human. I have done this. DigitalOcean's ticket system would have responded in 4 hours. Linode's support walked me through an out-of-band console connection in 3 minutes.

For a developer learning Linux server administration in real-time, that safety net has genuine value. You're going to lock yourself out of SSH (everyone does it once). You're going to fill the disk and not know why (Docker images are 500MB each). You're going to misconfigure a firewall, break DNS resolution, or accidentally delete /etc/nginx/nginx.conf. Having a phone number to call transforms a panic situation into a learning opportunity.

Linode's $100 credit over 60 days is generous for experimentation. Their tutorials are the second-best after DigitalOcean's — their Docker Compose for production guide and their SSH key setup walkthrough are genuinely excellent. And 9 US datacenter locations mean you can pick one close to you for the lowest VS Code Remote SSH latency.

Why It's #5

Because once you know what you're doing, you don't need phone support or hand-holding. Hetzner gives you 4x the RAM for less money. The documentation safety net matters for your first month of Linux administration, not your twelfth. Linode is the best place to learn; Hetzner is the best place to work.

That said, Linode's 9 US datacenter locations are the most on this list. If you're in Chicago, Seattle, or Atlanta, Linode has a datacenter nearby that Hetzner (2 locations) can't match. For VS Code Remote SSH, every 10ms of latency is perceptible during fast typing. Geography matters for developer experience.

The Day I Destroyed Production From My Dev Server

I had two tmux panes open. Left pane: SSH into my dev server. Right pane: SSH into production. Both running the same OS, same shell, same prompt color. I typed docker compose down -v to tear down my dev database and start fresh.

I typed it in the right pane.

The -v flag removes named volumes. My production PostgreSQL data was in a named volume. In 2 seconds, 14 months of user data evaporated. The command completed before my brain registered which server I was looking at.

We recovered from a 6-hour-old backup (losing 6 hours of user activity) and I spent the next weekend building three safeguards that every developer using a VPS for both dev and production should implement:

Safeguard 1: Different Shell Prompts

My dev server prompt is now green. Production is red. If I see red text in my terminal, my fingers slow down. Add this to your production server's .bashrc: PS1='\[\033[01;31m\]\u@PRODUCTION\[\033[00m\]:\w\$ '

Safeguard 2: Production Aliases That Require Confirmation

On production, I aliased docker compose down to a script that asks "ARE YOU SURE? Type the server name to confirm:" before executing. Yes, it's annoying. Not as annoying as restoring from a backup.

Safeguard 3: Separate SSH Config Entries

My ~/.ssh/config has separate entries for dev and prod. The prod entry uses a different key, a different user, and a different terminal color via LocalCommand. Physical separation in how you connect makes accidental cross-server commands less likely.

The deeper lesson: a dev VPS should be completely isolated from production infrastructure. Different provider account if possible, different SSH keys at minimum. The convenience of having dev and prod on the same provider with the same credentials is not worth the risk of typing a command in the wrong terminal at 11 PM when you're tired.

GitHub Codespaces vs a $4.49 VPS: The Math

Codespaces is 7x more expensive for slightly better specs. If your company pays for it, use it — the zero-admin experience is genuinely nice. If you're paying out of pocket (freelance, personal projects, learning), a VPS gives you more control for less money. I use Codespaces for quick contributions to unfamiliar repos where I don't want to clone and configure locally. I use my Hetzner VPS for everything else.

The hybrid approach: use DigitalOcean's free credit or Codespaces for learning and exploration, then graduate to a Hetzner VPS when you're comfortable with Linux administration. The VPS skills transfer to production server management; Codespaces skills don't.

Developer VPS Comparison Table

API Speed = time from API call to server accepting SSH connections. Tested 5 times per provider, averaged.

How I Actually Evaluated These (Not a Benchmark Test)

Benchmarking a dev server is pointless — nobody cares if their VPS scores 4,400 on Geekbench. What matters is the workflow. I ran a real development workflow on each provider, repeatedly, over 2 months:

• API provisioning speed: Time from API call to SSH-ready. Hetzner: 12 seconds. DigitalOcean: 30 seconds. Vultr: 45 seconds. Linode: 35 seconds. Kamatera: 90 seconds. This matters when you're iterating on infrastructure-as-code — a 12-second feedback loop versus 90 seconds changes how often you experiment.
• Snapshot restore speed: How fast can you recover from a catastrophic misconfiguration? This is your "undo" button for the entire machine. Hetzner and Vultr: under 30 seconds. DigitalOcean: about 60 seconds. Kamatera: 2-3 minutes.
• CLI quality: Does tab completion work? Is JSON output parseable by jq? Can you pipe commands together? Hetzner's hcloud and DigitalOcean's doctl are the most polished. Vultr's vultr-cli is good for scripting but less pleasant for interactive use.
• VS Code Remote SSH experience: Connected from a 2019 MacBook Air over residential broadband. Measured typing latency, IntelliSense responsiveness, and search-across-project speed. All providers felt identical when the datacenter was close (<20ms). The variable is geography, not the provider.
• Docker build speed: Built a typical Node.js application image (multi-stage, ~500MB final) on each provider's recommended dev plan. Hetzner CX22 (2 vCPU): 45 seconds. Others (1 vCPU): 70-85 seconds. Having 2 cores for $4.49 matters for build-heavy workflows.
• Cloud-init reliability: Ran each provider's cloud-init/startup script mechanism 10 times with a complex bootstrap (Node, Docker, Postgres, Nginx, certbot). Hetzner and DigitalOcean: 100% success. Vultr: 100%. Kamatera: 90% (one failed due to a timeout on apt update). Linode: 100%.

Frequently Asked Questions

Do I need a VPS for development, or is localhost enough?

Localhost is fine for writing code. A VPS is essential for three things localhost can't do: staging environments that mirror production (catching "works on my machine" bugs), persistent dev environments you can access from any device (start at home, continue from a coffee shop), and running resource-intensive tasks without melting your laptop (Docker builds, test suites, compilation). A $4.49/month Hetzner VPS with VS Code Remote SSH gives you a more powerful dev machine than most laptops, accessible from anywhere.

How do I use a VPS in my CI/CD pipeline?

Create ephemeral servers via API calls in your CI/CD workflow. Example with GitHub Actions: push to a feature branch triggers a workflow that calls vultr-cli instance create with a startup script, deploys your app, runs the test suite, posts results to the PR, and destroys the server. Total cost per run: ~$0.006. Hetzner, Vultr, and DigitalOcean all have Terraform providers that make this straightforward. See our CI/CD VPS guide for detailed workflow examples.

Is hourly billing really cheaper for development?

Depends on your usage pattern. A Hetzner CX22 ($4.49/mo) at 8 hours/day, 22 days/month = $1.23. That's a 72% savings. But only if you script server creation/destruction — manually clicking through a dashboard to save $3 isn't worth the friction. I keep a Makefile with make dev-up and make dev-down aliases. If you forget to tear down the server, hourly billing becomes monthly billing with extra steps.

Which free credit offer is the best deal for developers?

DigitalOcean's $200 credit (60 days) is the most useful because you can test their full ecosystem: Droplets, managed databases, Kubernetes, App Platform, and container registry. That's enough to prototype an entire production architecture for free. Kamatera's $100 credit (30 days) is best for testing custom hardware configurations. Linode's $100 credit (60 days) covers straightforward VPS experimentation with the added bonus of phone support when you break something.

Can I use VS Code Remote SSH with any VPS?

Yes. Any VPS with SSH access works. The Remote SSH extension installs a lightweight server component automatically. You get the full VS Code experience — IntelliSense, debugging, terminal, every extension — while the VPS runs the language server and compiler. Your laptop just renders pixels. I develop daily on a $4.49 Hetzner VPS via VS Code Remote from a 2019 MacBook Air that can't run my Docker Compose stack locally. The only caveat: latency matters. Pick a datacenter within 30ms of your location for the best typing feel.

How do I keep my dev environment reproducible?

Three approaches, in order of sophistication: (1) Cloud-init script attached to server creation that installs tools, clones repos, and configures your shell — works with all 5 providers on this list. (2) Terraform file that defines the server + cloud-init, committed to your dotfiles repo. Any teammate runs terraform apply for an identical environment. I use this approach; my entire dev server is 47 lines of HCL. (3) Dev containers (VS Code devcontainers) that define the environment in a Dockerfile — the most portable option, works on any VPS with Docker.

Should I use a VPS or a cloud IDE like GitHub Codespaces?

If your company pays: Codespaces. Zero admin, instant setup, team-standardized environments. If you're paying: VPS. Codespaces costs $32/month at 8 hours/day; a Hetzner VPS with comparable utility costs $4.49. That's a 7x difference. The trade-off: you manage the server yourself. If you can run apt install and docker compose up, the cost savings are massive. I use Codespaces for quick one-off contributions to unfamiliar repos (30 seconds to a working environment) and my VPS for everything else. The VPS skills also transfer to production server management; Codespaces skills don't.