Contrarian View: Serverless 2026 Is a Scam – AWS Lambda Costs 3x More Than EC2 for Steady Workloads

#!/usr/bin/env python3
"""
AWS Lambda vs EC2 Cost Calculator (us-east-1 Q1 2026 Pricing)
Benchmarks steady-state 24/7 workloads against equivalent EC2 Spot instances.
"""

import argparse
from typing import Literal, Dict, Optional

# Pricing constants (us-east-1, Q1 2026)
LAMBDA_GB_SECOND_PRICE = 0.0000166667  # $ per GB-second
LAMBDA_REQUEST_PRICE = 0.0000002  # $ per request (first 1M free, we exclude free tier here)
EC2_M7G_MEDIUM_SPOT_HOURLY = 0.0118  # m7g.medium (1 vCPU, 4GB RAM) Spot hourly rate
EC2_M7G_LARGE_SPOT_HOURLY = 0.0236   # m7g.large (2 vCPU, 8GB RAM) Spot hourly rate
# Equivalent Lambda memory to EC2 RAM: Lambda bills per GB-second, so 4GB Lambda = 4GB memory allocation
LAMBDA_MIN_MEMORY_MB = 128  # Minimum Lambda memory allocation
LAMBDA_MAX_MEMORY_MB = 10240  # Maximum Lambda memory allocation

class CostCalculationError(Exception):
    """Custom exception for invalid cost calculation parameters"""
    pass

def calculate_lambda_cost(
    memory_mb: int,
    avg_duration_ms: int,
    requests_per_month: int,
    num_concurrent: int = 1
) -> float:
    """
    Calculate monthly Lambda cost for a steady-state workload.

    Args:
        memory_mb: Allocated memory in MB (rounded up to nearest 64MB by AWS, but we use raw for calculation)
        avg_duration_ms: Average execution duration in milliseconds
        requests_per_month: Number of invocations per month
        num_concurrent: Number of concurrent instances (for provisioned concurrency, if used)

    Returns:
        Monthly cost in USD

    Raises:
        CostCalculationError: If input parameters are invalid
    """
    if memory_mb < LAMBDA_MIN_MEMORY_MB or memory_mb > LAMBDA_MAX_MEMORY_MB:
        raise CostCalculationError(f"Memory must be between {LAMBDA_MIN_MEMORY_MB}MB and {LAMBDA_MAX_MEMORY_MB}MB")
    if avg_duration_ms <= 0:
        raise CostCalculationError("Average duration must be positive")
    if requests_per_month <= 0:
        raise CostCalculationError("Requests per month must be positive")

    # Convert memory to GB
    memory_gb = memory_mb / 1024
    # Convert duration to seconds
    duration_seconds = avg_duration_ms / 1000
    # Calculate GB-seconds per request
    gb_seconds_per_request = memory_gb * duration_seconds
    # Total GB-seconds per month
    total_gb_seconds = gb_seconds_per_request * requests_per_month
    # Add provisioned concurrency costs if applicable (we ignore for steady 24/7, but include for completeness)
    # For 24/7 steady, we assume no provisioned concurrency, use on-demand
    lambda_compute_cost = total_gb_seconds * LAMBDA_GB_SECOND_PRICE
    # Request cost: exclude first 1M free tier requests as we're benchmarking enterprise workloads
    billable_requests = max(0, requests_per_month - 1_000_000)
    lambda_request_cost = billable_requests * LAMBDA_REQUEST_PRICE

    return lambda_compute_cost + lambda_request_cost

def calculate_ec2_cost(
    instance_type: Literal["m7g.medium", "m7g.large"],
    hours_per_month: int = 730,  # Average hours in a month
    spot_discount: float = 0.0  # Additional spot discount (already factored into hourly rate above)
) -> float:
    """
    Calculate monthly EC2 Spot instance cost.

    Args:
        instance_type: EC2 instance type (m7g.medium or m7g.large)
        hours_per_month: Number of hours the instance runs per month
        spot_discount: Additional discount to apply (decimal, e.g., 0.1 for 10% off)

    Returns:
        Monthly cost in USD

    Raises:
        CostCalculationError: If input parameters are invalid
    """
    if instance_type not in ("m7g.medium", "m7g.large"):
        raise CostCalculationError(f"Unsupported instance type: {instance_type}")
    if hours_per_month <= 0:
        raise CostCalculationError("Hours per month must be positive")
    if not 0 <= spot_discount < 1:
        raise CostCalculationError("Spot discount must be between 0 and 1")

    hourly_rate = EC2_M7G_MEDIUM_SPOT_HOURLY if instance_type == "m7g.medium" else EC2_M7G_LARGE_SPOT_HOURLY
    hourly_rate *= (1 - spot_discount)
    return hourly_rate * hours_per_month

def compare_costs(
    lambda_memory_mb: int,
    lambda_duration_ms: int,
    monthly_requests: int,
    ec2_instance_type: Literal["m7g.medium", "m7g.large"]
) -> Dict[str, float]:
    """Compare Lambda vs EC2 costs for equivalent workloads"""
    lambda_cost = calculate_lambda_cost(lambda_memory_mb, lambda_duration_ms, monthly_requests)
    ec2_cost = calculate_ec2_cost(ec2_instance_type)
    return {
        "lambda_monthly_usd": round(lambda_cost, 2),
        "ec2_monthly_usd": round(ec2_cost, 2),
        "cost_ratio": round(lambda_cost / ec2_cost, 1) if ec2_cost > 0 else float("inf")
    }

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Compare AWS Lambda vs EC2 costs for steady workloads")
    parser.add_argument("--lambda-memory", type=int, default=4096, help="Lambda memory allocation in MB (default: 4096)")
    parser.add_argument("--lambda-duration", type=int, default=200, help="Average Lambda duration in ms (default: 200)")
    parser.add_argument("--monthly-requests", type=int, default=25920000, help="Monthly requests (default: 25.92M = 10/second steady)")
    parser.add_argument("--ec2-type", type=str, default="m7g.medium", choices=["m7g.medium", "m7g.large"], help="EC2 instance type")

    args = parser.parse_args()

    try:
        results = compare_costs(
            lambda_memory_mb=args.lambda_memory,
            lambda_duration_ms=args.lambda_duration,
            monthly_requests=args.monthly_requests,
            ec2_instance_type=args.ec2_type
        )
        print(f"Lambda Monthly Cost: ${results['lambda_monthly_usd']}")
        print(f"EC2 Monthly Cost: ${results['ec2_monthly_usd']}")
        print(f"Lambda is {results['cost_ratio']}x more expensive than EC2")
    except CostCalculationError as e:
        print(f"Calculation error: {e}")
        exit(1)

// Production-ready AWS Lambda function for steady-state order processing
// Demonstrates observability, error handling, and retry logic for 24/7 workloads
const AWS = require('aws-sdk');
const { Logger } = require('@aws-lambda-powertools/logger');
const { Tracer } = require('@aws-lambda-powertools/tracer');
const { Metrics, MetricUnits } = require('@aws-lambda-powertools/metrics');

// Initialize Powertools for observability (required for production workloads)
const logger = new Logger({ serviceName: 'order-processor' });
const tracer = new Tracer({ serviceName: 'order-processor' });
const metrics = new Metrics({ serviceName: 'order-processor', namespace: 'OrderProcessing' });

const sqs = new AWS.SQS();
const dynamoDb = new AWS.DynamoDB.DocumentClient();

// Configuration constants
const ORDER_TABLE = process.env.ORDER_TABLE;
const DLQ_URL = process.env.DLQ_URL;
const MAX_RETRIES = 3;
const BATCH_SIZE = 10;

// Custom error classes for structured error handling
class OrderValidationError extends Error {
    constructor(message, orderId) {
        super(message);
        this.name = 'OrderValidationError';
        this.orderId = orderId;
        this.statusCode = 400;
    }
}

class DatabaseError extends Error {
    constructor(message, orderId) {
        super(message);
        this.name = 'DatabaseError';
        this.orderId = orderId;
        this.statusCode = 500;
    }
}

class SqsError extends Error {
    constructor(message, messageId) {
        super(message);
        this.name = 'SqsError';
        this.messageId = messageId;
        this.statusCode = 500;
    }
}

// Validate required environment variables at cold start
if (!ORDER_TABLE || !DLQ_URL) {
    throw new Error('Missing required environment variables: ORDER_TABLE, DLQ_URL');
}

/**
 * Validate incoming order payload
 * @param {Object} order - Order payload from SQS
 * @returns {boolean} True if valid
 * @throws {OrderValidationError} If order is invalid
 */
function validateOrder(order) {
    if (!order.orderId) {
        throw new OrderValidationError('Missing orderId', null);
    }
    if (!order.customerId) {
        throw new OrderValidationError('Missing customerId', order.orderId);
    }
    if (!order.totalAmount || order.totalAmount <= 0) {
        throw new OrderValidationError('Invalid totalAmount', order.orderId);
    }
    return true;
}

/**
 * Process a single order: validate, persist to DynamoDB, emit metrics
 * @param {Object} order - Order payload
 * @param {number} retryCount - Current retry attempt (0-indexed)
 */
async function processOrder(order, retryCount = 0) {
    const segment = tracer.getSegment();
    const subsegment = segment.addNewSubsegment('processOrder');

    try {
        tracer.annotateSubsegment(subsegment, { orderId: order.orderId });
        validateOrder(order);

        logger.info('Processing order', { orderId: order.orderId, retryCount });

        // Persist to DynamoDB with retry logic
        const params = {
            TableName: ORDER_TABLE,
            Item: {
                ...order,
                processedAt: new Date().toISOString(),
                status: 'PROCESSED'
            },
            ConditionExpression: 'attribute_not_exists(orderId)' // Prevent duplicate processing
        };

        await dynamoDb.put(params).promise();
        metrics.addMetric('OrdersProcessed', MetricUnits.Count, 1);
        logger.info('Order processed successfully', { orderId: order.orderId });

        subsegment.close();
    } catch (error) {
        subsegment.close(error);
        logger.error('Failed to process order', { orderId: order.orderId, error: error.message, retryCount });

        if (retryCount < MAX_RETRIES) {
            logger.warn('Retrying order processing', { orderId: order.orderId, nextRetry: retryCount + 1 });
            // Exponential backoff for retries
            await new Promise(resolve => setTimeout(resolve, 100 * Math.pow(2, retryCount)));
            return processOrder(order, retryCount + 1);
        }

        // Send to DLQ after max retries
        await sendToDlq(order, error);
        metrics.addMetric('OrdersFailed', MetricUnits.Count, 1);
        throw error; // Re-throw to fail the Lambda invocation
    }
}

/**
 * Send failed order to Dead Letter Queue
 * @param {Object} order - Failed order payload
 * @param {Error} error - Error that caused failure
 */
async function sendToDlq(order, error) {
    try {
        const params = {
            QueueUrl: DLQ_URL,
            MessageBody: JSON.stringify({
                order,
                error: {
                    name: error.name,
                    message: error.message,
                    stack: error.stack
                },
                failedAt: new Date().toISOString()
            })
        };
        await sqs.sendMessage(params).promise();
        logger.info('Order sent to DLQ', { orderId: order.orderId });
    } catch (dlqError) {
        logger.error('Failed to send order to DLQ', { orderId: order.orderId, dlqError: dlqError.message });
        metrics.addMetric('DlqSendFailed', MetricUnits.Count, 1);
    }
}

/**
 * Lambda handler for SQS batch events
 */
exports.handler = async (event) => {
    const segment = tracer.getSegment();
    segment.addAnnotation('batchSize', event.Records.length);
    logger.info('Processing SQS batch', { batchSize: event.Records.length });

    const processingPromises = event.Records.map(async (record) => {
        try {
            const order = JSON.parse(record.body);
            await processOrder(order);
            return { recordId: record.messageId, status: 'SUCCESS' };
        } catch (error) {
            return { recordId: record.messageId, status: 'FAILURE', error: error.message };
        }
    });

    const results = await Promise.all(processingPromises);
    const successCount = results.filter(r => r.status === 'SUCCESS').length;
    const failureCount = results.filter(r => r.status === 'FAILURE').length;

    metrics.addMetric('BatchSuccessCount', MetricUnits.Count, successCount);
    metrics.addMetric('BatchFailureCount', MetricUnits.Count, failureCount);
    logger.info('Batch processing complete', { successCount, failureCount });

    // Return partial success to SQS to delete successful messages, retry failures
    return {
        batchItemFailures: results
            .filter(r => r.status === 'FAILURE')
            .map(r => ({ itemIdentifier: r.recordId }))
    };
};

# Terraform configuration to deploy equivalent Lambda and EC2 workloads for cost comparison
# AWS Provider version 5.0+ (Q1 2026)
terraform {
  required_version = ">= 1.6.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
  # Store state in S3 for team collaboration
  backend "s3" {
    bucket         = "my-org-terraform-state"
    key            = "serverless-vs-ec2/terraform.tfstate"
    region         = "us-east-1"
    encrypt        = true
    dynamodb_table = "terraform-lock"
  }
}

provider "aws" {
  region = "us-east-1"
}

# Variables for configurable parameters
variable "environment" {
  type        = string
  default     = "prod"
  description = "Deployment environment (prod, staging)"
}

variable "lambda_memory_mb" {
  type        = number
  default     = 4096
  description = "Lambda function memory allocation in MB"
  validation {
    condition     = var.lambda_memory_mb >= 128 && var.lambda_memory_mb <= 10240
    error_message = "Lambda memory must be between 128MB and 10240MB."
  }
}

variable "ec2_instance_type" {
  type        = string
  default     = "m7g.medium"
  description = "EC2 instance type for equivalent workload"
  validation {
    condition     = contains(["m7g.medium", "m7g.large"], var.ec2_instance_type)
    error_message = "EC2 instance type must be m7g.medium or m7g.large."
  }
}

# IAM Role for Lambda function
resource "aws_iam_role" "lambda_role" {
  name = "order-processor-lambda-role-${var.environment}"
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Action = "sts:AssumeRole"
        Effect = "Allow"
        Principal = {
          Service = "lambda.amazonaws.com"
        }
      }
    ]
  })
}

# IAM Policy for Lambda to access DynamoDB and SQS
resource "aws_iam_role_policy" "lambda_policy" {
  name = "order-processor-lambda-policy-${var.environment}"
  role = aws_iam_role.lambda_role.id
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Action = [
          "dynamodb:PutItem",
          "dynamodb:GetItem"
        ]
        Effect   = "Allow"
        Resource = aws_dynamodb_table.orders.arn
      },
      {
        Action = [
          "sqs:ReceiveMessage",
          "sqs:DeleteMessage",
          "sqs:SendMessage"
        ]
        Effect   = "Allow"
        Resource = [aws_sqs_queue.order_queue.arn, aws_sqs_queue.order_dlq.arn]
      },
      {
        Action = [
          "logs:CreateLogGroup",
          "logs:CreateLogStream",
          "logs:PutLogEvents"
        ]
        Effect   = "Allow"
        Resource = "arn:aws:logs:*:*:*"
      }
    ]
  })
}

# Lambda function (equivalent to EC2 workload)
resource "aws_lambda_function" "order_processor" {
  function_name = "order-processor-${var.environment}"
  role          = aws_iam_role.lambda_role.arn
  handler       = "index.handler"
  runtime       = "nodejs18.x"
  memory_size   = var.lambda_memory_mb
  timeout       = 30 # 30 second timeout for order processing
  # Inline code for demo; use S3 bucket for production
  filename      = "${path.module}/lambda.zip"
  source_code_hash = filebase64sha256("${path.module}/lambda.zip")

  environment {
    variables = {
      ORDER_TABLE = aws_dynamodb_table.orders.name
      DLQ_URL     = aws_sqs_queue.order_dlq.id
    }
  }

  tracing_config {
    mode = "Active" # Enable X-Ray tracing
  }

  tags = {
    Environment = var.environment
    Service     = "order-processor"
    Workload    = "steady-state"
  }
}

# SQS Queue for Lambda triggers
resource "aws_sqs_queue" "order_queue" {
  name                       = "order-queue-${var.environment}"
  delay_seconds              = 0
  max_message_size          = 262144 # 256KB
  message_retention_seconds = 86400 # 1 day
  receive_wait_time_seconds = 20 # Long polling

  tags = {
    Environment = var.environment
  }
}

# SQS Dead Letter Queue for failed messages
resource "aws_sqs_queue" "order_dlq" {
  name                       = "order-dlq-${var.environment}"
  message_retention_seconds = 1209600 # 14 days

  tags = {
    Environment = var.environment
  }
}

# Event source mapping to trigger Lambda from SQS
resource "aws_lambda_event_source_mapping" "sqs_trigger" {
  event_source_arn = aws_sqs_queue.order_queue.arn
  function_name    = aws_lambda_function.order_processor.arn
  batch_size       = 10
  maximum_batching_window_in_seconds = 5
}

# DynamoDB table for order storage (shared between Lambda and EC2)
resource "aws_dynamodb_table" "orders" {
  name           = "orders-${var.environment}"
  billing_mode   = "PAY_PER_REQUEST" # Use provisioned for steady workloads, but PAY_PER_REQUEST for demo
  hash_key       = "orderId"

  attribute {
    name = "orderId"
    type = "S"
  }

  tags = {
    Environment = var.environment
  }
}

# EC2 Launch Template for equivalent workload
resource "aws_launch_template" "order_processor_ec2" {
  name_prefix   = "order-processor-ec2-${var.environment}-"
  image_id      = "ami-0abcdef1234567890" # Amazon Linux 2023 ARM (Graviton3) AMI
  instance_type = var.ec2_instance_type
  key_name      = "my-ec2-key" # Replace with your key pair

  iam_instance_profile {
    arn = aws_iam_instance_profile.ec2_profile.arn
  }

  network_interfaces {
    associate_public_ip_address = false
    security_groups             = [aws_security_group.ec2_sg.id]
  }

  user_data = base64encode(<<-EOF
    #!/bin/bash
    yum update -y
    yum install -y nodejs git
    git clone https://github.com/my-org/order-processor-ec2.git /opt/order-processor
    cd /opt/order-processor
    npm install
    # Run the order processor as a systemd service
    cat > /etc/systemd/system/order-processor.service <<-SERVICE
    [Unit]
    Description=Order Processor Service
    After=network.target

    [Service]
    ExecStart=/usr/bin/node /opt/order-processor/index.js
    Restart=always
    Environment=ORDER_TABLE=${aws_dynamodb_table.orders.name}
    Environment=DLQ_URL=${aws_sqs_queue.order_dlq.id}
    Environment=AWS_REGION=us-east-1

    [Install]
    WantedBy=multi-user.target
    SERVICE
    systemctl enable order-processor
    systemctl start order-processor
  EOF
  )

  tags = {
    Environment = var.environment
    Service     = "order-processor"
  }
}

# IAM Instance Profile for EC2
resource "aws_iam_instance_profile" "ec2_profile" {
  name = "order-processor-ec2-profile-${var.environment}"
  role = aws_iam_role.ec2_role.name
}

# IAM Role for EC2 (same permissions as Lambda)
resource "aws_iam_role" "ec2_role" {
  name = "order-processor-ec2-role-${var.environment}"
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Action = "sts:AssumeRole"
        Effect = "Allow"
        Principal = {
          Service = "ec2.amazonaws.com"
        }
      }
    ]
  })
}

# Reuse Lambda policy for EC2 role
resource "aws_iam_role_policy" "ec2_policy" {
  name = "order-processor-ec2-policy-${var.environment}"
  role = aws_iam_role.ec2_role.id
  policy = aws_iam_role_policy.lambda_policy.policy # Reuse the same policy
}

# Security Group for EC2
resource "aws_security_group" "ec2_sg" {
  name   = "order-processor-ec2-sg-${var.environment}"
  vpc_id = "vpc-0abcdef1234567890" # Replace with your VPC ID

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Environment = var.environment
  }
}

# EC2 Spot Instance Request for steady workload
resource "aws_spot_instance_request" "order_processor" {
  launch_template {
    id      = aws_launch_template.order_processor_ec2.id
    version = aws_launch_template.order_processor_ec2.latest_version
  }
  spot_price           = "0.0118" # m7g.medium Spot price as of Q1 2026
  wait_for_fulfillment = true
  instance_count       = 1 # Single instance for steady workload, use ASG for HA

  tags = {
    Environment = var.environment
    Service     = "order-processor"
  }
}

# Outputs to compare costs
output "lambda_function_arn" {
  value = aws_lambda_function.order_processor.arn
}

output "ec2_instance_id" {
  value = aws_spot_instance_request.order_processor.spot_instance_id
}

output "estimated_lambda_monthly_cost" {
  value = "Calculate using the Python cost calculator above with 25.92M monthly requests, 200ms duration, 4096MB memory"
}

output "estimated_ec2_monthly_cost" {
  value = "${var.ec2_instance_type} Spot instance: $0.0118/hour * 730 hours = $8.61/month"
}

# AWS CLI command to get Lambda cost for a tagged workload
aws ce get-cost-and-usage \
  --time-period Start=2026-03-01,End=2026-04-01 \
  --granularity MONTHLY \
  --metrics BlendedCost \
  --group-by Type=DIMENSION,Key=SERVICE \
  --filter '{"Tags":{"Key":"Workload","Values":["order-processor"]}}'

# Terraform scheduled ASG action for daily traffic spike
resource "aws_autoscaling_schedule" "evening_spike" {
  scheduled_action_name  = "evening-spike-scale-out"
  min_size               = 2
  max_size               = 3
  desired_capacity       = 2
  recurrence             = "0 17 * * *" # 5 PM UTC daily
  autoscaling_group_name = aws_autoscaling_group.order_processor.name
}

// Go EC2 worker snippet to poll SQS for batch jobs
func pollSQS() {
    for {
        result, err := sqs.ReceiveMessage(&sqs.ReceiveMessageInput{
            QueueUrl:            &queueURL,
            MaxNumberOfMessages: 10,
            WaitTimeSeconds:     20, // Long polling
        })
        if err != nil {
            log.Printf("Failed to receive SQS messages: %v", err)
            continue
        }
        for _, msg := range result.Messages {
            processBatchJob(msg.Body)
            sqs.DeleteMessage(&sqs.DeleteMessageInput{
                QueueUrl:      &queueURL,
                ReceiptHandle: msg.ReceiptHandle,
            })
        }
    }
}