Cloud Vendor Product Matrix#

Choosing between cloud vendors requires mapping equivalent services across providers. AWS has 200+ services. Azure has 200+. GCP has 100+. Cloudflare has 20+ but they are tightly integrated and edge-native. This article maps the services that matter for most applications – compute, serverless, databases, storage, networking, and observability – across all four vendors with pricing, availability, and portability for each.

How to Use This Matrix#

Each section maps equivalent products across vendors, then provides:

  • Pricing model: How you pay (per-request, per-hour, per-GB)
  • Free tier: What you get for $0
  • Portability: How easy it is to migrate to another vendor (High/Medium/Low)
  • Best for: When to choose each vendor’s offering

Portability scores mean:

  • High: Standard API or open protocol. Migration requires config changes only (e.g., S3 API, SQL, SMTP)
  • Medium: Custom API but portable concepts. Migration requires code changes but not architecture changes (e.g., Lambda to Workers)
  • Low: Deeply proprietary. Migration requires rearchitecting (e.g., DynamoDB, Cosmos DB, Durable Objects)

Global Presence#

Metric Cloudflare AWS Azure GCP
Edge locations / PoPs 330+ cities 600+ CloudFront PoPs 200+ PoPs 200+ PoPs
Compute regions N/A (runs at every PoP) 33 regions, 105 AZs 60+ regions 40 regions, 121 zones
Countries 120+ 30+ (regions) 60+ (regions) 40+ (regions)
Model Edge-first (code runs at every PoP) Region-first (you choose where code runs) Region-first Region-first

Cloudflare is fundamentally different: code deploys to every edge location automatically. AWS, Azure, and GCP require you to choose regions and manage replication. This means Cloudflare has the lowest latency for globally distributed users by default, but you cannot pin workloads to specific regions (except with Durable Objects location hints or D1 data localization).

Serverless Compute#

Feature Cloudflare Workers AWS Lambda Azure Functions GCP Cloud Run
Runtime V8 isolates Container-based Container-based Container-based
Languages JS/TS, Rust (WASM), Python (beta) Node, Python, Java, Go, .NET, Ruby, Rust Node, Python, Java, C#, PowerShell Any (Docker)
Cold start <5 ms 100ms-1s (varies by runtime) 100ms-2s 0 (min instances) to 1-2s
Max execution 30s CPU (paid) 15 min 10 min (Consumption), 60 min (Premium) 60 min
Memory 128 MB 128 MB-10 GB 1.5 GB (Consumption) 32 GB
Pricing unit Requests + CPU ms Requests + GB-seconds Executions + GB-seconds vCPU-seconds + memory
Price per 1M requests $0.30 $0.20 + compute $0.20 + compute ~$0.40 (depends on config)
Free tier 100K req/day (no expiry) 1M req/mo + 400K GB-s 1M req/mo 2M req/mo, 180K vCPU-s
Free tier expiry Never Never (Lambda itself) Never Never
Portability Medium Medium Medium High (Docker)

Best for:

  • Cloudflare Workers: Latency-sensitive APIs, edge logic, globally distributed apps. Sub-5ms cold starts are unmatched.
  • AWS Lambda: Event-driven backends, complex AWS integrations (SQS, S3 triggers, Step Functions). Broadest trigger ecosystem.
  • Azure Functions: .NET workloads, Microsoft ecosystem integration, Event Grid / Service Bus triggers.
  • GCP Cloud Run: Docker-based workloads that need serverless scaling. Most portable (any container runs).

Container / VM Compute#

Feature Cloudflare AWS Azure GCP
Containers (managed) Containers (beta) ECS / Fargate Container Apps / ACI Cloud Run / GKE Autopilot
Kubernetes EKS ($0.10/hr/cluster) AKS (free control plane) GKE ($0.10/hr/cluster, free Autopilot)
VMs EC2 Virtual Machines Compute Engine
Bare metal EC2 .metal instances Dedicated Hosts Sole-tenant nodes
Spot / preemptible Spot Instances (up to 90% off) Spot VMs (up to 90% off) Spot VMs (up to 91% off)
GPU instances P/G/Inf instances NC/ND series A2/G2 instances
Portability N/A Medium (EC2), High (EKS/Docker) Medium (VMs), High (AKS/Docker) Medium (GCE), High (GKE/Docker)

Cloudflare does not offer traditional VMs or managed Kubernetes. Cloudflare Containers (beta) run Docker workloads at the edge but are not GA and lack the isolation guarantees needed for security-sensitive workloads. If you need VMs, Kubernetes, GPUs, or bare metal, you need AWS, Azure, or GCP.

Databases#

Relational#

Feature Cloudflare D1 AWS RDS Azure SQL / DB for PG GCP Cloud SQL
Engine SQLite PostgreSQL, MySQL, MariaDB, Oracle, SQL Server SQL Server, PostgreSQL, MySQL PostgreSQL, MySQL, SQL Server
Model Serverless (pay per query) Instance-based (pay per hour) Instance-based or serverless Instance-based
Scaling Auto (reads at edge) Manual (read replicas) Auto (serverless tier) Manual (read replicas)
Max size 10 GB 128 TB (Aurora) 100 TB 64 TB
Free tier 5B reads, 100M writes, 5 GB (no expiry) db.t3.micro 750 hrs/mo (12 months) 750 hrs/mo (12 months) None
Monthly cost (small) $0-5 $15-50+ (instance always running) $15-50+ $10-40+
Portability Medium (SQLite dialect) High (standard SQL) High (standard SQL) High (standard SQL)

Best for:

  • D1: Small-to-medium apps, edge-read-heavy workloads, projects where zero management matters. Not for write-heavy or large databases.
  • RDS/Aurora: Production workloads needing PostgreSQL/MySQL compatibility, high write throughput, mature tooling.
  • Cloud SQL: GCP-native apps, same strengths as RDS in the GCP ecosystem.

Key-Value / Document#

Feature Cloudflare KV AWS DynamoDB Azure Cosmos DB GCP Firestore
Model Key-value, eventually consistent Document/KV, strongly consistent options Multi-model (document, graph, KV, column) Document, strongly consistent
Pricing $0.50/M reads, $5/M writes On-demand: $1.25/M writes, $0.25/M reads Request-based, varies by consistency $0.06/100K reads, $0.18/100K writes
Free tier 100K reads/day (no expiry) 25 GB, 25 WCU/25 RCU (no expiry) 1000 RU/s, 25 GB (no expiry) 50K reads, 20K writes/day (no expiry)
Max value size 25 MB 400 KB 2 MB 1 MB
Global replication Automatic (every PoP) Global Tables (opt-in) Multi-region writes (opt-in) Multi-region (opt-in)
Portability Low (custom API) Low (custom API) Low (custom API, partial Mongo compat) Low (custom API)

All key-value / document databases are low portability. Each has a proprietary API. Choosing one is a long-term commitment. KV is the simplest (just get/put with TTL) but also the most limited.

Object Storage#

Feature Cloudflare R2 AWS S3 Azure Blob GCP Cloud Storage
Egress $0 $0.09/GB $0.087/GB $0.12/GB
Storage $0.015/GB/mo $0.023/GB/mo $0.018/GB/mo $0.020/GB/mo
Free tier 10 GB storage (no expiry) 5 GB (12 months) 5 GB (12 months) 5 GB (no expiry)
Archive tier Infrequent Access ($0.01/GB) Glacier ($0.004/GB), Deep Archive ($0.00099/GB) Archive ($0.002/GB) Coldline ($0.004/GB), Archive ($0.0012/GB)
API S3-compatible Native S3 Blob API GCS API (+ S3 interop)
CDN integration Built-in (Cloudflare CDN) CloudFront (separate service) Azure CDN (separate) Cloud CDN (separate)
Versioning Beta GA GA GA
Lifecycle rules Yes Yes Yes Yes
Max object 5 TB 5 TB 190 TB (block blob) 5 TB
Portability High (S3 API) High (S3 API is the standard) Medium (Blob API, different from S3) Medium (GCS API, S3 interop available)

Best for:

  • R2: Any workload where downloads are frequent. Zero egress makes it the cheapest option at scale for serving content.
  • S3: The default choice when you need the broadest ecosystem (event notifications, analytics, Glacier archiving).
  • Azure Blob: Azure-native apps, Archive tier for cold storage.
  • GCS: GCP-native apps, BigQuery integration for analytics on stored data.

CDN and Edge#

Feature Cloudflare CDN AWS CloudFront Azure CDN / Front Door GCP Cloud CDN
PoPs 330+ 600+ 200+ 200+
Edge compute Workers (V8 isolates) Lambda@Edge / CloudFront Functions Azure Functions (limited edge)
Pricing Free (included with any Cloudflare plan) $0.085/GB (US), varies by region $0.081/GB (US), varies $0.08/GB (US)
Free tier Unlimited bandwidth 1 TB/mo (12 months) None None
DDoS protection Included (all plans) AWS Shield Standard (free) Included with Front Door Cloud Armor ($5/mo + rules)
WAF Included (free plan: limited rules) $5/mo + $1/rule + $0.60/M requests Included with Front Door Premium Cloud Armor ($5/mo + rules)
Custom domains Unlimited, free SSL Via ACM (free cert) + distribution config Via Front Door config Via load balancer config
Portability Medium Medium Medium Medium

Cloudflare is the clear value leader for CDN. The free plan includes unlimited bandwidth, DDoS protection, basic WAF, and DNS. Every other vendor charges for bandwidth and treats DDoS/WAF as add-on services.

DNS#

Feature Cloudflare DNS AWS Route 53 Azure DNS GCP Cloud DNS
Hosted zone cost Free $0.50/zone/mo $0.50/zone/mo $0.20/zone/mo
Query cost Free $0.40/M queries $0.40/M queries (first 1B) $0.40/M queries
DNSSEC Free, one-click Supported Supported Supported
Propagation <5 seconds typical 60 seconds typical 60 seconds typical Varies
Health checks Free (limited) $0.50-0.75/endpoint/mo Via Traffic Manager ($0.75/M queries) Via load balancer
Geo routing Via load balancing rules Geolocation routing policy Via Traffic Manager Via Cloud DNS routing
Portability High (standard DNS) High (standard DNS) High (standard DNS) High (standard DNS)

DNS is fully portable – it is an open standard. Cloudflare DNS is free with fast propagation, making it the default recommendation unless you need tight integration with Route 53 health checks or Traffic Manager.

Message Queues#

Feature Cloudflare Queues AWS SQS Azure Service Bus GCP Pub/Sub
Model Queue (Workers-native) Queue (pull) Queue + Topics (push/pull) Topics + Subscriptions (push/pull)
Pricing $0.40/M messages $0.40/M requests (Standard) $0.05/M operations (Basic) $40/TiB ingested
Free tier 1M messages/mo 1M requests/mo None 10 GB/mo
Max message size 128 KB 256 KB (up to 2 GB via S3) 256 KB (Standard), 100 MB (Premium) 10 MB
Max retention 4 days 14 days 14 days (Standard) 31 days
Dead letter queue Yes Yes Yes Yes
FIFO ordering Yes Yes (FIFO queues) Yes (sessions) Yes (ordering keys)
Portability Low (Workers API) Medium (HTTP API) Medium (AMQP) Medium (HTTP/gRPC API)

Best for:

  • Cloudflare Queues: Connecting Workers to Workers. Simplest setup if you are already on Cloudflare.
  • SQS: The default queue for AWS workloads. Battle-tested, simple, pairs with Lambda triggers.
  • Service Bus: Enterprise messaging with AMQP, sessions, and complex routing. .NET ecosystem.
  • Pub/Sub: Fan-out messaging (one message, many subscribers). Analytics pipelines, event streaming.

Observability#

Feature Cloudflare AWS Azure GCP
Metrics Analytics Engine CloudWatch Monitor Cloud Monitoring
Logs Workers Logpush / wrangler tail CloudWatch Logs Log Analytics Cloud Logging
Tracing X-Ray Application Insights Cloud Trace
Dashboards Cloudflare dashboard (limited) CloudWatch Dashboards Azure Monitor Workbooks Cloud Monitoring Dashboards
Alerting – (use external) CloudWatch Alarms Azure Alerts Cloud Monitoring Alerting
Cost Analytics Engine: $0.25/M data points CloudWatch: $0.30/metric/mo + $0.50/GB logs Log Analytics: $2.76/GB ingested $0.50/metric/mo + $0.50/GiB logs
Portability Low Low Low Low

Cloudflare’s observability is the weakest of the four. There is no built-in tracing, limited alerting, and no equivalent to CloudWatch Dashboards. For production observability, pair Cloudflare with external tools (Datadog, Grafana Cloud, Axiom). AWS, Azure, and GCP all have comprehensive built-in observability stacks.

Identity and Access Management#

Feature Cloudflare AWS IAM Azure AD / Entra ID GCP IAM
Model API tokens + Zero Trust Users, Roles, Policies Users, Groups, Roles, Service Principals Users, Service Accounts, Roles
Granularity Per-service tokens Per-action policies Per-action role assignments Per-action policies
Cross-account Cross-account roles (STS) Azure Lighthouse Cross-project roles
MFA Yes (dashboard) Yes (per-user) Yes (Conditional Access) Yes (per-user)
Service identity API tokens IAM Roles for services Managed Identities Service Accounts + Workload Identity
Portability Low Low Low Low

IAM is always low portability – every vendor’s permission model is deeply proprietary. Cloudflare’s IAM is simpler (API tokens scoped to services) but less granular than AWS/Azure/GCP.

Pricing Model Comparison#

Dimension Cloudflare AWS Azure GCP
Compute billing Per-request + CPU time Per-request + GB-seconds Per-execution + GB-seconds Per-vCPU-second + memory
Storage billing Per-GB/month Per-GB/month Per-GB/month Per-GB/month
Egress (data out) $0 (Workers, R2, Pages) $0.09/GB $0.087/GB $0.12/GB
Bandwidth (CDN) Free (unlimited) $0.085/GB (US) $0.081/GB (US) $0.08/GB (US)
Commitment discounts Annual plan (minor savings) Reserved Instances, Savings Plans (up to 72% off) Reserved VMs (up to 72% off) CUDs (up to 57% off)
Billing complexity Simple (few line items) Complex (dozens of line items per service) Complex Complex
Cost predictability High (per-operation, no idle cost) Low-Medium (instance-hours, NAT GW, data transfer) Low-Medium Low-Medium

The fundamental pricing difference: Cloudflare charges per operation with zero egress. AWS/Azure/GCP charge per instance-hour, per-GB-transferred, and per-operation, with egress fees on nearly everything. This makes Cloudflare extremely cost-predictable but also means you cannot optimize costs through reserved instances or committed use discounts (because there are no instances to reserve).

Free Tier Summary#

Category Cloudflare AWS Azure GCP
Compute 100K req/day 1M Lambda req/mo, 750 hrs EC2 (12mo) 1M Functions/mo, 750 hrs B1s VM (12mo) 2M Cloud Run req/mo, 1 e2-micro VM
Database D1: 5B reads, 5 GB DynamoDB: 25 GB. RDS: 750 hrs (12mo) Cosmos DB: 1000 RU/s. SQL: 750 hrs (12mo) Firestore: 50K reads/day
Object storage R2: 10 GB, $0 egress S3: 5 GB (12mo) 5 GB (12mo) 5 GB
KV / Cache KV: 100K reads/day ElastiCache: none Redis: none Memorystore: none
CDN bandwidth Unlimited 1 TB/mo (12mo) None None
DNS Free (unlimited) $0.50/zone + $0.40/M queries $0.50/zone $0.20/zone
Expiry Never 12 months for most 12 months for most Mixed (some never, some 90-day)

Cloudflare has the most generous permanent free tier. AWS has the broadest free tier but most of it expires after 12 months (RDS, EC2, S3, CloudFront). GCP’s free tier is mixed – some services are always-free (e2-micro, Firestore), others are trial credits. Azure is similar to AWS with 12-month limits on key services.

Portability Summary#

Category Most Portable Least Portable
Serverless compute Cloud Run (Docker) All others (custom runtimes/APIs)
Relational DB AWS RDS, Azure SQL, Cloud SQL (standard SQL) D1 (SQLite dialect, smaller ecosystem)
Object storage R2, S3 (S3 API is the standard) Azure Blob (different API)
Key-value All are low portability DynamoDB, Cosmos DB, KV (all proprietary)
DNS All are high portability
CDN All are medium portability
Queues SQS, Pub/Sub (HTTP APIs) Cloudflare Queues (Workers-only)
IAM None are portable All are deeply proprietary

The most portable stack: Docker containers (Cloud Run / Fly.io) + PostgreSQL (any managed provider) + S3-compatible storage (R2 or S3) + standard DNS. This combination lets you move between vendors by changing configuration, not code.

The least portable stack: Lambda with DynamoDB triggers + SQS + CloudFront Functions + Cognito. Every component is AWS-specific. Migration requires a full rewrite.

Choosing a Vendor#

For most new projects, evaluate these criteria in order:

  1. Do you need specific managed services? If your project depends on SageMaker, BigQuery, Active Directory integration, or another vendor-specific service, that vendor wins by default.

  2. What is your budget? At $0-50/month, Cloudflare’s free tier and per-operation pricing is hard to beat. At $500+/month, AWS/Azure/GCP commitment discounts become significant.

  3. Where are your users? If globally distributed, Cloudflare’s edge-first model gives the lowest latency without configuration. If concentrated in one region, a regional deployment on any vendor works.

  4. What is your team’s expertise? The vendor your team already knows is often the right choice. Cloud expertise takes months to build. Switching vendors means retraining, not just reconfiguring.

  5. How much operational overhead can you absorb? Cloudflare requires the least ops work (no regions, no VPCs, no security groups). AWS offers the most control but demands the most operational investment.

When none of these criteria produce a clear winner, default to Cloudflare for APIs and static sites (lowest cost, least ops), AWS for complex backends (broadest services), or GCP for data/ML workloads (BigQuery, Vertex AI).