The $10M Cloud Repatriation: Why Teams are Leaving AWS for Bare Metal & Node.js

August 23, 2026

All Topics Shopify (31)Whatsapp (24)Dev (10)Payments (10)Nodejs (10)Cold email (10)Web fundamentals (8)Wordpress (7)Nextjs (5)Ai (4)Logistics (4)Email (4)Security (3)Advertising (2)Seo (1)Fintech (1)Cms (1)

For the past fifteen years, the prevailing startup wisdom was simple: Never buy physical servers; run everything on Amazon Web Services, Google Cloud, or Microsoft Azure.

The initial premise was sensible: when you are a two-person startup testing an unproven idea, paying $50/month for elastic cloud virtual machines is better than buying a rack of physical hardware.

However, as applications grow past product-market fit into steady, predictable production workloads, the economics invert completely.

What begins as an agile cloud setup gradually morphs into an astronomical monthly invoice: paying massive markups on virtualized RAM, inflated storage egress penalties, and exorbitant hourly fees for managed services that add little actual business value.

In 2022, 37signals (the creators of Basecamp and HEY) shocked the tech ecosystem by announcing they were leaving the public cloud entirely. Two years into their migration, they revealed they had saved over $3.2 million in their first year alone, on track to save more than $10 million over five years.

Here is an architectural and financial breakdown of Cloud Repatriation, why "boring" self-hosted servers with Node.js and Docker are dominating in 2026, and how to evaluate your own infrastructure.

1. The Cloud Markup Trap: What You're Actually Paying For

To understand why companies are leaving the cloud, you have to look at the raw unit economics of compute, memory, and bandwidth.

Public cloud providers (AWS, GCP, Azure) are not selling compute at cost; they are selling managed convenience with gross margins often exceeding 60% to 70%.

Monthly Cost Comparison for High-Throughput Workload (64 vCPU, 256GB RAM, 4TB NVMe):
┌────────────────────────────────────────────────────────┐
│ AWS EC2 (r6i.4xlarge instances + EBS + Bandwidth):     │  ~$3,200 / month
└────────────────────────────────────────────────────────┘
┌────────────────────────────────────────────────────────┐
│ Dedicated Bare Metal (Hetzner / OVH / Equinix Metal):  │  ~$220 / month
└────────────────────────────────────────────────────────┘
┌────────────────────────────────────────────────────────┐
│ Owned Hardware (amortized over 5 years in colocation): │  ~$140 / month
└────────────────────────────────────────────────────────┘

The 3 Biggest Cloud Hidden Taxes:

Bandwidth Egress Extortion: AWS charges up to $0.09 per gigabyte for data leaving their data centers. If your Node.js API serves rich media, high-volume JSON feeds, or image assets, your bandwidth bill alone can exceed your actual compute costs. On bare metal and modern VPS providers, multi-terabyte egress is included free or billed at fractions of a cent.
The "Managed Service" Markup: Running a PostgreSQL database on AWS RDS costs roughly 2.5x to 3x more than running the exact same PostgreSQL database inside a Docker container on raw compute with identical CPU and RAM.
The Multi-Cloud Abstraction Tax: Teams often layer Kubernetes, Istio service meshes, and Terraform scripts on top of AWS to remain "cloud agnostic," inadvertently creating a system so convoluted that they need an entire dedicated DevOps team just to keep the pipelines running.

2. Case Study: 37signals and the $10 Million Bare Metal Exit

When David Heinemeier Hansson (DHH) and the 37signals operations team analyzed their $3.2 million annual AWS and cloud bill, they made a radical realization: their workloads were steady, predictable, and mature.

They did not need "instant auto-scaling from 10 to 1,000 servers in 60 seconds"—they served predictable business software during normal working hours.

The Strategy:

The Investment: 37signals purchased ~$600,000 worth of enterprise Dell servers across two private colocation data center facilities.
The Tooling (Kamal): Instead of using complex Kubernetes clusters, DHH and his team built Kamal—an open-source deployment tool that deploys Docker containers to any bare-metal Linux server or VPS via SSH with zero-downtime rolling updates.
Team Size: They completed the migration of their core applications (Basecamp, HEY, and internal tools) with zero additional operations hires.

The Financial Outcome:

Year 1 Savings: $3.2 million saved.
5-Year Projected Savings: Over $10.5 million after factoring in all hardware amortization, colocation power/cooling rack fees, and high-speed transit bandwidth.

3. The 2026 "Boring Tech" Deployment Stack

Leaving AWS does not mean going back to 2005-style manual FTP uploads or messy bash scripts. Modern bare metal and self-hosted infrastructure uses lightweight, container-native tooling:

┌────────────────────────────────────────────────────────────┐
│                    Cloudflare / Fastly CDN                 │
│              (DDoS Protection & Global Edge Caching)       │
└─────────────────────────────┬──────────────────────────────┘
                              │
┌─────────────────────────────▼──────────────────────────────┐
│       Dedicated Bare-Metal Host / Enterprise VPS           │
│  ┌──────────────────────────────────────────────────────┐  │
│  │ Traefik / Kamal Proxy (Auto Let's Encrypt SSL)       │  │
│  └──────────────────────────┬───────────────────────────┘  │
│                             │ Docker Network                │
│  ┌──────────────────────────▼───────────────────────────┐  │
│  │ Node.js Application Containers (Cluster / Fastify)   │  │
│  └──────────────────────────┬───────────────────────────┘  │
│                             │                               │
│  ┌──────────────────────────┴───────────────┐               │
│  │ Native PostgreSQL 16 (NVMe Direct IO)    │               │
│  │ Redis 7 (In-Memory Cache & BullMQ)       │               │
│  └──────────────────────────────────────────┘               │
└────────────────────────────────────────────────────────────┘

Why Node.js Thrives on Bare Metal:

Direct NVMe Disk I/O: Cloud EBS volumes have strict IOPS throttling unless you pay for premium provisioned IOPS. On bare metal, PostgreSQL and Node.js interact directly with raw PCIe NVMe drives, delivering 10x to 50x faster disk read/write throughput.
Deterministic CPU Performance: On shared public cloud VMs, "noisy neighbors" steal CPU cycles and cause latency jitter. On dedicated hardware, 100% of the physical CPU cores and L3 cache belong exclusively to your Node.js event loop.
Sub-Millisecond Cache Latency: Hosting your Node.js application container on the same high-speed internal Docker bridge as your Redis and PostgreSQL instances drops internal query latency from 3ms–12ms (across cloud VPC subnets) to under 0.2ms.

4. How Kamal Replaced Kubernetes for Lean Teams

For years, developers tolerated cloud lock-in because deploying containers to raw servers without Kubernetes felt daunting.

Kamal fundamentally changed the self-hosting landscape:

# deploy.yml (Kamal Configuration)
service: my-nodejs-app
image: myusername/my-nodejs-app

servers:
  web:
    - 192.168.1.10
    - 192.168.1.11

registry:
  server: ghcr.io
  username: myusername
  password:
    - KAMAL_REGISTRY_PASSWORD

env:
  clear:
    NODE_ENV: production
    PORT: 3000
  secret:
    - DATABASE_URL

Deploying a brand new version of your application with zero downtime is a single command:

kamal deploy

Kamal connects over SSH, pulls the latest Docker image, spins up the new container alongside the old one, waits for health checks to pass, seamlessly switches Traefik routing, and gracefully terminates the old container.

5. Cloud Repatriation Checklist: Is Your Team Ready?

Should every company leave AWS tomorrow? No. But if your application meets these criteria, cloud repatriation could cut your operating costs in half:

✅ You Are a Strong Candidate for Cloud Repatriation If:

Predictable Workloads: Your traffic does not swing by 1,000% from hour to hour.
High Bandwidth / Egress: You spend thousands each month on data-out fees.
High Database Utilization: Your managed cloud database instances (RDS/Aurora) represent more than 40% of your total cloud bill.
Small, Agile Engineering Team: You want your developers focused on shipping features rather than managing complex Terraform/Kubernetes configurations.

❌ You Should Stay on the Public Cloud If:

Early-Stage Pre-PMF: You are building an MVP and traffic is unpredictable.
Heavy Dependency on Proprietary Cloud Services: Your app is deeply reliant on proprietary APIs like DynamoDB, Amazon SQS FIFO, or AWS Rekognition that cannot easily be replaced with open-source equivalents (Postgres, Redis, RabbitMQ).

Frequently asked questions

What is cloud repatriation?

Cloud repatriation is the process of migrating applications, databases, and digital workloads off public cloud platforms (such as AWS, Google Cloud, or Microsoft Azure) back onto dedicated bare-metal servers, private colocation data centers, or cost-effective virtual private servers (VPS).

How much money did 37signals save by leaving AWS?

37signals saved $3.2 million in their first year after exiting the public cloud. Over a 5-year timeline, their total net savings—after purchasing ~$600k of enterprise hardware and paying for colocation hosting, power, and bandwidth—is projected to exceed $10.5 million.

Is self-hosting on bare metal harder than using AWS?

With modern open-source tooling like Docker, Kamal, and Cloudflare, deploying to bare-metal servers is often simpler than managing enterprise AWS setups. You eliminate complex cloud access controls (IAM), VPC subnets, and Kubernetes configurations in favor of a straightforward Linux and container environment.

How do you handle hardware failure on bare metal?

Modern bare-metal setups use hardware redundancy: dual power supplies, RAID 1/10 NVMe disk mirroring, and multiple physical servers behind a load balancer. If an entire server fails, traffic routes to secondary servers while automated backups (such as Litestream for SQLite or WAL-G for PostgreSQL) ensure zero data loss.

Can Node.js run fast enough on a single dedicated server?

Yes. A modern 32-core AMD EPYC or Intel Xeon dedicated server with 128GB RAM running Node.js in cluster mode with a Fastify or Express web server can comfortably handle between 30,000 and 80,000 HTTP requests per second with sub-10ms response times.