Best Cloud Hosting & Infrastructure Pricing Compared (2026)

The cloud infrastructure landscape has fractured into distinct tiers: raw compute providers (AWS, Google Cloud), managed platforms (Heroku, Vercel), and specialized edge networks (Cloudflare Workers). Each charges differently and targets different audiences. This guide compares actual 2026 pricing across six cloud providers so you can calculate the true cost of running your application.

The choice between cloud providers isn't just about features—it's about total cost of ownership. A startup using AWS EC2 might pay $0.0116/hour ($250/month), while the same workload costs $4–48/month on DigitalOcean. Understanding these differences means the difference between sustainable unit economics and bankruptcy.

This analysis covers Infrastructure-as-a-Service (IaaS), Platform-as-a-Service (PaaS), and serverless edge providers. We include real pricing for compute, databases, and storage so you can forecast your actual bill.

Pricing at a Glance

IaaS (Infrastructure-as-a-Service)

AWS EC2

Micro instance (t3.micro): $0.0116/hour → ~$8.50/month (always-on)
Standard instance (t3.small): $0.0208/hour → ~$15.20/month
Memory-optimized (r6i.large): $0.168/hour → ~$122/month
Storage (S3): $0.023/GB/month
Data transfer: $0.09/GB outbound
Free tier: 750 hours/month t2.micro (first 12 months)

Google Cloud Compute Engine

Micro instance (e2-micro): $0.006/hour → ~$4.40/month
Standard instance (e2-small): $0.012/hour → ~$8.80/month
Memory-optimized (m2.medium): $0.161/hour → ~$117/month
Storage (Cloud Storage): $0.020/GB/month
Data transfer: $0.12/GB outbound (US egress)
Free credit: $300 for 90 days (new accounts)

DigitalOcean (Droplets)

Micro droplet (512 MB RAM): $4/month (fixed monthly billing)
Basic droplet (1 GB RAM): $6/month
Standard droplet (4 GB RAM): $24/month
High-memory droplet (48 GB RAM): $384/month
Managed databases (PostgreSQL): $15–300/month
App Platform (managed): $5–12/month

PaaS (Platform-as-a-Service)

Vercel

Free hobby tier: $0/month (includes 1000 function invocations, 100 GB bandwidth, up to 100 build hours)
Pro: $20/month/seat (unlimited functions, edge config)
Enterprise: Custom pricing
Overages: $0.50 per 1000 function invocations beyond free tier

Heroku (Eco Plan)

Eco dyno: $5/month (auto-sleeps after 30 min inactivity)
Basic dyno: $7/month (always running)
Standard dyno: $25/month (6 GB RAM, standard performance)
Managed PostgreSQL: $9–500/month depending on plan
Total basic setup: $16–32/month

Cloudflare Workers (Serverless Edge)

Free: 100,000 requests/day (unlimited, truly free)
Paid: $5/month + $0.50 per million requests (10M included)
Workers KV storage: Included in paid plan
R2 object storage: $0.015/GB stored, $0.015/GB downloaded
Durable Objects: $0.15 per million requests

Individual Provider Breakdown

AWS: The Industry Standard (Most Complex)

Strengths: Global reach, 200+ services, pay-per-use model, free tier, dominant market share

Pricing Structure: Usage-based. You pay only for what you use, second by second for compute.

Real Cost Example: Running a Node.js API

Scenario: A startup runs a REST API with 10,000 daily active users, 50 requests per user per day = 500,000 requests/month.

Compute: t3.small instance (2 vCPU, 2 GB RAM): $0.0208/hour × 730 hours = $15.18/month
Database: RDS PostgreSQL (db.t3.micro): $0.017/hour × 730 = $12.41/month
Data transfer out: 500,000 requests × 5 KB response = 2.5 GB outbound × $0.09 = $0.23/month
CloudFront CDN: 2.5 GB × $0.085 = $0.21/month

Total: $27.03/month for a production-ready API

Hidden costs to watch:

NAT Gateway charges ($32/month for 1 GB processed data)
Load balancer ($16/month minimum)
VPN endpoint ($7/month) if you need hybrid connectivity
Data transfer between regions ($0.02/GB)

Real bill at scale (1M requests/day):

With NAT Gateway, load balancer, RDS replication: $150–300/month minimum

Google Cloud: Free Credits + Competitive Compute

Strengths: $300 free credit (90 days), lower per-hour compute costs, strong data analytics

Pricing Structure: Similar to AWS but with aggressive pricing for new accounts

Real Cost Example: Running a Node.js API

Same scenario: 500,000 requests/month, 10,000 DAU

Compute: e2-small (2 vCPU, 2 GB RAM): $0.012/hour × 730 hours = $8.76/month
Cloud SQL PostgreSQL (db-f1-micro): $0.025/hour × 730 = $18.25/month (includes storage)
Cloud Run (serverless alternative): 500,000 requests × $0.00004 = $20/month (simpler, no instance management)
Cloud Storage: 50 GB data × $0.020 = $1/month

Total: $28–40/month depending on architecture choice

Key difference: Google Cloud Run is serverless, so you only pay per request. Perfect for unpredictable traffic.

$300 free credit covers 10 months of this setup, making GCP an exceptional choice for new projects.

DigitalOcean: The Affordable Alternative

Strengths: Simplicity, flat monthly pricing, no surprise bills, managed services, excellent documentation

Pricing Structure: Fixed monthly billing. No hourly micro-charges. Predictable.

Real Cost Example: Running a Node.js API

Same scenario: 500,000 requests/month

Compute: Standard Droplet (4 GB RAM, 2 vCPU): $24/month
Managed PostgreSQL: Standard plan (single node, 10 GB): $15/month
Managed Redis (optional): $15/month
Backups (automatic): Included

Total: $39–54/month with full managed experience

Why teams love DigitalOcean:

No surprise bills. $24/month is exactly $24/month.
Managed databases included (no RDS upcharge)
Deploy via App Platform ($5–12/month) for git push deployment
$100 free credit for new accounts

At scale (1M requests/day):

Upgraded to Premium Droplet (16 GB): $96/month
Managed PostgreSQL High Availability: $60/month
Total: $156/month still beats AWS significantly

Vercel: Serverless-First for Frontend Teams

Strengths: Git-integrated deployments, edge network, automatic HTTPS, zero-config

Pricing Structure: Free hobby tier, then $20/month Pro (per seat), then per-overage

Real Cost Example: Running a Next.js App

Scenario: 1M pageviews/month, 50 serverless API calls per pageview = 50M function invocations

Hosting (Pro plan): $20/month (includes bandwidth, functions)
Function invocations: 1,000 free + (50M – 1000) × $0.50 per 1M = $24.995 ≈ $25/month
Edge Config: Included
Edge Middleware: Included

Total: $45/month

Why Vercel is cheap for web startups:

Includes 1,000 free function invocations/month on Pro
First 100 GB bandwidth free
Edge caching reduces origin hits
No database (usually Supabase $5/mo + Vercel $20/mo = $25/mo total)

At scale (100M invocations/month):

Invocation cost: (100M – 1000) × $0.50 per 1M = $49.995/month
Pro seat: $20/month
Total: ~$70/month (surprisingly cheap for 100M invocations)

Heroku: PaaS Simplicity, Premium Pricing

Strengths: Dead simple deploy (git push heroku main), managed environment, zero ops

Pricing Structure: Monthly dyno fees + add-on charges (database, cache, etc.)

Real Cost Example: Running a Node.js App

Scenario: Same 500K requests/month

Eco dyno: $5/month (auto-sleeps, not for production)
Basic dyno (recommended for production): $7/month
PostgreSQL Starter plan: $9/month
Redis (Heroku Data for Redis Starter): $30/month

Total: $46–51/month for a basic app

Total with HA PostgreSQL (production-grade): $7 (dyno) + $50 (PostgreSQL Standard) + $30 (Redis) = $87/month

Why Heroku is expensive despite seeming cheap:

Managed databases aren't cheap ($50–500/month)
Auto-scaling requires Standard+ dyno ($25+)
Build limits, no free tier for existing apps

Heroku fits teams that value developer time over hosting cost. 2 hours saved per month at $100/hr engineering = $200 savings, which pays for $2/month more hosting.

Cloudflare Workers: Edge Computing at Scale

Strengths: Ultra-low latency (runs on 300+ global data centers), 100K free requests/day, no cold starts

Pricing Structure: Free tier (100K requests/day), then $5/month + overage

Real Cost Example: API at Edge

Scenario: Global API, 500K requests/month, average 10 KB response

Free tier: 100K requests/day × 30 days = 3M requests/month free
Paid tier: $5/month + ($0.50 per 1M for 500K – 3M) = $5 + $0 = $5/month
KV Storage (if needed): Included with paid plan
R2 for static files: 0 cost (first 10K requests free, then $0.015/GB stored)

Total: $5–15/month even with heavy usage

Why choose Cloudflare Workers:

100,000 requests/day = 3M/month completely free
No cold starts (always warm globally)
Lowest latency in the world (avg 10ms)
Ideal for APIs, CDN origin protection, rate limiting

At 100M requests/month:

Free: 3M
Paid: $5 + (100M – 3M) × $0.50 per 1M = $5 + $48.50 = $53.50/month

Comparison Table

|----------|-------------------|----------|-------|---------|

| AWS | $8.50–$15 | $12–50 | $27–65/mo | $150–300/mo |

| Google Cloud | $4.40–$8.76 | $18–25 | $28–40/mo | $100–200/mo |

| DigitalOcean | $4–24 | $15–60 | $39–54/mo | $150–200/mo |

| Heroku | $5–25 | $9–500 | $46–87/mo | $200–500/mo |

Recommendation Matrix

Best for Startups (Proof of Concept): Google Cloud Platform

Why: $300 free credit = 10 months free for small apps
Setup time: 15 minutes (Cloud Run)
Cost at launch: $0 (uses credit)

Best for Bootstrap/Indie Hackers: DigitalOcean

Why: Predictable $24/month, managed databases, no surprise bills
Setup time: 30 minutes
Cost: $39/month with database included

Best for Simple Web Apps: Vercel

Why: Git-integrated, includes edge network, $20/mo Pro tier covers most startups
Setup time: 5 minutes (connect GitHub)
Cost: $20–45/month

Best for Global APIs: Cloudflare Workers

Why: Lowest latency, 3M free requests/month, $5/mo paid tier
Setup time: 10 minutes
Cost: $0–5/month for most use cases

Best for Scaling Beyond 1M Requests/day: AWS or Google Cloud

Why: Economy of scale, compute costs below $100/month
Setup time: 2–4 hours (infrastructure as code)
Cost: Negotiate reserved instance discounts (20–40% savings)

Best for Zero-Ops Deployments: Heroku

Why: git push deploy, no infrastructure management, includes SSL
Setup time: 5 minutes
Cost: $46–87/month (premium for simplicity)

Real Cost Scenarios

Scenario 1: New SaaS Startup ($0–50/month budget)

A bootstrapped founder wants to launch a web app. Priority: minimize cost, avoid surprise bills.

Recommended: Google Cloud + Cloud Run + Firestore

Cloud Run (serverless): First 2M requests free, then $0.00004/request
Firestore (database): First 1GB storage free, then $0.18/GB stored
Cloud Storage: 5GB free, then $0.020/GB

Monthly cost for 1M requests + 10 GB data: $10–20

Plus $300 free credit = 10 months free

Alternative: DigitalOcean $4 Droplet + PostgreSQL = $19/month total

Less elegant, but works immediately without waiting for credit approval

Scenario 2: Growing B2B SaaS ($100–500/month budget)

A team of 3 engineers is at 50K monthly active users, 10M requests/month. Priority: reliability, not cost.

Recommended: DigitalOcean or AWS

DigitalOcean:

Standard Droplet (4 GB, 2 vCPU): $24/month
PostgreSQL HA (High Availability): $60/month
Managed Redis: $15/month
Spaces (object storage): $5/month
Total: $104/month with automatic HA failover and backups

AWS (equivalent):

EC2 t3.small + RDS PostgreSQL HA + ElastiCache: $80–120/month
But add NAT gateway ($32/mo), load balancer ($16/mo) = $128–168/month
Better for regional expansion (AWS has 30 regions, DigitalOcean has 13)

Winner for this scenario: DigitalOcean (simpler, cheaper, all-in)

Scenario 3: Enterprise with Global Traffic ($500–5000/month)

A Series A startup with 100K DAU, 200M requests/month. Priority: latency, scale, reliability.

Recommended: AWS or Google Cloud + Cloudflare Workers for edge

Architecture:

AWS EC2 auto-scaling (5–10 instances avg): $80–150/month
RDS PostgreSQL Multi-AZ: $200–400/month
CloudFront CDN: $50–100/month
S3 storage: $10–50/month
Cloudflare Workers for edge API: $100/month
Data transfer egress: $300–500/month (often overlooked)

Total: $750–1,500/month

Note: Data transfer egress is the hidden cost at scale. AWS charges $0.09/GB outbound, which adds up fast at 100 Gbps.

Cost optimization: Negotiate AWS commitment discount (25% annual) = save ~$200/month

Hidden Costs and Gotchas

AWS: Data Transfer Egress

AWS charges $0.09/GB for data leaving your VPC (transferred out to internet). A streaming app transferring 1 TB/day pays $2,700/month just in egress fees.

Mitigation: Use CloudFront CDN ($0.085/GB) or negotiate volume discounts with AWS.

GCP: Egress to Non-Google Networks

Google Cloud charges $0.12/GB for US-to-internet egress (more than AWS). But intra-Google services (YouTube, Gmail, Firebase) are free egress.

Mitigation: If you use Google APIs heavily (Looker, BigQuery, Vertex AI), Google's pricing advantage compounds.

DigitalOcean: Limited Region Expansion

DigitalOcean has 13 regions. AWS has 30 regions. If you need to serve Nigeria or Osaka, AWS/GCP/Azure may be required.

Cost impact: DigitalOcean Singapore for US-based users = $50/month but poor latency. AWS Mumbai + US = $30–50/month and 50ms lower latency.

Vercel: Function Invocation Overages

A single memory leak causing 1 billion function invocations could cost $500/month.

Mitigation: Set invocation budgets in Vercel dashboard. Monitor with DataDog or New Relic.

Heroku: Database Plan Minimums

Even a tiny hobby project needs $9/month Postgres starter. At scale, the cheapest HA database is $50/month. That's 10x DigitalOcean's price.

Mitigation: Migrate from Heroku to Render or Railway for 70% savings (same UX, cheaper infrastructure).

Cloudflare Workers: Cold Start Edge Cases

Workers is free for 100K requests/day. The second you exceed 100K/day, you're on paid tier ($5/month). No gradual ramping.

Mitigation: If you exceed 3M requests/month, Workers costs $50–100/mo (competitive with others). Worth it for the latency gains.

How to Forecast Your Actual Bill

Step 1: Estimate Traffic

Daily active users (DAU): 10,000
API requests per DAU: 50
Daily requests: 500,000
Monthly requests: 15,000,000

Step 2: Estimate Data

Average response size: 5 KB
Monthly data transferred: 75 GB
Data stored in database: 100 GB
Storage needed: 500 GB (includes backups)

Step 3: Apply Provider Pricing

AWS:

Compute (t3.small, 730 hours): $15
RDS PostgreSQL: $25
Data egress (75 GB × $0.09): $6.75
Total: $46.75/month

Google Cloud:

Cloud Run (15M × $0.00004): $0.60
Cloud SQL (100 GB stored): $20
Cloud Storage (500 GB × $0.020): $10
Total: $30.60/month + $300 free credit

DigitalOcean:

Standard Droplet: $24
PostgreSQL Managed: $30
Backups (automatic): Included
Total: $54/month flat

Vercel:

Pro plan: $20
Function invocations: (15M – 1000) × $0.50 per 1M = $7.50
Total: $27.50/month

Cloudflare Workers:

Free tier: 3M requests included
Overage: (15M – 3M) × $0.50 per 1M = $6
Paid plan: $5
Total: $11/month

Step 4: Choose Based on Trade-offs

| Cost Priority | Choice | Rationale |

|---|---|---|

| Minimize Cost | Cloudflare Workers ($11/mo) | Best for APIs, no database |

| Minimize Ops Work | DigitalOcean ($54/mo) | Flat billing, all-in |

| Free Credit | Google Cloud ($30/mo + $300 credit) | Lasts 10 months free |

| Developer Velocity | Vercel ($27.50/mo) | Git push deploy, no config |

| Enterprise Scale | AWS ($50–500/mo) | Negotiate volume discounts |

Final Recommendation

Start here: Use Google Cloud with $300 free credit + Cloud Run. Takes 15 minutes to deploy. No credit card charges for 10 months.

If you're beyond the credit: Choose based on your traffic pattern:

APIs < 3M requests/month: Cloudflare Workers ($5/mo)
Web apps with databases: DigitalOcean ($54/mo) or Vercel ($27/mo)
Global scale (100M+ requests): AWS or Google Cloud (negotiate discounts)

Compare side-by-side with Cloud Hosting Tools on CompareTiers. Check DigitalOcean pricing, explore AWS, and review Vercel directly to see current rates. Most providers offer free tiers or credits—use them to test before committing to annual contracts.

For developer tooling pricing, see our best dev tools pricing guide. Dive deeper into specific cloud matchups with AWS vs Google Cloud, DigitalOcean vs Heroku, or Vercel vs Cloudflare Workers.

Best Cloud Hosting & Infrastructure Pricing Compared (2026)

TL;DR — Our Quick Picks