AWS MWAA (Managed Airflow) vs Self-Hosted: Real Cost Numbers

If you're running Apache Airflow at scale, you've hit the same wall: the choice between paying AWS for convenience or managing infrastructure yourself and keeping the bill low. This isn't a theoretical debate. Teams we work with at D23 routinely handle data pipelines that generate tens of thousands in monthly infrastructure costs, and the difference between MWAA and self-hosted can swing 10x in either direction depending on your workload.

This article walks through the actual numbers—not marketing claims. We'll break down Amazon Managed Workflows for Apache Airflow (MWAA) pricing, compare it against self-hosted deployments on EKS (Elastic Kubernetes Service), and show you the real trade-offs: when managed makes sense, when self-hosted wins on cost, and what hidden expenses both approaches carry.

Understanding MWAA Pricing Structure

AWS MWAA charges you for three things: scheduler capacity, worker capacity, and data storage. Unlike many AWS services, there's no minimum commitment or upfront fee—you pay for what you use, which sounds good in theory but hides complexity in practice.

Scheduler Costs: MWAA charges per "scheduler unit" per hour. A scheduler is the brain of Airflow—it parses DAGs (directed acyclic graphs), decides which tasks to run, and tracks dependencies. AWS offers small, medium, and large schedulers:

• Small: $0.25/hour (~$180/month if always-on)
• Medium: $0.50/hour (~$360/month if always-on)
• Large: $1.00/hour (~$730/month if always-on)

For a typical mid-market data team running 50–200 DAGs, a medium scheduler handles baseline load. But here's where it gets expensive: during peak scheduling windows (when Airflow parses and queues tasks), you may need to scale up, and you pay for the upgrade even if it's only for 30 minutes.

Worker Costs: Workers execute the actual tasks in your DAGs. MWAA charges per "worker unit" per hour, with three tiers:

• Small: $0.24/hour (~$175/month if always-on)
• Medium: $0.48/hour (~$350/month if always-on)
• Large: $0.97/hour (~$710/month if always-on)

Unlike traditional EC2 instances where you provision fixed capacity, MWAA auto-scales workers based on task queue depth. This sounds efficient, but the catch is you're charged for every second a worker exists—even if it's idle for 55 seconds of every minute. One team we consulted had 20 workers sitting idle 80% of the time because their DAGs were bursty, costing them $4,200/month in unused capacity.

Storage Costs: MWAA uses S3 for DAG storage and logs. AWS charges standard S3 rates (~$0.023 per GB/month), plus request costs. For a typical environment with 100–500 DAGs and moderate logging, expect $20–100/month. This is negligible compared to compute.

Typical MWAA Bill Breakdown (Medium Environment):

• Scheduler (medium, always-on): $360/month
• Workers (3 medium, average 60% utilization): ~$630/month
• Storage & requests: ~$50/month
• Total: ~$1,040/month minimum

If you scale to large schedulers during peak or add more workers for parallel DAGs, you're easily at $1,500–2,500/month. At one scale-up we worked with, their MWAA bill hit $6,800/month because they had 8 large workers running to handle a daily batch window that lasted 4 hours.

Self-Hosted Airflow on EKS: The Real Cost Model

Self-hosted Airflow on EKS (or EC2, or any IaaS) flips the equation: you pay for fixed infrastructure, then run Airflow on top. The appeal is obvious—you control exactly what you pay for. The hidden cost is operational overhead.

EKS Cluster Costs:

An EKS cluster requires:

• EKS control plane: $0.10/hour (~$73/month, fixed)
• Worker nodes (EC2 instances): varies by instance type and count

For a typical mid-market setup, you'd run 3–5 t3.large instances (2 vCPU, 8 GB RAM) as worker nodes:

• t3.large: $0.0832/hour per instance
• 4 instances × $0.0832/hour = ~$245/month
• Total cluster: ~$318/month

This is your baseline, whether you run 1 DAG or 500. The cost doesn't scale with workload—it scales with how many workers you need to handle peak load.

Airflow Pods on EKS:

Within EKS, you deploy Airflow components as pods:

• Scheduler pod: ~1 vCPU, 2 GB RAM (runs continuously)
• Webserver pod: ~0.5 vCPU, 1 GB RAM (runs continuously)
• Worker pods: spawn dynamically based on task queue (KubernetesExecutor or CeleryExecutor)

The scheduler and webserver are negligible cost—they fit in your existing node capacity. Workers are where it scales. If you use the KubernetesExecutor (recommended for EKS), each task spawns a new pod. For a DAG with 50 tasks, you get 50 pods. If tasks run in parallel, you need enough node capacity to fit them.

Real-World EKS Scenario:

Let's say you run 100 DAGs, with:

• 20 heavy DAGs (20 tasks each, 10 parallel): peak 200 pods
• 80 light DAGs (5 tasks each, 2 parallel): peak 160 pods
• Total peak: ~360 pods, each needing ~100 mCPU and 256 MB RAM

To fit 360 pods, you need roughly:

• 360 pods × 100 mCPU = 36 vCPU
• 360 pods × 256 MB = 92 GB RAM

Using t3.large instances (2 vCPU, 8 GB RAM each):

• Required instances: 36 vCPU ÷ 2 = 18 instances for CPU
• Required instances: 92 GB ÷ 8 = 11.5 instances for RAM
• Need 18 instances to meet CPU demand
• Cost: 18 × t3.large × $0.0832/hour = ~$1,074/month

Add EKS control plane ($73/month), and you're at ~$1,147/month for infrastructure.

But wait—you likely don't run peak load 24/7. If peak only happens 4 hours/day:

• Off-peak (20 hours): 4 instances = ~$30/month
• Peak (4 hours): 18 instances = ~$36/month
• Blended: ~$66/month for compute
• Plus EKS: ~$73/month
• Total: ~$139/month for on-demand compute

If you use reserved instances (1-year commitment), you cut the t3.large cost by ~40% to $0.050/hour, bringing the blended cost down to ~$80/month for compute.

The Operational Overhead: The Hidden Cost of Self-Hosted

Here's what the spreadsheet doesn't show: self-hosted Airflow requires DevOps time.

Cluster Management:

• Patching EKS control plane (automatic, but testing required)
• Managing worker node AMIs and updates
• Scaling policies and monitoring
• Debugging pod scheduling issues

Airflow Operations:

• DAG parsing and scheduler tuning (Airflow can choke if you have 500+ DAGs)
• Database maintenance (Airflow uses PostgreSQL; you need backups, monitoring, and failover)
• Log aggregation and cleanup (Airflow logs to S3 or local storage; they grow fast)
• Worker pool management and auto-scaling configuration

Incident Response:

• Scheduler crashes (happens with bad DAGs or resource contention)
• Worker pod evictions (OOMKilled pods cause task failures)
• Database connection pool exhaustion
• Airflow UI slowness under load

A single engineer can manage self-hosted Airflow for a team of 20 data engineers, but they'll spend 10–15 hours/week on operational toil. At $150/hour loaded cost, that's $1,500–2,250/month in OpEx.

MWAA eliminates most of this. AWS handles cluster management, patching, scaling, and failover. Your team focuses on DAG development, not infrastructure. The trade-off: less control and higher compute costs.

Side-by-Side Cost Comparison: Real Workload Examples

Let's ground this in concrete scenarios.

Scenario 1: Light Workload (Startup Phase)

Workload: 10 DAGs, 5–10 tasks each, run once daily, 30-minute total runtime, no parallelism

MWAA:

• Scheduler (small): $180/month
• Workers (1 small, 20% utilization): $35/month
• Storage: $10/month
• Total: $225/month

Self-Hosted EKS:

• EKS control plane: $73/month
• Worker nodes (2 t3.medium, $0.0416/hour): $61/month
• Operational overhead (5 hours/week): ~$300/month
• Total: $434/month

Winner: MWAA by 2x. For small workloads, managed is cheaper and simpler.

Scenario 2: Medium Workload (Growth Phase)

Workload: 50 DAGs, 15 tasks average, 10 run daily, 5 run hourly, peak 100 concurrent tasks, 2-hour peak window daily

MWAA:

• Scheduler (medium, always-on): $360/month
• Workers (4 medium, 50% avg utilization): $876/month
• Storage: $30/month
• Total: $1,266/month

Self-Hosted EKS:

• EKS control plane: $73/month
• Worker nodes (8 t3.large, off-peak 2, peak 8 for 2 hours/day): ~$220/month blended
• Operational overhead (10 hours/week): ~$600/month
• Database (managed RDS for Airflow metadata): $50/month
• Total: $943/month

Winner: Self-hosted by 25%. At this scale, the operational overhead is justified by cost savings.

Scenario 3: Heavy Workload (Enterprise Scale)

Workload: 200 DAGs, 30 tasks average, 50 run daily, 50 run hourly, peak 500 concurrent tasks, 4-hour peak window daily

MWAA:

• Scheduler (large, always-on): $730/month
• Workers (10 large, 40% avg utilization): $2,850/month
• Storage: $75/month
• Total: $3,655/month

Self-Hosted EKS:

• EKS control plane: $73/month
• Worker nodes (40 t3.large, off-peak 5, peak 40 for 4 hours/day): ~$800/month blended
• Operational overhead (20 hours/week): ~$1,200/month
• Database (RDS multi-AZ): $200/month
• Monitoring & logging (CloudWatch, Datadog): $150/month
• Total: $2,423/month

Winner: Self-hosted by 33%. At enterprise scale, the math strongly favors self-hosted if you have the ops capacity.

Hidden Costs and Trade-Offs

These comparisons assume everything goes smoothly. Reality is messier.

MWAA Hidden Costs:

• Scheduler scaling during DAG parsing spikes (unexpected bills)
• Worker over-provisioning for safety (teams often run larger workers than needed)
• Egress costs if workers pull data from on-prem or private VPCs (can be $0.02–0.10 per GB)
• No multi-region failover without running multiple MWAA environments (doubles the cost)

Self-Hosted Hidden Costs:

• Emergency scaling during incidents (spot instances can spike to on-demand pricing)
• Database failover and backup costs (RDS can be $200–500/month for production-grade setup)
• Log storage in S3 (Airflow logs grow fast; one team accumulated 2 TB in 6 months, costing $46/month)
• Incident response and debugging time (not in the spreadsheet, but real)

Comparing MWAA Against Other Managed Alternatives

MWAA isn't the only managed Airflow option. According to comparisons of managed Airflow services, AWS MWAA competes with:

• Google Cloud Composer: ~$0.44/hour base + compute (similar pricing to MWAA, slightly higher)
• Astronomer (SaaS): $0.25/hour base + compute (cheaper base, but less flexible)
• Self-managed with Astronomer support: $500–2,000/month support + infrastructure (good middle ground)

For teams already in AWS, MWAA is the path of least resistance. For teams willing to manage infrastructure, self-hosted on EKS or EC2 is cheaper.

When MWAA Makes Sense (Despite Higher Costs)

Cost isn't the only variable. MWAA wins when:

1. You're in early-stage startup mode: Operational overhead is a luxury you can't afford. Pay the premium for managed and focus on product.
2. Your workload is unpredictable: If you have bursty DAGs that spike from 0 to 500 tasks in seconds, MWAA's auto-scaling is valuable. Self-hosted requires over-provisioning.
3. You need multi-region failover: Running MWAA in multiple regions is simpler than managing self-hosted clusters across regions.
4. Your team has no Kubernetes expertise: EKS requires someone who knows how to troubleshoot pod scheduling, resource limits, and networking. MWAA abstracts this away.
5. Compliance requires managed services: Some enterprises mandate AWS-managed services for audit and compliance reasons.

When Self-Hosted Wins (Beyond Just Cost)

Self-hosted makes sense when:

1. You have stable, predictable workloads: If your peak load is consistent and you can provision for it, self-hosted is cheaper and you control every dollar.
2. You have Kubernetes expertise in-house: If you already run EKS for other workloads, adding Airflow is incremental.
3. You need custom Airflow operators or plugins: MWAA restricts what you can install; self-hosted has no limits.
4. You want to avoid vendor lock-in: Self-hosted Airflow runs anywhere (AWS, GCP, on-prem, hybrid). MWAA is AWS-only.
5. You're optimizing for latency: Self-hosted can run in your VPC with low-latency access to databases and data warehouses. MWAA adds a small network hop.

Real-World Case Study: From $10K MWAA to $400 Self-Hosted

One of the best illustrations comes from a real case study where an engineer reduced their $10,000 monthly AWS Glue bill to $400 using Airflow. While this focused on Glue vs Airflow, the underlying lesson applies: managed services hide true costs, and self-hosted with discipline can be 96% cheaper.

The engineer's approach:

1. Moved from AWS Glue (pay-per-DPU-second) to Airflow (pay-per-compute)
2. Deployed Airflow on EC2 with spot instances
3. Tuned DAGs to minimize parallelism and compute
4. Used spot instances for non-critical tasks

The result: $10K → $400/month. That's extreme, but it illustrates the power of self-hosted when you optimize aggressively.

Cost Optimization Strategies for Both Approaches

Regardless of which path you choose, there are universal cost-cutting tactics.

For MWAA:

• Right-size schedulers and workers to actual load (audit every 30 days)
• Use small workers for I/O-bound tasks (most tasks don't need medium/large)
• Batch DAG parsing to avoid scheduler scaling spikes
• Use MWAA's task pooling to limit concurrent workers
• Implement DAG timeouts and SLAs to catch runaway tasks

For Self-Hosted:

• Use spot instances for non-critical tasks (can save 70% on compute)
• Implement pod resource requests and limits to prevent over-provisioning
• Use Horizontal Pod Autoscaler (HPA) to scale workers based on queue depth
• Aggregate logs and clean them up regularly (Airflow logs explode in size)
• Use reserved instances for baseline load, spot for peaks

Datadog's guide on Airflow cost optimization provides deeper tactics for both approaches, including query optimization and resource monitoring.

Using Cost Calculators to Model Your Workload

Before committing to either approach, model your specific workload. Astronomer provides an interactive Airflow cost calculator that lets you plug in task counts, parallelism, and runtime to estimate MWAA vs self-hosted costs.

Steps to use it:

1. Count your DAGs and average task count per DAG
2. Estimate peak parallel tasks (this is critical—it determines worker count)
3. Estimate runtime per DAG
4. Input into the calculator
5. Compare MWAA vs self-hosted estimates

For most teams, the calculator will show self-hosted is cheaper if peak load is predictable and your team has Kubernetes expertise.

Integrating Airflow with Modern Data Stacks

Whichever Airflow deployment you choose, it's likely part of a larger data infrastructure. At D23, we work with teams who use Airflow to orchestrate data pipelines that feed into analytics platforms. The choice between MWAA and self-hosted shouldn't be made in isolation—it should align with your broader data stack.

For example, if you're building self-serve BI dashboards using Apache Superset or embedding analytics in your product, Airflow is the orchestration layer that keeps data fresh. Whether you run MWAA or self-hosted, the downstream analytics infrastructure remains the same. The key is choosing the Airflow deployment that lets your team focus on data quality and analytics, not infrastructure toil.

Comparison with Competing Orchestration Platforms

While this article focuses on Airflow, it's worth noting that MWAA and self-hosted Airflow aren't your only options. Comparisons of managed Airflow services include alternatives like:

• Cloud Composer (GCP): Google's managed Airflow. Pricing is similar to MWAA, but if you're already in GCP, integration is seamless.
• Astronomer: A SaaS platform built on Airflow. Adds features like environment promotion and team management, with pricing starting at $0.25/hour base + compute.
• Prefect and Dagster: Modern orchestration platforms designed from scratch (not forks of Airflow). Pricing varies, but both have managed SaaS options.
• Temporal and Kestra: Newer entrants focused on workflow reliability and scalability.

For most teams already using Airflow, MWAA and self-hosted are the primary decision. For greenfield projects, it's worth evaluating alternatives.

Making the Decision: A Framework

Here's a simple framework to decide between MWAA and self-hosted:

Choose MWAA if:

• Monthly compute costs are <$500 (managed overhead is worth it)
• Your team has no Kubernetes expertise
• You need to scale unpredictably
• You're in early-stage startup mode and value simplicity over cost

Choose Self-Hosted if:

• Monthly compute costs would be >$1,000 (self-hosted breaks even)
• Your team already runs Kubernetes
• Your workload is stable and predictable
• You need custom operators or plugins
• You want to avoid vendor lock-in

Choose a middle ground (Astronomer or managed Airflow support) if:

• You want managed infrastructure but need customization
• Your team is growing and needs operational support
• You're willing to pay a premium for peace of mind

Conclusion: The Real Numbers Tell the Story

AWS MWAA costs $1,000–3,000/month for typical mid-market workloads. Self-hosted Airflow on EKS costs $200–1,500/month for the same workload, plus $300–1,200/month in operational overhead if you count engineer time.

If you value simplicity and have small workloads, MWAA wins. If you have stable, predictable workloads and Kubernetes expertise, self-hosted wins—often by 2–3x.

The key is modeling your specific workload, not relying on averages. Use the MWAA pricing page to estimate your scheduler and worker costs, then compare against self-hosted using the Astronomer cost calculator.

For teams building modern data stacks, Airflow is just one piece of the puzzle. Whether you run MWAA or self-hosted, the goal is the same: reliable, scalable data pipelines that feed analytics, dashboards, and AI-powered insights to your organization. The orchestration layer shouldn't distract from that mission—choose the approach that lets your team focus on data quality and impact, not infrastructure toil.

For more guidance on building scalable data infrastructure, check out D23's approach to managed analytics and how modern data teams are rethinking their BI and analytics stacks.