Compute: capacity-time, not work
Why does a cheaper-per-hour engine often cost more per useful hour?
Compute: you are billed for capacity-time, not for work
Compute meters occupancy. The billed quantity is capacity × time. The useful quantity is work done. The ratio between them is utilization, and it is entirely your problem. So
Data table
| Utilization | $ per useful hour |
|---|---|
| 0.05 | 20 |
| 0.062 | 16.2 |
| 0.074 | 13.6 |
| 0.086 | 11.7 |
| 0.098 | 10.3 |
| 0.109 | 9.14 |
| 0.121 | 8.25 |
| 0.133 | 7.51 |
| 0.145 | 6.9 |
| 0.157 | 6.37 |
| 0.169 | 5.93 |
| 0.181 | 5.54 |
| 0.193 | 5.19 |
| 0.204 | 4.89 |
| 0.216 | 4.62 |
| 0.228 | 4.38 |
| 0.24 | 4.17 |
| 0.252 | 3.97 |
| 0.264 | 3.79 |
| 0.276 | 3.63 |
| 0.287 | 3.48 |
| 0.299 | 3.34 |
| 0.311 | 3.21 |
| 0.323 | 3.09 |
| 0.335 | 2.99 |
| 0.347 | 2.88 |
| 0.359 | 2.79 |
| 0.371 | 2.7 |
| 0.382 | 2.61 |
| 0.394 | 2.54 |
| 0.406 | 2.46 |
| 0.418 | 2.39 |
| 0.43 | 2.33 |
| 0.442 | 2.26 |
| 0.454 | 2.2 |
| 0.466 | 2.15 |
| 0.477 | 2.09 |
| 0.489 | 2.04 |
| 0.501 | 2 |
| 0.513 | 1.95 |
| 0.525 | 1.9 |
| 0.537 | 1.86 |
| 0.549 | 1.82 |
| 0.561 | 1.78 |
| 0.573 | 1.75 |
| 0.584 | 1.71 |
| 0.596 | 1.68 |
| 0.608 | 1.64 |
| 0.62 | 1.61 |
| 0.632 | 1.58 |
| 0.644 | 1.55 |
| 0.656 | 1.53 |
| 0.667 | 1.5 |
| 0.679 | 1.47 |
| 0.691 | 1.45 |
| 0.703 | 1.42 |
| 0.715 | 1.4 |
| 0.727 | 1.38 |
| 0.739 | 1.35 |
| 0.751 | 1.33 |
| 0.763 | 1.31 |
| 0.774 | 1.29 |
| 0.786 | 1.27 |
| 0.798 | 1.25 |
| 0.81 | 1.23 |
| 0.822 | 1.22 |
| 0.834 | 1.2 |
| 0.846 | 1.18 |
| 0.857 | 1.17 |
| 0.869 | 1.15 |
| 0.881 | 1.13 |
| 0.893 | 1.12 |
| 0.905 | 1.1 |
| 0.917 | 1.09 |
| 0.929 | 1.08 |
| 0.941 | 1.06 |
| 0.953 | 1.05 |
| 0.964 | 1.04 |
| 0.976 | 1.02 |
| 0.988 | 1.01 |
| 1 | 1 |
Minimum billing increments are fixed cost in dollars
A minimum increment is the fixed cost per operation of the vendor, shown on your bill. A 60-second minimum against 5-second jobs means you pay 12× for the work. The natural batch size is exactly that ratio: consolidate small jobs until the job duration is larger than the billing increment. Run twelve 5-second jobs inside one 60-second billed slot, and the waste disappears.
Parallelism is not free
Under occupancy pricing, parallelism looks free: ten machines for one hour cost the same as one machine for ten hours. That is true only while efficiency stays constant. But more machines also mean more coordination. Scalability models (the Universal Scalability Law) show that past a certain number of workers, throughput goes down. Beyond that peak you pay strictly more money for a strictly slower answer. This is the cost of coordination, now with a price tag.
Burstable, credit-based machines hide one more term: they earn credits when idle and are throttled when the credits run out. The meter hides the throttling, and it contaminates any measurement taken on such machines: a benchmark run with full credits does not represent steady state.