Comparing AWS container services solely on compute pricing misses the bigger picture. Total Cost of Ownership includes operational labor, training, tooling, and the hidden costs of managing control planes and node infrastructure. A service that costs 20% more per vCPU but requires half the engineering time can deliver better TCO for many teams.
Key Takeaways
- ECS has the lowest per-vCPU cost but requires AWS-specific expertise and limits portability
- EKS provides Kubernetes portability but adds control plane fees ($73/month per cluster) and operational overhead
- Fargate eliminates node management but costs 30-50% more per vCPU and has one-minute minimum billing
- For teams under 5 engineers, Fargate’s labor savings often outweigh higher compute costs
- TCO calculations must include training time, on-call burden, and opportunity cost of infrastructure work
Understanding the Three Options
Amazon ECS (Elastic Container Service)
ECS is AWS’s proprietary container orchestration service. You define task definitions (similar to pod specs), and ECS schedules containers on EC2 instances or Fargate. It integrates deeply with AWS services but doesn’t use Kubernetes.
Key characteristics:
- No control plane fees (ECS itself is free)
- Pay only for EC2 instances or Fargate capacity
- AWS-native tooling (CloudFormation, CDK, CLI)
- No Kubernetes portability
Amazon EKS (Elastic Kubernetes Service)
EKS runs managed Kubernetes control planes. You use standard Kubernetes APIs (kubectl, Helm) to deploy workloads on EC2 nodes or Fargate pods.
Key characteristics:
- $0.10/hour ($73/month) per cluster control plane fee
- Full Kubernetes compatibility and ecosystem
- Can run on EC2 (self-managed), managed node groups, or Fargate
- Multi-cloud and on-prem portability via Kubernetes
AWS Fargate (Serverless Compute for Containers)
Fargate is a serverless compute engine that works with both ECS and EKS. You define task/pod resource requirements and AWS provisions right-sized VMs without exposing EC2 instances.
Key characteristics:
- No node management or Auto Scaling Groups
- Pay per vCPU and GB-RAM with one-minute minimum billing
- Higher per-vCPU cost than EC2
- Works with both ECS and EKS
Direct Compute Cost Comparison
Let’s start with the raw infrastructure costs for running a simple workload: 10 containers, each requiring 1 vCPU and 2GB RAM, running 24/7.
Scenario: 10 vCPU, 20GB RAM Total
ECS on EC2 (2× m5.large: 2 vCPU, 8GB each):
- EC2 cost: $0.096/hour × 2 = $0.192/hour
- Monthly: $0.192 × 730 hours = $140/month
- ECS control plane: $0 (no charge)
- Total: $140/month
EKS on EC2 (2× m5.large):
- EC2 cost: $140/month (same as ECS)
- EKS control plane: $73/month
- Total: $213/month
ECS on Fargate:
- Fargate pricing: $0.04048/vCPU-hour + $0.004445/GB-hour
- Per task: (1 vCPU × $0.04048) + (2GB × $0.004445) = $0.0494/hour
- 10 tasks: $0.494/hour × 730 hours = $361/month
- Total: $361/month
EKS on Fargate:
- Fargate cost: $361/month (same as ECS)
- EKS control plane: $73/month
- Total: $434/month
Summary for this scenario:
- ECS on EC2: $140/month (baseline)
- EKS on EC2: $213/month (+52% vs ECS)
- ECS on Fargate: $361/month (+158% vs ECS on EC2)
- EKS on Fargate: $434/month (+210% vs ECS on EC2)
This is why “Fargate is expensive” is a common complaint—but it ignores operational costs.
The Hidden Costs: Operational Labor
Infrastructure costs are visible in AWS billing. Labor costs are hidden in salaries, on-call rotations, and opportunity cost (engineers managing infrastructure instead of building features).
Task Breakdown by Service
ECS on EC2 operational tasks:
- Provision and patch EC2 instances (AMI updates, security patches)
- Configure Auto Scaling Groups and capacity providers
- Monitor EC2 health and replace failed instances
- Optimize instance types and right-size capacity
- Manage ECS agent updates
- Handle Spot interruptions if using Spot instances
- Estimated hours/week: 4-8 hours for small clusters, 10-20 for large fleets
EKS on EC2 operational tasks:
- All ECS tasks above, plus:
- Manage Kubernetes control plane upgrades (quarterly)
- Configure and maintain autoscalers (Cluster Autoscaler or Karpenter)
- Troubleshoot Kubernetes networking (CNI, kube-proxy, CoreDNS)
- Manage add-ons (AWS Load Balancer Controller, EBS CSI driver, metrics-server)
- Handle RBAC, service accounts, and IAM roles for service accounts (IRSA)
- Monitor and tune pod resource requests/limits
- Estimated hours/week: 8-15 hours for small clusters, 20-40 for large fleets
Fargate (ECS or EKS) operational tasks:
- Define task/pod specs with CPU and memory
- Monitor task execution and logs
- Tune Fargate profiles (EKS only)
- No node management, patching, or autoscaling
- Estimated hours/week: 1-3 hours for small workloads, 5-10 for large
Labor Cost Calculation
Assume a platform engineer costs $150,000/year fully loaded (salary + benefits + overhead):
- Hourly rate: $150,000 / 2080 hours = $72/hour
- Weekly maintenance cost by service:
Small cluster scenario (10-20 nodes or equivalent Fargate capacity):
- ECS on EC2: 6 hours/week × $72 = $432/week = $1,870/month
- EKS on EC2: 12 hours/week × $72 = $864/week = $3,740/month
- Fargate (ECS or EKS): 2 hours/week × $72 = $144/week = $624/month
Total Cost of Ownership: Real Scenarios
Scenario 1: Small Startup (5-person team, 20 containers)
Requirements: 20 vCPU, 40GB RAM total. Team has limited Kubernetes experience. Speed to market is critical.
Monthly costs:
| Service | Compute | Control Plane | Labor (partial FTE) | Total TCO |
|---|---|---|---|---|
| ECS on EC2 | $280 | $0 | $1,870 | $2,150 |
| EKS on EC2 | $280 | $73 | $3,740 | $4,093 |
| ECS on Fargate | $722 | $0 | $624 | $1,346 |
| EKS on Fargate | $722 | $73 | $624 | $1,419 |
Winner: ECS on Fargate ($1,346/month). Despite 2.5× higher compute costs, labor savings make it the cheapest option. The team can focus on product instead of infrastructure.
Why not EKS? The team doesn’t need Kubernetes portability yet, and learning Kubernetes would slow feature development by months.
Scenario 2: Mid-Size SaaS (15-person engineering team, multi-cloud strategy)
Requirements: 200 vCPU, 400GB RAM. Running workloads on AWS and GCP. Need portability. Platform team of 3 engineers.
Monthly costs:
| Service | Compute | Control Plane | Labor (0.5 FTE dedicated) | Total TCO |
|---|---|---|---|---|
| ECS on EC2 | $2,800 | $0 | $3,740 | $6,540 |
| EKS on EC2 | $2,800 | $219 (3 clusters) | $7,480 | $10,499 |
| EKS on Fargate | $7,220 | $219 | $1,248 | $8,687 |
Winner: ECS on EC2 ($6,540/month) if staying AWS-only. But if multi-cloud portability is required, EKS on EC2 ($10,499/month) is necessary despite higher cost.
Trade-off: The company values Kubernetes skills (portable across clouds) over short-term cost savings. EKS justifies its premium through reduced vendor lock-in and ability to hire from broader talent pool.
Scenario 3: Enterprise (100-person engineering org, batch + APIs)
Requirements: 2,000 vCPU steady-state, 5,000 vCPU peak (batch jobs). Dedicated 8-person platform team. Optimizing for cost at scale.
Monthly costs (steady-state only):
| Service | Compute (with Spot) | Control Plane | Labor (1 FTE) | Total TCO |
|---|---|---|---|---|
| ECS on EC2 | $12,000 | $0 | $12,500 | $24,500 |
| EKS on EC2 | $12,000 | $365 (5 clusters) | $18,700 | $31,065 |
| EKS on Fargate | $72,000 | $365 | $6,240 | $78,605 |
Winner: ECS on EC2 ($24,500/month). At this scale, compute costs dominate and Fargate’s premium becomes prohibitive. The platform team can absorb operational overhead efficiently.
Why not Fargate? Fargate would cost 3.2× more monthly ($78K vs $24K). The labor savings ($12K/month) don’t justify the compute premium ($60K/month).
Why might they choose EKS anyway? If the company values Kubernetes ecosystem (Helm charts, operators, multi-cloud optionality) and has budget, the $6,500/month premium for EKS on EC2 may be justified strategically.
TCO Factors Beyond Compute and Labor
Training and Onboarding
- ECS: AWS-specific learning curve. Documentation is good but ecosystem is smaller. Harder to hire experienced ECS engineers.
- EKS: Large training investment (CKA/CKAD courses, Kubernetes learning). Easier to hire (huge Kubernetes talent pool).
- Fargate: Minimal learning curve. Developers define resource needs; infrastructure is abstracted.
Typical training costs:
- ECS: $2,000-5,000 per engineer (AWS training, trial-and-error)
- EKS: $5,000-15,000 per engineer (formal Kubernetes training, certifications, ramp-up time)
- Fargate: $500-1,000 per engineer (basic containerization concepts)
Tooling and Ecosystem
- ECS: Integrated with AWS tooling (CloudWatch, X-Ray, Systems Manager). Limited third-party integrations.
- EKS: Massive ecosystem (Helm, operators, service meshes, Prometheus/Grafana, Argo CD). Requires integration effort.
- Fargate: Works with both ECS and EKS ecosystems but limits some advanced features (DaemonSets on EKS Fargate require workarounds).
Cost example: A company using EKS might spend $10,000-50,000/year on tools like Kubecost, Datadog Kubernetes monitoring, or managed service mesh—costs that don’t exist in ECS.
Opportunity Cost
Every hour spent managing infrastructure is an hour not spent building product features. For a startup racing to market, this can be existential.
Example calculation: If managing EKS takes an extra 10 hours/week vs Fargate, that’s 520 hours/year. At $72/hour, that’s $37,440 in opportunity cost—or roughly one engineer-quarter that could have shipped features.
Fargate Nuances That Impact TCO
One-Minute Minimum Billing
Fargate bills with a one-minute minimum, then per-second after. For tasks that run under one minute (like quick CI jobs), you pay for the full minute even if the task finishes in 10 seconds.
Impact: Fargate is poor for very short-lived tasks. A CI pipeline running 1,000 ten-second jobs per day pays for 1,000 minutes (16.7 hours) even though actual compute is 2.8 hours.
Fargate Spot (ECS Only)
ECS supports Fargate Spot (up to 70% discount) for interruptible workloads. EKS on Fargate does not support Spot—you must use EC2 Spot instances.
TCO impact: For batch workloads on ECS, Fargate Spot can bridge the cost gap with EC2, making Fargate viable even at scale.
Fargate Per-Task Overhead
Each Fargate task gets a dedicated VM with its own overhead. For workloads with many tiny containers (microservices with <0.5 vCPU each), bin-packing on EC2 is more efficient than individual Fargate tasks.
Decision Framework
Choose ECS on EC2 if:
- You’re committed to AWS long-term (no multi-cloud needs)
- Cost optimization is the top priority
- You have platform engineering capacity
- You run large-scale, steady-state workloads (>100 vCPU)
Choose EKS on EC2 if:
- You need Kubernetes portability (multi-cloud, hybrid, on-prem)
- You want access to the Kubernetes ecosystem (Helm, operators, service meshes)
- You have or can build Kubernetes expertise
- You run diverse workloads that benefit from Kubernetes features
Choose ECS on Fargate if:
- You have a small team (<10 engineers) without infrastructure specialists
- You’re AWS-committed and don’t need Kubernetes
- Speed to market matters more than cost optimization
- You run long-lived tasks (not sub-minute jobs)
Choose EKS on Fargate if:
- You need Kubernetes but have limited ops capacity
- You’re willing to pay a premium to avoid node management
- Your workloads are variable and you want elastic scaling without autoscaler tuning
Common Mistakes
Choosing EKS because “everyone uses Kubernetes” without evaluating whether you actually need its features. Many teams would be better served by ECS with less complexity.
Avoiding Fargate because “it’s too expensive” based only on compute pricing. For small teams, Fargate’s TCO is often lowest when labor is included.
Starting with EKS on Fargate for cost-sensitive batch workloads. Fargate doesn’t support Spot on EKS—use EC2 with Spot instead.
Ignoring team size in TCO calculations. A 3-person startup has very different TCO than a 100-person platform team.
TCO Calculator Inputs
To calculate your own TCO, gather these inputs:
- Workload requirements: Total vCPU, RAM, task/pod count, runtime (24/7 vs burst)
- Team size and composition: Engineers available for platform work, Kubernetes experience level
- Fully-loaded engineer cost: Salary + benefits + overhead (typically 1.3-1.5× salary)
- Operational time estimates: Hours/week for infrastructure management per service
- Strategic factors: Multi-cloud plans, portability needs, ecosystem access
- Growth projections: Expected scale in 6-12 months (TCO shifts with scale)
Formula:
Monthly TCO = (Compute Cost) + (Control Plane Cost) + (Weekly Ops Hours × 4.33 × Hourly Engineer Rate) + (Training Cost / Amortization Period) + (Tooling Subscriptions)Conclusion
Total Cost of Ownership for AWS container services depends more on team size and operational maturity than on per-vCPU pricing. Small teams with limited infrastructure expertise get the lowest TCO from Fargate despite its compute premium—the labor savings outweigh infrastructure costs. Mid-size teams benefit from ECS on EC2 when staying AWS-native, or EKS on EC2 when Kubernetes portability matters strategically. Large enterprises running thousands of vCPUs optimize TCO with EC2-based solutions where dedicated platform teams amortize operational overhead across large fleets. Calculate your TCO honestly by including engineer time, training costs, and opportunity cost of infrastructure work. The service with the lowest compute bill often has the highest total cost when you account for the full picture.