DGX Spark/Guides/Migrating an existing self-hosted AI deployment to a DGX Spark
Migration

Migrating an existing self-hosted AI deployment to a DGX Spark

By Samuel Seidel · Published September 9, 2026

This guide moves an existing self-hosted deployment (a workstation with a consumer GPU, or a cloud GPU instance elsewhere) onto a Spark in four steps: re-check quantization, move the data, validate side by side, then cut over gradually. Expect three gotchas: the memory architecture is different, the quantization that worked on your old box may not be the right one here, and the data move must not depend on shutting the old machine down while you test the new one.

Why the move isn't a straight lift-and-shift

A Spark's 128 GB is unified memory, shared between CPU and GPU, not a discrete VRAM pool sitting next to system RAM the way a workstation with an RTX card or a cloud instance with a discrete NVIDIA GPU is built. GPUwerk's DGX Spark vs Mac Studio comparison and the memory-bandwidth arithmetic on the benchmarks page cover why that architecture changes the numbers that actually govern serving speed: decode speed is bandwidth-bound, and a Spark's bandwidth figure is not the same as whatever card you're moving off of. Don't assume a model and quantization that ran well on your existing hardware will hit the same tokens per second here; the two boxes are shaped differently even when the total memory number looks similar on paper.

Step 1: re-check quantization for the new memory budget

If you were memory-constrained on your old hardware (for example running a 4-bit build on a 24 GB consumer card because full precision didn't fit), the Spark's 128 GB may open room you didn't have before. Conversely, if your old setup was a multi-GPU cloud instance with more total VRAM than 128 GB, a model that ran at full precision there may not fit on a single Spark at all.

Step 2: move the data before you move the traffic

Model weights, fine-tuned adapters, vector indexes, prompt templates, and any application state need to land on the new instance before you cut traffic over. This is usually the slowest part of a migration, not the model swap itself.

Step 3: validate before cutover

Stand up the new deployment on the Spark, run it against the same eval set or a slice of real traffic, and compare output quality and latency against the old system side by side. This is the point to catch a quantization regression from step 1 or a subtly wrong config from step 2, while the old system is still the one actually serving users.

Check latency characteristics specifically, not just correctness: a Spark's single-stream decode speed and its behavior under concurrent load are governed by the bandwidth and engine arithmetic on GPUwerk's benchmarks page, and those numbers won't match a different GPU architecture even for the same model and similar quantization. If your workload has a latency target, measure it on the new box before you commit to it. Don't assume parity from the spec sheet.

Step 4: cut over deliberately

What doesn't need to change

If your existing deployment already runs behind vLLM or llama.cpp, the serving layer itself is largely the same; GPUwerk's vLLM doc and llama.cpp doc cover Spark-specific setup, but the framework, its API surface, and anything your application built against that API surface should carry over with minimal change. The migration work is concentrated in the memory and quantization layer underneath, not the serving interface above it.

A first engagement can help plan the cutover and validate the eval set before you send real traffic to a new box. If you would rather own the hardware than rent it long term, GPUwerk's GB10 store sells machines from eight makers, and GPUwerk can host yours and rent it out for you.

Validate your migration before you cut traffic over.

Rent a dedicated Spark from $0.79/h, billed by the minute, run it side by side with your existing setup, and cut over on your own schedule. First top-up: pay $20, get $30 in credit.

Create account Read the quantization reference