DGX Spark/Guides/Cold start vs always-on: choosing an instance uptime pattern
Cost

Cold start vs always-on: choosing an instance uptime pattern

By Samuel Seidel · Published September 9, 2026

Stop a Spark between uses if your usage has a predictable window and nothing needs an answer within seconds at any hour; keep it running if something depends on it around the clock. This page shows how to tell which case you're in. A rented Spark has three states (running, stopped and terminated), and each has a different cost and a different guarantee about what's still there when you come back.

What each state actually costs and keeps

Per the pricing page, a running Spark bills the full $0.79/hour on-demand rate. Stopping an instance keeps it held for you (the same machine, the same SSH port and hostname, workspace intact) at 75% of the running rate: $0.59/hour. Terminating ends billing entirely, but it also deletes the workspace for good, with no copy kept. That's why the console asks you to type the instance name to confirm.

The middle state, stopped, is what makes a cold-start pattern viable at all. It isn't free (a stopped Spark still holds its allocation), but it costs a quarter less than running and keeps everything on disk. If your pattern is closer to "start it, terminate it, start a fresh one next time," nothing carries over between sessions: every restart means re-fetching models and redoing setup from scratch.

The case for stopping between uses

Stopping fits usage that's genuinely intermittent: a research or evaluation workload run for a few hours a day, a batch job that only needs the GPU during a nightly window, or a team still in early testing where the Spark sits idle most of the time. At 75% of the running rate while stopped, the savings scale directly with how much of the day the instance would otherwise sit idle but running. A Spark used eight hours a day and stopped the other sixteen costs noticeably less over a month than one left running continuously, even accounting for the stopped-hour charge.

The tradeoff is restart time. Model presets may need several minutes to warm up after a restart, per the pricing page's own FAQ, and that's after the instance itself comes back online. For an interactive workload where someone is waiting on the first response of the day, that warm-up is a real, if bounded, delay. For a batch or scheduled job it hardly matters, because nothing is waiting on it.

The case for always-on

Always-on fits the opposite profile: an endpoint other systems depend on, a chat interface teammates use throughout the day without warning, or any workload where a multi-minute cold start would be visible to a user at an unpredictable moment. Running continuously also avoids the small operational overhead of a stop/start routine, whether that's a person remembering to do it or a script that has to be maintained and monitored.

The cost tradeoff runs the other way here: 24 hours running costs $18.96 against $14.16 for 24 hours stopped (the pricing page's worked example). That gap adds up every day the instance doesn't need to be up around the clock. Always-on is the more expensive default, so confirm the workload needs it before you choose it out of convenience.

A rough way to decide

The deciding question is usually: does anything depend on this endpoint responding within seconds, at any hour, without advance notice? If yes, always-on is close to a requirement, not a preference. If the workload has a predictable active window (business hours, a nightly batch, one team's working hours in one timezone), stopping outside that window is close to free savings: the warm-up delay lands when nobody is waiting.

For genuinely unpredictable, bursty usage with no clear pattern, no uptime policy solves it cleanly on a single Spark. A scheduled stop/start based on observed usage patterns, revisited periodically, tends to work better than either extreme applied blindly.

Whichever pattern you choose, terminating (not stopping) is the only state that fully ends billing, and it permanently deletes the workspace. Keep a backup of anything that matters before terminating; GPUwerk keeps no copy once an instance is gone.

For working through the actual monthly cost of either pattern against a specific usage estimate, see the cost forecasting guide. Full pricing detail, including the stopped-rate math, is on the pricing page. A first engagement can help model the right uptime pattern against a specific workload before committing to one.

First top-up: pay $20, get $30 in credit

Stop, don't terminate, and pick up right where you left off.

Rent a dedicated Spark from $0.79/h, billed by the minute, and stop it whenever nobody needs it.

Create account See pricing