All posts
Step Functions vs SQS Chains: Choosing a Workflow Orchestration Model
Whether multi-step backend processing should be conducted by Step Functions or passed along SQS-and-Lambda chains: the structural split between orchestration and choreography, the price gap between Standard at $25 per million state transitions and Express at $1 per million executions, what an SQS chain gains in simplicity and loses in visibility, and the deciding factors of retries, compensation, and long runs, plus the patterns that combine both.
Graviton vs x86: Choosing an EC2 Instance Architecture
A working standard for ARM (Graviton) versus x86 on EC2: the hourly rate gap between m8g and m7i and the larger price-performance gap behind it, where Graviton5 (m9g, GA in 2026) fits, why managed services migrate first, the difficulty gap between interpreted languages and native dependencies, the workloads where x86 remains, and the decision order.
Cutting CloudWatch Logs Costs: Ingestion Is the Bill, Not Storage
Decomposing the CloudWatch Logs bill: why ingestion at $0.50/GB is 17 times the $0.03 storage rate, what the half-price Infrequent Access log class gives up, volume tiers and the intelligent tiering introduced in 2026, routing Lambda logs to S3 and Firehose instead, retention settings, and the order in which to reduce what you ingest.
Aurora Serverless v2 vs Provisioned: Pricing Structure and When to Use Which
A working standard for Aurora's two capacity models: the ACU billing unit at about $0.12 per hour, what scale-to-zero auto-pause buys and the resume delay it costs, the break-even where provisioned plus commitments wins for steady load, the trap of a high ACU floor turning serverless into fixed cost, and the hybrid of a provisioned writer with serverless readers.
Choosing an ElastiCache Engine: Valkey vs Redis OSS vs Memcached
A working standard for the three ElastiCache engines: how Valkey, forked after the Redis license change, became the default for new clusters, the 20% node-based and 33% serverless price gap, the serverless minimum that splits at 100MB for Valkey versus 1GB for Redis OSS, the narrow niche where Memcached still fits, and the node-based versus serverless decision.
API Gateway vs ALB: Choosing What Sits in Front of Lambda
A working standard for what to put in front of Lambda: the pricing-model split between per-request billing (HTTP API at $1.00 per million) and hourly-plus-LCU billing (ALB at about $16/month fixed), the crossover near 16 million requests a month, the feature set that justifies REST API at $3.50, where the free Lambda Function URL fits, and a decision order that includes VPC-internal targets and WAF.
Fixing Lambda Cold Starts: The Cost Math of Provisioned Concurrency
Lambda cold starts and their remedies from a cost angle: how the init phase creates the latency, the near-free fixes like smaller packages and SnapStart, the two-part pricing of Provisioned Concurrency ($0.0000041667/GB-s to keep warm plus a discounted execution rate), the crossover around 60% utilization where it becomes cheaper than on-demand, scheduling, and the decision order.
AWS Data Transfer Pricing, Explained: What's Billed and What's Free
A leg-by-leg breakdown of the hardest line item to read on an AWS bill: the inbound-free, outbound-paid principle, internet egress at $0.09/GB, free same-AZ traffic versus $0.01/GB each way across AZs, cross-region transfer, the NAT Gateway and public IPv4 charges that stack on top, VPC endpoints as the bypass, and the order in which to cut the bill.
The Cost Case for CloudFront: When It Saves Money and When It Doesn't
Whether putting CloudFront in front actually lowers your bill, worked out with numbers: the rate gap between direct EC2/S3 transfer at $0.09/GB and CloudFront at $0.085/GB, the structural fact that origin-to-CloudFront transfer is free, the effect of the always-free 1TB, the trap where request fees become the main cost for small responses, and how cache hit ratio decides the outcome.
Terraform Associate 004 #10 Practice Exam: 50 Questions Across the Full Scope with Explanations
A 50-question multiple-choice practice exam drawn from all nine parts of the series. The questions are arranged by domain — from IaC concepts through the workflow, state, modules, writing configuration, the new 004 scope of ephemeral and write-only, and HCP Terraform — and every question comes with an explanation covering the reasoning behind the answer and the traps in the wrong choices. Grade yourself, then go back to the matching part for any weak domain as a final check.
Terraform Associate 004 #9 HCP Terraform: Workspaces, Variable Sets, Policies, and Drift Detection
Starting from the fact that an HCP Terraform workspace shares only its name with the CLI workspace, we lay out the structure that groups workspaces under projects and the three ways runs start (VCS-, CLI-, and API-driven). We then cover variable sets for supplying values to multiple workspaces, where Sentinel and OPA policies are evaluated and the hard versus soft failure distinction, always-on drift detection, and the relationship with Terraform Enterprise — the areas 004 widened.
Terraform Associate 004 #8 Deep Dive on the New Scope: ephemeral, write-only, and Meta-Arguments
This part gathers 004's flagship new scope in one place. We cover the nature of ephemeral values that never land in plan or state and where they can be used, how write-only arguments solve the secrets problem and why _wo_version is what triggers rotation, then firm up the meta-arguments from the exam's angle: the legitimate use of depends_on, choosing between count and for_each, and how the three lifecycle arguments — create_before_destroy, prevent_destroy, and ignore_changes — differ in effect.