#Cost
21 posts
Cutting NAT Gateway Costs: The Data Processing Fee Is the Real Bill
A breakdown of the NAT Gateway bill and the order to cut it: the three overlapping charge layers (hourly, data processing, internet transfer), why downloads get charged too, the cost math of each bypass route from free gateway endpoints through interface endpoints, IPv6, and NAT instances, how to find the traffic culprits, and the cost structure of multi-AZ placement.
DynamoDB vs RDS: Choosing an AWS Database
A working standard for choosing between DynamoDB and RDS: the data-model difference between key-value and relational, how per-request versus per-instance-hour billing splits the bill, DynamoDB's constraint of designing access patterns up front, the trap of GSIs multiplying write costs, a selection order driven by traffic patterns, and the setup that runs both side by side.
RAG vs Fine-Tuning vs Long Context: Getting Knowledge Into an LLM
A working standard for the three ways to get your data into an LLM: the structural difference between retrieving and injecting (RAG), modifying weights (fine-tuning), and stuffing everything in with caching (long context), the boundary that fine-tuning teaches behavior rather than knowledge, a selection order driven by knowledge size and update frequency, and the practical setup that combines all three.
RI vs Savings Plans: Choosing an AWS Commitment Discount
A working standard for choosing between Reserved Instances and Savings Plans: the structural difference between matching instance attributes and committing to an hourly spend, the flexibility split behind the identical 72% maximum discount, the services Savings Plans cannot cover (RDS and friends), capacity reservation as a separate problem, and how to size a commitment against the stable floor of your bill.
EFS vs EBS vs S3: Choosing AWS Storage
A working standard for choosing among the three AWS storage services: the access-model difference between block, file, and object storage, unit prices that spread from $0.023 to $0.30 per GB and the provisioned-versus-usage billing split behind them, hidden costs like EFS throughput charges, the common overengineering of using EFS without a sharing requirement, and a selection order driven by access patterns.
SQS vs SNS vs EventBridge: Choosing a Messaging Service
A working standard for choosing among the three AWS messaging services: the model difference between a queue, pub/sub, and an event bus, where retention and retries exist and where they do not, pricing that spreads from $0.40 to $1.00 per million with 64KB-chunk billing, combination patterns like SNS-to-SQS fan-out, and the traps of EventBridge latency and FIFO throughput limits.
ALB vs NLB: Choosing a Load Balancer
A working standard for choosing between ALB and NLB: the layer difference between L7 routing and L4 forwarding, the things only NLB can do (static IPs, source IP preservation, PrivateLink), how bills diverge in LCU math even though the hourly rate is identical, hidden costs like cross-zone load balancing, and the chained NLB-to-ALB setup for when you need both.
Choosing a GPU Cloud: Hyperscaler vs Specialist GPU Cloud vs Serverless Inference
A working standard for where to rent GPUs for AI workloads: why H100 hourly rates run 2〜5x apart between hyperscalers (AWS) and specialist GPU clouds (Lambda, RunPod), what you accept when spot drops below half, where serverless inference removes GPU management with per-token billing, and the integration, network, and regulatory requirements that flip the price difference.
LLM API vs Self-Hosting: Doing the Break-Even Math
A working standard for deciding whether to use an LLM API or self-host: the structural difference between per-token and per-GPU-hour billing, how to compute break-even from the tokens one GPU produces in a day, where utilization, batching, and quantization move the crossover, and the factors outside price — data privacy, latency, operational burden — that decide when the math is close.
Lambda vs Fargate: Choosing Serverless Compute
A working standard for choosing between Lambda and Fargate: the structural difference between per-invocation and per-task billing, the unit-price math that makes Lambda over twice as expensive when running continuously and the utilization threshold that follows, Lambda's hard limits (15 minutes, 10GB, cold starts), the hidden costs where API Gateway and log ingestion outgrow the compute bill, and a selection order driven by workload shape.
Aurora vs RDS: The Structural Difference and When to Switch
A working standard for choosing between Aurora and standard RDS: what the separated compute/storage architecture buys (15 shared-storage read replicas, fast failover, 256TiB auto-scaling), the three-layer pricing where storage and I/O ride on an instance premium, the 25% threshold that makes I/O-Optimized cheaper, Serverless v2 with scale-to-zero, and the conditions where standard RDS remains the right answer.
S3 Storage Classes Compared: Standard to Glacier Deep Archive
A working standard for choosing S3 storage classes: the full map of storage rates versus retrieval fees and minimum durations, the three traps in Standard-IA (retrieval fees, 30 days, 128KB), the real differences between the three Glacier classes (instant, hours, 12+ hours), why Intelligent-Tiering is the answer when access patterns are unknown, and when lifecycle transition fees eat the savings.