What Can You Actually Run on a $6/Month Droplet? (2026 Benchmarks)

Disclosure: Some links in this guide are affiliate links. If you sign up for DigitalOcean through them, ToolsHubKit earns a small commission — at no cost to you.

Pricing note. Specs and prices are as of July 2026. The entry Basic Droplet is $6/month: 1 GB RAM, 1 vCPU, 25 GB SSD, 1 TB transfer (DigitalOcean moved to per-second billing in January 2026, so you can spin one up, test, and destroy it for pennies). Verify current specs before relying on them.

The $6 Droplet is the workhorse of indie hosting. But 1 GB of RAM and a single shared vCPU is genuinely tight — so the honest question is: what does it actually run well, and where does it fall over? Grab one to follow along — new signups get $200 in free credits for 60 days — and let's find out.

The Contender

First move on any 1 GB box: add swap. It's the difference between a process surviving a memory spike and the kernel's OOM killer nuking it:

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
# Tune swappiness down so swap is a safety net, not a crutch
echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf

How We Benchmark

For each workload we look at two things: idle memory footprint (does it even fit?) and throughput under load. To reproduce the throughput numbers, install a load generator:

sudo apt install -y wrk apache2-utils   # wrk and ab

Then hit an endpoint for 30 seconds with a modest concurrency of 20:

wrk -t2 -c20 -d30s http://localhost:8080/api/health

Reproducibility caveat: exact numbers depend on your app, region, and the shared-CPU neighbors of the moment. Treat the figures below as realistic expectations to calibrate against, then run the commands on your own app for numbers that actually mean something.

Test 1: A Spring Boot API

The JVM is the hungriest guest on this list. A minimal Spring Boot app with embedded Tomcat idles around 300–450 MB — before real traffic. On 1 GB that's survivable but leaves little headroom for the OS and GC.

Make it fit: cap the heap explicitly so the JVM doesn't assume it owns the box.

java -Xmx384m -Xms128m -XX:+UseSerialGC -jar app.jar

• Verdict: ✅ Runs a single low-traffic Spring Boot service fine — internal tools, a webhook receiver, a small JSON API. Expect comfortable throughput for dozens of concurrent users on simple endpoints.
• Falls over when: you add a second JVM, or traffic drives GC churn past your heap cap. For anything production-facing with steady load, step up to the $12 (2 GB) tier — as we recommend in the Spring Boot deploy guide.

Test 2: Laravel + MySQL

PHP-FPM is far lighter than the JVM. A Laravel app with a tuned FPM pool plus a small MySQL instance is a realistic fit for 1 GB — if you keep both lean.

; /etc/php/8.3/fpm/pool.d/www.conf — modest pool for 1 GB
pm = dynamic
pm.max_children = 6
pm.start_servers = 2
pm.min_spare_servers = 1
pm.max_spare_servers = 3

# MySQL: shrink the buffer pool for a small box
[mysqld]
innodb_buffer_pool_size = 256M
max_connections = 40

• Verdict: ✅ A genuine sweet spot. A small Laravel SaaS, a blog, a CRUD app with MySQL on the same box runs comfortably with config caching (php artisan config:cache route:cache view:cache).
• Falls over when: the FPM pool and MySQL buffer pool together exceed RAM under concurrency — you'll see swap thrashing. Keep max_children conservative and enable OPcache.

Test 3: Next.js SSR

A Next.js app in standalone output mode running under PM2 idles around 80–150 MB per instance — Node is lean. The 1 GB box handles a single SSR instance plus Nginx easily.

# One instance is right for 1 vCPU — don't cluster on a single core
pm2 start node --name web -- .next/standalone/server.js

• Verdict: ✅ Very comfortable for a personal site, blog, docs, or a marketing site with moderate SSR traffic. Static and ISR pages are essentially free.
• Falls over when: you try to run npm run build on the box. The build is the real memory hog — it can blow past 1 GB and get OOM-killed. Build in CI (see the GitHub Actions deploy guide) and ship only the artifact, or build with swap active and NODE_OPTIONS=--max-old-space-size=768.

Test 4: A Few Services via Docker Compose

Can you run several small services at once? Yes — if they're lightweight and you're realistic. A workable 1 GB stack:

That leaves a sliver of headroom. Go-based services shine here — a compiled Go binary serving an API often idles under 30 MB.

• Verdict: ⚠️ Possible for 2–3 genuinely small services, especially with Go/Node and a tuned Postgres. Docker's own overhead is modest but not zero.
• Falls over when: any single container is memory-hungry (Java, ClickHouse, Elasticsearch), or you forget to set mem_limit per service and one leaks. For a real multi-app box, the $12 (2 GB) tier is the honest starting point — see self-host your developer stack.

Where It Falls Over — The Short List

1. Build-time RAM. Next.js builds, webpack, and composer install on huge dependency trees are the most common OOM cause. Build in CI, not on the Droplet.
2. A second JVM. One Spring Boot app is fine; two will fight over 1 GB.
3. Untuned databases. Default MySQL/Postgres configs assume more RAM than you have — shrink the buffer pools.
4. No swap. Without swap, a brief memory spike is instant death. Always add 2 GB of swap.
5. Memory-hungry infra. ClickHouse, Elasticsearch, and large ML models need real RAM — don't force them onto 1 GB.

The Verdict: What the $6 Tier Is Genuinely Good For

The $6 Droplet is a legitimately capable little machine for one lean app or a couple of tiny services — provided you add swap, tune your databases, and build your artifacts in CI. The moment you need steady production headroom or a second heavy process, the $12 tier's 2 GB is the natural, still-cheap next step.

Related Guides

• DigitalOcean vs AWS vs Hetzner for a solo dev (2026)
• Self-host Next.js on a $6 Droplet vs serverless
• Deploy Spring Boot to a DigitalOcean Droplet

Resources