Stop Paying the AWS Default Tax

I spent forty thousand dollars on AWS over three years for a project that generated a fraction of that in revenue. I treated cloud infrastructure like a utility bill. I assumed the default EC2 instances were good enough for my workloads and paid the invoice every month without looking at the underlying hardware. I was completely wrong.

Developers fall into a comfortable trap. We learn one ecosystem and memorize a few instance types. Then we stop paying attention to the silicon underneath. Compute is just hardware. The processors powering the data centers have shifted drastically while our deployment habits have stayed exactly the same. I recently ran a massive benchmarking suite across the major providers to see what I was actually paying for. The results forced me to reconsider my entire approach to system architecture.

The Silicon Reality Check

If you are still spinning up default Intel instances, you are burning money. AMD EPYC Turin has taken over the server market. In my single-threaded testing, Turin beat everything else available. The margin is not small. It is a fundamental shift in x86 dominance.

Intel Granite Rapids finally fixed the performance instability that plagued the Emerald Rapids generation under heavy load. It provides a consistent baseline now. The gap between Intel and AMD is still wide enough that you should actively filter for Turin when provisioning new nodes.

Then there is the ARM architecture. Google Axion and Azure Cobalt 100 are pushing numbers that rival the previous generation of AMD processors. If your application can compile and run on ARM, you are looking at serious cost reductions without sacrificing throughput. AWS Graviton4 is solid, but the competition has caught up entirely.

Pricing Disconnects and the Spot Market Arbitrage

AWS has the worst on-demand price-to-performance ratio in the industry right now. Unless you are specifically provisioning their C8a instances with SMT disabled, you are overpaying for raw compute. Their legacy instances are kept artificially expensive, penalizing teams that refuse to migrate.

I started looking at Hetzner for shared-core workloads. Their pricing model feels broken. You get massive performance per dollar, though you trade away the multi-region redundancy and instant availability of the top-tier providers. For a solopreneur or a bootstrapped startup, paying AWS premiums for background workers or staging environments makes zero sense. Oracle Cloud is another bizarre outlier. Their AmpereOne M instances dominate the multi-threaded price-to-performance charts, and they offer a free tier that is perfect for low-traffic services.

Spot instances change the math entirely. If your system can handle interruptions gracefully, spot instances give you roughly double the performance per dollar compared to a three-year reserved commitment. You just need the code to handle the chaos.

Implementation: Breaking the Default Habit

Knowledge without execution is just trivia. I stopped clicking through the AWS console and moved my infrastructure entirely to code. This isolates my application logic from my hosting provider, letting me swap vendors when the math stops making sense.

Here is how I use Pulumi with TypeScript to provision a cost-effective Hetzner node instead of defaulting to an overpriced EC2 instance. We target the CPX22 shared-core instance type because it uses AMD processors and offers incredible single-threaded value.

import * as pulumi from "@pulumi/pulumi";
import * as hetzner from "@pulumi/hcloud";
 
// Provisioning a high-value AMD node on Hetzner
const server = new hetzner.Server("cost-optimized-node", {
    serverType: "cpx22",
    image: "ubuntu-24.04",
    location: "fsn1",
    publicNets: [{
        ipv4Enabled: true,
        ipv6Enabled: true,
    }],
});
 
export const serverIp = server.ipv4Address;

If you are locked into AWS for compliance or data-gravity reasons, you cannot rely on on-demand pricing. You need to automate spot instance requests. Below is a Node.js snippet using the AWS SDK to request spot capacity specifically for the Turin-based C8a instances.

import { EC2Client, RequestSpotInstancesCommand } from "@aws-sdk/client-ec2";
 
const client = new EC2Client({ region: "us-east-1" });
 
async function requestComputeCapacity() {
    const command = new RequestSpotInstancesCommand({
        InstanceCount: 1,
        Type: "one-time",
        LaunchSpecification: {
            ImageId: "ami-0abcdef1234567890",
            InstanceType: "c8a.large", // Targeting the AMD Turin architecture
            KeyName: "production-key",
            SecurityGroupIds: ["sg-0123456789abcdef0"],
        },
        // Define the absolute maximum you will pay per hour
        SpotPrice: "0.05",
    });
 
    try {
        const response = await client.send(command);
        console.log("Capacity requested successfully:", response.SpotInstanceRequests);
    } catch (error) {
        console.error("Failed to acquire cheap compute:", error);
    }
}
 
requestComputeCapacity();

Modeling the True Cost of Operations

Moving away from managed services requires a sober assessment of your own time. A bare-metal server is cheaper until you spend three days debugging a kernel panic. I wrote a small utility script to calculate the break-even point between managed cloud and alternative providers.

interface CloudProvider {
    name: string;
    monthlyCost: number;
    estimatedMaintenanceHours: number;
}
 
function calculateTotalCostOfOwnership(
    provider: CloudProvider,
    hourlyDeveloperRate: number
): number {
    const annualHardwareCost = provider.monthlyCost * 12;
    const annualLaborCost = provider.estimatedMaintenanceHours * 12 * hourlyDeveloperRate;
    return annualHardwareCost + annualLaborCost;
}
 
const awsOnDemand: CloudProvider = {
    name: "AWS Default On-Demand",
    monthlyCost: 150,
    estimatedMaintenanceHours: 2
};
 
const hetznerBareMetal: CloudProvider = {
    name: "Hetzner Shared Core",
    monthlyCost: 20,
    estimatedMaintenanceHours: 6
};
 
// Assuming your time is worth $100/hr
const developerRate = 100;
 
console.log(`Annual AWS Cost: $${calculateTotalCostOfOwnership(awsOnDemand, developerRate)}`);
console.log(`Annual Hetzner Cost: $${calculateTotalCostOfOwnership(hetznerBareMetal, developerRate)}`);

When I run this math for my own projects, the alternative providers almost always win for staging environments and CI/CD runners. They also make perfect sense for background workers. The expensive, highly available cloud instances are reserved exclusively for the customer-facing production database.

The Baseline Truth

You do not need to migrate your core infrastructure to a budget provider today. You do need to audit what you are running.

Check your cloud bill this afternoon. Find the instances handling asynchronous background jobs or internal reporting. If those are running on legacy x86 instances at a premium provider, you are directly funding their data center expansion instead of your own runway. Switch them to ARM or move them to a cheaper provider. Alternatively, rewrite your deployment scripts to utilize the spot market. Compute is a commodity. Buy it like one.