AWS, GCP, and Azure for Vibecoders: The Services You Actually Need

Quick answer

• Your AI will generate configs for all three hyperscalers. You need to understand what they actually do.
• AWS: most services, largest community, AI defaults to it. Start with EC2 + RDS, not EKS.
• GCP: cheapest compute, best serverless containers (Cloud Run), AI/ML lead. Start with Cloud Run + Cloud SQL.
• Azure: best if you’re in the Microsoft ecosystem. Start with Container Apps + Azure SQL.
• Every section includes the common AI-generated mistakes for that cloud. Read yours before deploying.

Why your AI defaults to AWS (and why that’s a problem)

AI coding assistants are trained on public repositories — and public infrastructure-as-code is overwhelmingly AWS. Terraform registry? AWS dominates. GitHub Actions marketplace? AWS. Stack Overflow infrastructure answers? AWS. Your AI generates AWS configs not because AWS is right for your project, but because it’s what the AI has seen the most.

The result: your three-file todo app gets a Terraform plan with a NAT Gateway ($32/month), an Application Load Balancer ($22/month), and an EKS cluster ($73/month). Your monthly bill is $127 before the app serves a single request.

This guide covers what you actually need from each hyperscaler — the 6-8 services per cloud that run 90% of AI-generated apps — and what the AI gets wrong about them.

The universal service map

Every hyperscaler has the same six building blocks, just named differently:

You don’t need all sixteen. For a typical AI-generated app, you need 4-6 of them. The rest of this guide tells you which ones.

AWS: The services your AI will generate configs for

AWS has 200+ services. Your AI will reference maybe 8 of them. Here are the ones that matter, the ones to avoid, and the mistakes the AI makes.

✅ EC2 (Elastic Compute Cloud) — Virtual machines

The most fundamental AWS service. A virtual server in the cloud. You pick an instance type, an OS image, and a size, and AWS gives you a machine.

What it actually costs:

• t3.micro (2 vCPU, 1GB RAM): ~$8.50/month on-demand; free for 12 months only on accounts created before July 2025 — new accounts get credits instead
• t3.small (2 vCPU, 2GB RAM): ~$17/month
• t3.medium (2 vCPU, 4GB RAM): ~$34/month
• Add ~$0.10/GB-month for EBS storage

Common AI mistake: Generating a t3.xlarge (4 vCPU, 16GB) for a static website. Also: not attaching an elastic IP or using a dynamic DNS, so the public IP changes on every stop/start.

✅ RDS (Relational Database Service) — Managed Postgres/MySQL

AWS runs the database, handles backups, patches, and replication. You connect and query.

What it actually costs:

• db.t4g.micro (2 vCPU, 1GB RAM): ~$15/month (Postgres/MySQL)
• db.t4g.small (2 vCPU, 2GB RAM): ~$30/month
• Multi-AZ (high availability): doubles the cost
• Storage: $0.115/GB-month for gp3

Common AI mistake: Generating a Multi-AZ RDS deployment ($30/month x2 = $60/month) for a hobby project. Single-AZ is fine for development. Also: not enabling automated backups, so there’s no recovery when the AI-generated migration drops a table.

✅ S3 (Simple Storage Service) — File storage

The universal file bucket. User uploads, static assets, database backups, log archives. Object storage with an HTTP API.

What it actually costs:

• Storage: $0.023/GB-month (Standard tier)
• Requests: $0.005/1,000 PUT, $0.0004/1,000 GET
• Egress to internet: 100GB free, then $0.09/GB
• Basically free for small projects

Common AI mistake: Making the bucket public ("Effect": "Allow", "Principal": "*") for a static website instead of using CloudFront. Public buckets are the #1 cause of AWS data leaks.

✅ Lambda — Serverless functions

Code that runs on demand, scales to zero, and bills per millisecond. Good for cron jobs, webhooks, API endpoints, and glue code between AWS services.

What it actually costs:

• 1 million invocations/month: free (always-free tier)
• Beyond that: $0.20 per million invocations + $0.0000166667 per GB-second
• A rarely-called function costs $0. A heavily-called one can cost hundreds

Common AI mistake: Hardcoding secrets in the function code instead of using environment variables with Secrets Manager. Also: setting a 3-second timeout for a function that takes 5 seconds, causing silent failures; or setting no timeout and letting a runaway function burn money.

⚠️ ECS Fargate — Serverless containers

Run Docker containers without managing EC2 instances. Easier than Kubernetes, still complex.

What it actually costs:

• 0.25 vCPU, 0.5GB RAM: ~$12/month if running 24/7
• 0.5 vCPU, 1GB RAM: ~$24/month
• Plus data transfer and load balancer costs

Common AI mistake: Deploying to ECS Fargate when Lambda or a single EC2 instance would suffice. Fargate is for when you need containers but don’t want to manage servers — not for when you need to run a single Express app.

❌ EKS (Elastic Kubernetes Service) — Avoid for your first deploy

Managed Kubernetes. $73/month just for the control plane, before any worker nodes or traffic.

Common AI mistake: Generating an EKS cluster for a single-service app. The AI sees Kubernetes YAML in training data and reproduces it. Unless you have a specific Kubernetes requirement (multi-cloud portability, complex scheduling, Helm charts), use ECS Fargate or a single EC2 instance instead.

❌ NAT Gateway — The $32/month trap

A NAT Gateway lets instances in a private subnet reach the internet. At $32/month + $0.045/GB processed, it’s one of the most expensive per-byte services on AWS.

Common AI mistake: Every AWS VPC tutorial includes a NAT Gateway, so the AI includes one. Your single EC2 instance doesn’t need a private subnet — put it in a public subnet with a security group and skip the NAT Gateway entirely. This one change saves $384/year on most AI-generated architectures.

GCP: The best hyperscaler for vibecoders

GCP is the cheapest of the Big Three for compute, has the best serverless container platform (Cloud Run), and leads in AI/ML tooling. If you’re starting fresh and choosing a hyperscaler, GCP is the best default.

✅ Cloud Run — The standout service

Cloud Run is the best serverless container platform across all three clouds. Push a Docker image, get an HTTPS endpoint, pay per request. Scales to zero (no cost when idle), scales up instantly. No Kubernetes knowledge required.

What it actually costs:

• 2 million requests/month: free (always-free tier)
• Beyond that: $0.40 per million requests
• Compute: $0.000018 per vCPU-second, $0.000002 per GB-second
• A small app with moderate traffic: $0-5/month

Common AI mistake: Not setting max-instances or concurrency limits, so a traffic spike scales up to hundreds of instances. Also: setting memory too high (2GB for a 128MB app) because the AI defaults to generous values.

✅ Cloud SQL — Managed Postgres/MySQL

Equivalent to AWS RDS. Managed database with automated backups, patches, and replication.

What it actually costs:

• db-f1-micro (shared vCPU, 0.6GB RAM): ~$8/month
• db-g1-small (shared vCPU, 1.7GB RAM): ~$25/month
• Storage: $0.17/GB-month for SSD

Common AI mistake: Provisioning a high-memory instance for a development database. The db-f1-micro handles most small apps fine. Also: not enabling automated backups (they’re off by default on GCP, unlike AWS).

✅ Cloud Storage — Object storage

Equivalent to AWS S3. Cheaper egress than AWS for most regions. Five storage classes from Standard (frequent access) to Archive (once a year).

✅ Compute Engine — Virtual machines

Slightly cheaper than EC2 for equivalent specs. Unique advantage: custom machine types — pick exactly the vCPU and RAM you want instead of choosing from predefined instance families.

Common AI mistake: Not using custom machine types and over-provisioning. A 1 vCPU, 1GB RAM custom VM is cheaper than the nearest predefined option. Also: GCP’s sustained use discounts apply automatically — no reserved instance commitment needed.

✅ Cloud Build — CI/CD in the cloud

GCP’s built-in CI/CD. Push to a Git repo, Cloud Build runs your tests, builds your container, and deploys to Cloud Run. Equivalent to GitHub Actions or AWS CodeBuild, but natively integrated with GCP services.

What it actually costs:

• 120 build-minutes/day: free
• Beyond that: $0.003/minute

⚠️ GKE (Google Kubernetes Engine) — Best managed K8s, still overkill

GKE is the best managed Kubernetes offering, period. Google invented Kubernetes, and GKE reflects that — autopilot mode, automated upgrades, and the tightest integration with the K8s ecosystem. But: it still costs $73/month for the control plane in standard mode (autopilot is per-pod pricing). For most vibecoders, Cloud Run covers the same use case at a fraction of the cost and complexity.

Azure: Best if you’re already in the Microsoft ecosystem

Azure is the most expensive of the Big Three on average (~8-10% more than AWS for equivalent compute). Its strengths are Microsoft integration and the exclusive OpenAI partnership — if your app uses GPT-4o through an API, Azure is the primary enterprise-grade path.

✅ Azure Container Apps — The Cloud Run equivalent

Serverless containers on Kubernetes, without you managing Kubernetes. Equivalent to Cloud Run (GCP) or ECS Fargate (AWS). Handles HTTPS, auto-scaling, and revision management.

What it actually costs:

• Consumption plan: pay per vCPU-second and GB-second
• A small app: $10-20/month

✅ Azure Functions — Serverless functions

Equivalent to AWS Lambda. Consumption plan (pay per execution) or Premium plan (pre-warmed instances for lower cold starts).

✅ Azure SQL Database — Managed SQL Server

Azure’s flagship managed database, optimized for SQL Server. Also offers PostgreSQL and MySQL via Azure Database for PostgreSQL/MySQL flexible server.

What it actually costs:

• Basic tier (5 DTU, 2GB): ~$5/month
• General Purpose (small): ~$75/month
• The cost jump from Basic to General Purpose is large — plan accordingly

✅ Azure Blob Storage — Object storage

Equivalent to S3. Hot, cool, and archive tiers. Integrated with Azure CDN.

⚠️ Azure OpenAI Service — GPT with enterprise compliance

The exclusive enterprise path to GPT-4o, DALL-E, and other OpenAI models. If your app needs GPT access with Azure’s compliance, security, and data residency guarantees, this is the service.

Common AI mistake: Provisioning GPT-4o at $30/hour for provisioned throughput when the pay-per-token model ($15/M input, $60/M output for GPT-4o) is cheaper for low-volume usage. Provisioned throughput is for high-volume production; token-based pricing is for development and small-scale use.

The AI-generated mistake checklist (all three clouds)

These mistakes recur across every hyperscaler. The AI generates them because they appear in public Terraform modules, tutorials, and Stack Overflow answers — not because they’re right for your project.

Compute over-provisioning

# ❌ AI-generated: 4 vCPU, 16GB for a static site
resource "aws_instance" "web" {
  instance_type = "t3.xlarge"
}

# ✅ What you actually need: 1 vCPU, 1GB for a static site
resource "aws_instance" "web" {
  instance_type = "t3.micro"
}

The AI defaults to generous because enterprise examples use generous. Scale down. You can always scale up.

Missing cost barriers

The AI never generates billing alerts, budget actions, or cost allocation tags. Add these yourself:

• AWS: Budgets → set a $20/month alert
• GCP: Budgets & alerts → set a $20/month threshold with Pub/Sub notification
• Azure: Cost Management → set a $20/month budget with email alert

Public resources

# ❌ AI-generated: world-readable S3 bucket
resource "aws_s3_bucket_acl" "example" {
  acl = "public-read"
}

# ✅ Block all public access by default
resource "aws_s3_bucket_public_access_block" "example" {
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

If you need public access, use CloudFront (AWS) or Cloud CDN (GCP) in front of the bucket — never expose the bucket directly.

Hardcoded secrets

# ❌ AI-generated: secret in code
OPENAI_API_KEY = "sk-abc123..."

# ✅ Environment variable, never in code
OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]

The AI doesn’t know your secrets are secrets. It sees a string and treats it like any other string. Review every AI-generated config for API keys, passwords, and tokens.

Zero monitoring

The AI generates the app and the infrastructure, but never CloudWatch alarms (AWS), Cloud Monitoring alerts (GCP), or Azure Monitor alerts. Add at minimum: CPU utilization > 80% for 5 minutes, error rate > 5%, and health check failures.

The decision: which hyperscaler for which project?

Your project needs...

The widest range of services, GPU instances, or you're already on AWS
└── AWS — start with EC2 t3.micro + RDS t4g.micro. Avoid EKS and NAT Gateway.

The cheapest compute, best serverless containers, or AI/ML workloads
└── GCP — start with Cloud Run + Cloud SQL. Use the always-free tier.

Microsoft ecosystem, .NET/Windows, or enterprise GPT-4o access
└── Azure — start with Container Apps + Azure SQL Basic.

None of the above — you just want your app to run without managing infrastructure
└── Don't use a hyperscaler. See: How to Choose a Cloud Provider (@/blog/devops/choose-cloud-provider-ai-app.md)
   and Budget Cloud and PaaS Compared (@/blog/devops/budget-cloud-paas-compared.md)

Where this bites vibecoders

The AI generates infrastructure like it’s deploying Netflix. It doesn’t know your project has 3 users and a $20/month budget. The skill is recognizing overkill: a NAT Gateway for a single EC2 instance, an EKS cluster for a one-service app, a Multi-AZ RDS for a development database. Strip the AI’s config down to what you actually need, add billing alerts and monitoring, and only add complexity when traffic demands it — not when the AI suggests it.

Checklist

• Identify which 4-6 services your app actually needs (use the universal service map)
• Strip down the AI’s generated config: remove NAT Gateways, downgrade instance sizes, use single-AZ
• Set billing alerts on day one ($20-50/month threshold depending on budget)
• Block all public access on storage buckets by default — use CDN if you need public content
• Move all secrets to the cloud’s secrets manager, never in code
• Add basic monitoring: CPU, error rate, and health check alerts
• Use the always-free tier resources first (Lambda/DynamoDB on AWS, e2-micro + Cloud Run on GCP, Functions/Cosmos DB on Azure)
• Resist Kubernetes until you have a specific reason you need it

FAQ

Which hyperscaler is cheapest for a small app?

GCP, because of Cloud Run’s scale-to-zero and the always-free tier (e2-micro VM with 30GB disk, 2M Cloud Run requests/month). AWS is competitive if you build on the new always-free services (Lambda, DynamoDB, CloudFront) rather than credit-funded EC2 and RDS. Azure is generally the most expensive of the three for small workloads, but Azure Hybrid Benefit can reduce costs if you already have Microsoft licenses.

Why does my AI generate such expensive AWS architectures?

AI assistants are trained on enterprise infrastructure code — multi-AZ RDS, NAT Gateways, ALBs, EKS clusters. They generate what they’ve seen, and they’ve seen overbuilt production architectures. The generated Terraform for a todo app routinely includes: NAT Gateway ($32/month), Application Load Balancer ($22/month), and EKS ($73/month) — $127/month before the app runs. Always review AI-generated infra and strip it down to what you actually need.

Should I use Kubernetes on the hyperscalers?

Almost certainly not for your first deploy. GKE (GCP) is the best-managed Kubernetes, but it still costs $73/month minimum for the control plane. ECS Fargate (AWS) or Cloud Run (GCP) give you container orchestration without the Kubernetes complexity and cost. Only reach for Kubernetes when you need multi-cloud portability, complex scheduling, or a specific Kubernetes feature your app depends on.

What’s the equivalent of [AWS service] on GCP/Azure?

See the universal service map at the top of this guide. Rule of thumb: EC2 = Compute Engine = Virtual Machines. Lambda = Cloud Functions = Azure Functions. S3 = Cloud Storage = Blob Storage. RDS = Cloud SQL = Azure Database. CloudFront = Cloud CDN = Azure CDN. The naming is different; the concepts are identical.

Related topics

• How to Choose a Cloud Provider for Your AI-Generated App
• How to Launch Free Infrastructure on AWS, GCP, or Azure
• How to Deploy Your First App on AWS for Free
• How to Deploy Your First App on Google Cloud for Free
• How to Deploy Your First App on Azure for Free
• Budget Cloud and PaaS Compared: Hetzner, DigitalOcean, Railway, Fly.io, Render
• Deploying AI-Generated Apps to Production: A Vibecoder’s Checklist
• What Is Infrastructure as Code (IaC)?
• What Is FinOps (Cloud Cost Management)?
• Why Did My AI-Generated Terraform Config Almost Delete Production?
• Self-Hosted AI Coding Models in 2026: The Practical Review

Sources

• DigitalOcean — Comparing AWS, Azure, and GCP for Startups in 2026
• Rackspace Spot — Cloud Computing Cost: AWS vs Azure vs GCP Pricing 2026
• Tech Insider — AWS vs Azure vs Google Cloud 2026
• Usage.ai — Top Cloud Service Providers 2026
• AWS Documentation
• GCP Documentation
• Azure Documentation