The Break-Even Math Nobody Runs Before Buying a GPU

Patch Tuesday Reality Check

Are you patching servers again this month? If you self-host anything, the answer is probably yes, and it never really stops.

Every serious IT team just spent hours this cycle applying Microsoft's latest round of security updates, testing for breakage, and rebooting systems on a schedule nobody enjoys. That work does not show up on the invoice when you buy a GPU. It shows up later, as time, as attention, as the person who has to notice when something silently fails at 2am.

This matters more than it sounds like it should when you are deciding whether to run your own LLM instead of calling an API. The GPU purchase price feels like the whole decision. It is not. A self-hosted model needs the same category of ongoing care as any other server: driver updates, security patches, dependency conflicts, and the occasional afternoon lost to a library update that broke your inference stack for reasons nobody can quite explain.

None of this shows up in the spreadsheets people run before buying hardware. They price out the card, maybe the electricity, call it done, and assume the math favors them because the API meter keeps running and the GPU sits in a closet. The real comparison needs a few more line items than that.

The Numbers Most People Skip

Run the actual break-even math and the picture gets uncomfortable fast.

A mid-range GPU VPS at $365 a month sounds cheap against a frontier API charging $15 per million output tokens. It is, eventually. You need 24.3 million output tokens a month before the GPU rental pays for itself. Below that number, you were better off paying per token and never thinking about it again.

Drop down to a quantized 32B model like Qwen 3.6 running on a single RTX 3090, and the math changes shape without getting friendlier. That setup runs about $146 a month. Compared against a $0.40 per million token API, break-even lands around 100 million blended tokens a month. That is not a side project's workload. That is a team running the model constantly, every day, with something close to full utilization.

Nobody puts these two numbers side by side before buying hardware. They see $365 a month and assume it beats an API meter that never stops running. They do not ask which API, at what price, and at what volume the math actually flips. The frontier comparison and the budget comparison are two entirely different decisions, and most people only run one of them, usually the one that makes the GPU look good.

Why Cheap APIs Usually Win Anyway

Both of those break-even numbers still assume you are competing against an expensive frontier API. Most people are not.

Open-weight models are cheap to rent from someone else's server too. Budget hosted APIs running the same class of model you would self-host charge somewhere between $0.14 and $0.50 per million tokens. Run the break-even math against that price instead of the $15 frontier number, and the volume required jumps past 2.5 billion tokens a month.

Nobody solo hits that number. Most small teams do not either. Bring the actual physics of the comparison into the room and it gets worse than uncomfortable. Even a self-hosted node running at 100% utilization, batch processing around the clock with no downtime, no idle hours, no wasted GPU cycles, still lands around $10 per million output tokens. A cheap API charges $0.87 for the same million. That is not a rounding error. That is more than eleven times the cost, and it assumes the kind of flawless, nonstop utilization almost nobody actually runs.

This is the comparison that gets skipped every time. People check self-hosting against the API they are annoyed about paying for, usually a frontier model, and feel vindicated. They never check it against the API that is actually priced to compete with them.

What Utilization Actually Costs You

Here is the part that makes the break-even math even worse than it already looked. Every number in the previous section assumed 100% utilization, batch processing, no gaps. Real deployments do not run that way.

Actual GPU utilization in production self-hosted setups typically lands somewhere between 5% and 50%. Requests arrive in bursts. The card sits idle between them. You are paying for a GPU that spends most of its life waiting, not computing, and idle GPU time is not free just because nobody is hitting the endpoint.

Then there is the second multiplier nobody puts in the spreadsheet: the people running the thing. Monitoring, patching, model updates, prompt debugging, the afternoon lost when quantization breaks something for reasons nobody can quite explain. Ops and engineering overhead typically multiplies raw GPU rental cost by 3 to 5x once you account for the actual labor of keeping the thing alive.

Stack low utilization on top of that overhead multiplier, and the $146 or $365 sticker price on your GPU rental was never the number determining your break-even point. The real number is 3 to 5 times higher, applied against a utilization rate that is probably closer to 20% than 100%. That is the math almost nobody runs before buying the hardware.