Usage & cloud pricing
Device capability & fallback
—
monthly savings vs pure-cloud, hybrid on-device approach—savings %
—pure-cloud baseline / mo
—hybrid total / mo
Cost breakdown
| Line item | Inferences / mo | Cost / mo |
|---|
| Pure-cloud baseline (100% cloud, no on-device) | — | — |
| — cloud-only users (not on-device-capable) | — | — |
| — cloud fallback from on-device-capable users | — | — |
| = Hybrid cloud bill | — | — |
| + Amortized on-device setup cost | — | — |
| = Hybrid total monthly cost | — | — |
Break-even on the one-time setup cost
—
How this connects to other tools
Two calculators already on this site price a related but structurally different decision. The Self-Host vs API Cost Calculator and the Self-Hosted LLM vs API Calculator both model server-side self-hosting — renting your own GPU or cloud instance and running inference there yourself, compared against paying a provider per token or per call. The cost shape in both is still a server somewhere with a real hosting bill, just one you control instead of a vendor's. This calculator instead models client-side on-device inference running directly on the end user's phone hardware — no server to rent, effectively zero marginal cost per inference once the model ships, and a completely different bottleneck: not GPU-hours, but what fraction of your users own capable-enough devices and how often even those devices still need to fall back to the cloud. If you are deciding between renting a GPU box and paying a cloud API, use the self-hosted calculators; if you are deciding whether to ship a quantized model inside your mobile app itself, this is the one that matches that cost shape.
Reading the numbers
At the defaults — 100,000 monthly active users, 50 inferences per user per day, $0.001 per cloud inference, a $40,000 one-time on-device build, 60% of users on capable devices, a 5% cloud-fallback rate on those capable users, amortized over 12 months — the pure-cloud baseline runs $150,000/month. Going hybrid brings the residual cloud bill down to $64,500/month (60,000,000 inferences from cloud-only users plus 4,500,000 fallback inferences from capable users), adds roughly $3,333/month in amortized setup cost, and lands on a hybrid total near $67,833/month — a savings of about $82,167/month, or roughly 55% off the pure-cloud baseline. The $40,000 setup cost itself breaks even in under half a month at this volume, because the monthly cloud spend it deflects (about $85,500/month) dwarfs the one-time build cost almost immediately. That math changes fast at lower scale: run the same inputs at 5,000 users instead of 100,000 and the break-even stretches to roughly 20x longer — about 9.4 months instead of under half a month — because there simply are not enough deflected inferences per month to recoup the build cost quickly. Plug in your app's real MAU, not an aspirational one, before committing engineering budget to an on-device build.
How this calculator works
The Edge / On-Device AI Inference vs Cloud API Calculator first computes a pure-cloud baseline: inferences per user per day × monthly active users × 30, priced at your cloud-per-inference rate — this is what you'd pay with zero on-device model at all. It then splits your user base by on-device-capable percentage into capable users and cloud-only users. Cloud-only users generate a full cloud bill for every one of their inferences, since their devices can't run the local model at all. On-device-capable users mostly run inference locally at effectively zero marginal cost, except for a cloud-fallback percentage of their queries — too complex, low-battery, a cold-start before the local model finishes downloading, or a low-confidence local result — which still bills against the cloud API.
Deliberately, this calculator does not put a dollar figure on the on-device compute, battery drain or storage footprint itself — it treats the marginal cost of a local inference as zero once the model has shipped. That's a realistic simplification for small, well-quantized models running on modern flagship chips, where the incremental battery and compute cost per inference is negligible next to a cloud API bill. It understates the real cost for very large on-device models or older/low-end devices, where thermal throttling, battery drain and storage pressure are real (if hard-to-price-in-dollars) costs worth weighing separately. The residual cloud-only and cloud-fallback inferences get summed into a hybrid cloud bill, then the one-time on-device setup cost (engineering, quantization, shipping) is divided by your chosen amortization window and added on top to get the hybrid total monthly cost. Comparing that against the pure-cloud baseline gives the monthly savings and savings percentage, while dividing the setup cost by the monthly cloud spend it deflects (pure-cloud minus hybrid cloud bill, ignoring amortization) gives the standalone break-even in months — how fast the one-time build pays for itself from cloud savings alone.
Frequently asked questions
Why does on-device inference have a one-time cost instead of a per-inference cost like cloud APIs?
Because the expensive part of on-device inference is building it, not running it. Quantizing a model down to a size that fits on a phone, converting it to Core ML or a TensorFlow Lite / NNAPI format, testing it across device tiers, and shipping it inside the app binary or as a downloadable asset is a fixed engineering project with a fixed price tag, paid once regardless of whether one user or ten million users end up running it. A cloud API instead bills per request because the provider's GPU time is a real marginal cost on every single call. Once the on-device model is quantized and shipped, running one more inference on a user's own phone costs the app owner essentially nothing beyond a sliver of the user's battery and compute — no server, no per-call bill — which is exactly what turns the one-time setup cost into something worth amortizing over months rather than expensing per call.
What happens if my on-device-capable percentage is low — does on-device ever stop being worth it?
Yes, and this calculator is built to show exactly where that line is. As the on-device-capable percentage drops, more of your user base falls back into the cloud-only bucket, so the residual monthly cloud bill climbs back toward the pure-cloud baseline while you are still paying to amortize the setup cost on top of it — at some low enough capable percentage, the hybrid approach can cost more than pure cloud ever would have, not less. The other lever that matters just as much is total inference volume: the same setup cost that pays for itself in under a month at 100,000 monthly active users can take many months, or effectively never break even within a product's lifetime, at a few thousand users, because there simply are not enough inferences being deflected off the cloud bill to recoup the build cost. Before committing engineering budget to an on-device build, it is worth plugging in your actual MAU and your best real estimate of device capability rather than assuming the economics scale down linearly.
Why is there still a cloud bill even for users running on-device?
Because on-device capability is never all-or-nothing in practice. Even on a phone that is fully capable of running the local model, some fraction of queries still need to go to the cloud: a query too complex or too far outside the local model's scope for a compressed on-device version to handle well, a low-battery or thermal-throttling situation where the OS restricts on-device compute, a cold-start window before the local model asset has finished downloading after install or update, or simply a local inference that comes back low-confidence and needs a cloud model to double-check it. This calculator models that as a cloud-fallback percentage applied only to on-device-capable users' queries, on top of the full cloud bill still owed by the users whose devices cannot run on-device inference at all — so the residual cloud line item in the hybrid total is never zero, even at very high device-capability rates.
How is this different from the self-hosted LLM vs API calculator already on this site?
Both the Self-Host vs API Calculator and the Self-Hosted LLM vs API Calculator already on this site model server-side self-hosting: renting your own GPU instance or cloud box and running inference there yourself, compared against paying a cloud provider per token or per call — the cost shape in both cases is still a server somewhere with a hosting bill, just yours instead of a vendor's. This calculator models something structurally different: client-side on-device inference running directly on the end user's own phone hardware, where there is no server to rent and the marginal cost per inference is effectively zero once the model ships. What replaces the hosting bill here is a one-time engineering cost to build and quantize the model, amortized over months, plus a capped ceiling on how much cloud spend you can actually deflect — set by what fraction of your users own capable-enough devices and how often even those devices still need to fall back to the cloud.