Product names, checked against DigitalOcean’s docs on 2026-11-14. Paperspace is part of DigitalOcean and still offers Notebooks, Deployments, Workflows, and Machines through the Paperspace console. “Gradient” still names those Paperspace products and their subscription plans. DigitalOcean’s own AI products are GPU Droplets, Bare Metal GPUs, and Inference (serverless inference, dedicated inference, and Agent Platform). DigitalOcean’s docs list no retirement date for the four Paperspace products. They do state that the legacy Gradient and Core API endpoints are no longer available (so the
gradient CLI no longer works), that Windows templates are unavailable to users who joined after July 1, 2024, and that NVIDIA GRID machines are retired.How Paperspace and DigitalOcean map to Runpod
What’s different
What works differently
VMs become containers. A Paperspace Machine or a GPU Droplet is a virtual machine: you pick an OS image, get a boot disk that persists everything, and can install drivers, runsystemd services, or run Docker yourself. A Pod is a single container that Runpod starts from your Docker image, with the GPU drivers provided by the host. Anything you installed by hand on the VM has to move into a Dockerfile. Runpod runs Docker for you, so you can’t start your own Docker daemon or use Docker Compose inside a Pod.
Only /workspace persists. On a VM the whole boot disk survives a shutdown. On a Pod, the container disk resets when the Pod stops, the volume disk at /workspace survives a stop and is deleted with the Pod, and a network volume outlives the Pod. Keep code, data, and checkpoints under the mounted path, and install system packages in the image.
Stopping and billing. Paperspace bills machine compute only while the machine is powered on, and keeps billing storage and public IPs. DigitalOcean keeps billing a powered-off GPU Droplet until you destroy it. A stopped Pod stops billing compute and keeps billing its volume disk. A Serverless endpoint with zero active workers bills only while workers run. See Pod pricing and Serverless pricing.
Public access. A Machine or Droplet gets a public IP address where every port you open is reachable. A Pod exposes only the ports you list. HTTP ports get a URL of the form https://POD_ID-PORT.proxy.runpod.net, which is public, has no built-in authentication, and closes connections after 100 seconds. TCP ports (such as SSH) get a public IP and a mapped external port that Runpod assigns. Pods support TCP and HTTP, not UDP.
Deployment endpoints. A Paperspace Deployment serves your container at a paperspacegradient.com URL, optionally protected with basic authentication (username paperspace). A Runpod load-balancing endpoint serves your container at https://ENDPOINT_ID.api.runpod.ai and always requires Authorization: Bearer YOUR_API_KEY. A queue-based endpoint uses a different contract: you write a handler function and clients call /run or /runsync with an {"input": {...}} body.
Autoscaling signals. Paperspace Deployments scale between replicas and maxReplicas on CPU, memory, or request duration, using the Kubernetes horizontal pod autoscaler. Runpod endpoints scale between a minimum and maximum worker count on request count (load balancing and queue-based) or queue delay (queue-based only). The minimum is 0 by default, so an endpoint scales to zero and the first request after idle pays a cold start.
Health checks. Paperspace supports liveness, readiness, and startup probes with any 2xx or 3xx code as success. A load-balancing worker has one health path (/ping by default, configurable with HEALTH_CHECK_PATH) where 200 means healthy, 204 means initializing, and anything else means unhealthy.
Model APIs. DigitalOcean serverless inference authenticates with a model access key against https://inference.do-ai.run/v1 and includes commercial third-party models. Runpod Public Endpoints and vLLM endpoints authenticate with your Runpod API key and include the endpoint or model slug in the base URL.
One credential. Paperspace and DigitalOcean use separate credentials (a Paperspace API key, a DigitalOcean personal access token, model access keys, and Spaces keys). Runpod uses one API key for the CLI, REST API, SDK, and endpoint requests, plus a separate S3 API key for the S3-compatible API.
What has no direct equivalent
On Runpod:- Windows machines and desktop streaming. Pods run Linux containers. Keep Windows workloads where they are, or port them to Linux. For interactive work, use JupyterLab, SSH, or an IDE connection.
- A Kubernetes API. DOKS GPU node pools have no Runpod counterpart you can point
kubectlat. Move each workload to the product that fits its shape: a Deployment with a Service to a Serverless endpoint, a Job to@app.taskor a queue-based endpoint, a StatefulSet or long-lived process to a Pod, and tightly coupled multi-node training to an Instant Cluster. To keep a cluster-style scheduler, use the SkyPilot or dstack integration. - VM snapshots and custom OS templates. Rebuild the environment as a Docker image and store its settings in a template.
- A workflow engine. Gradient Workflows runs YAML job graphs with typed inputs and outputs. On Runpod, job order lives in Python (the SDK) or in your CI system.
- Versioned datasets. Paperspace datasets have immutable versions and tags. On a network volume, use versioned directory names, or keep datasets in an object store that supports versioning.
- Object storage buckets with a CDN. The S3-compatible API reads and writes files on a network volume. It isn’t a bucket service with public URLs or a CDN. Keep Spaces for public assets.
- Managed agents, knowledge bases, and commercial model routing. Agent Platform, Knowledge Bases, the Inference Router, and third-party commercial models stay on DigitalOcean or move to another provider.
- Raw block devices. Network volumes mount as a file system. You can’t partition or format them.
- Multiple probe types. Fold readiness and startup logic into the single health path.
- Scale to zero for your own containers. Paperspace
replicasis the floor for a running Deployment, and you stop it by settingenabled: false. - A managed request queue. Queue-based endpoints give you async jobs, status polling, streaming, retries, and webhooks without running a queue yourself.
- Storage that isn’t tied to a region. A global volume (beta) mounts in any data center.
- Ephemeral compute per function call.
@app.taskprovisions a Pod per call and terminates it when the function returns.
Requirements
- A Runpod account with credits, and a Runpod API key.
- Access to your Paperspace team (a Paperspace API key for
pspace) or your DigitalOcean team (a personal access token fordoctl), or both. - Docker on your machine, and a container registry you can push to (Docker Hub, GHCR, or DigitalOcean Container Registry).
- An SSH key pair for Pod access and file transfer.
- For Terraform users: Terraform 1.6 or later.
Step 1: Take inventory of what you run on Paperspace and DigitalOcean
List every resource, record its configuration, and find the code that calls either platform. Use the names from each product’s API, because you’ll map them field by field in later steps.Paperspace
Installpspace and log in with a Paperspace API key, then list the resources it manages. The --json flag is available on every command.
machineType, region, diskSize, templateId, publicIpType, networkId, startupScriptId, and the auto-shutdown settings. Secret values aren’t needed yet, only the names.
Export the full configuration of each Deployment. The response includes the spec (image, port, env, command, instance type, replicas, autoscaling, health checks, and integrations) and the endpoint URL.
https://api.paperspace.com/v1, for example GET /deployments, GET /machines, GET /shared-drives, and GET /datasets, with an Authorization: Bearer header.
pspace has no commands for Notebooks, Workflows, or datasets. For those, use the Paperspace console:
- Notebooks: For each Notebook, record the container image, the workspace repository URL, the machine type, and what you keep in
/notebooks,/storage, and/datasets. - Workflows: Workflow specs live in your repository under
.gradient/workflows. Record each job’sinstance-type, image,inputs,outputs,env, andneeds. - Datasets and models: Record each dataset ID and its storage provider (Gradient-managed or your own S3-compatible bucket).
DigitalOcean
Installdoctl, authenticate with a personal access token, and list GPU resources. doctl compute droplet list returns only non-GPU Droplets unless you pass --gpus.
gpu-h100x1-80gb), the image slug (gpu-h100x1-base, gpu-h100x8-base, gpu-amd-base, a 1-Click Model, or your own snapshot), region, attached volume IDs, VPC, tags, and the user data script. For DOKS, record which node pools use gpu- size slugs and which workloads schedule onto them.
List dedicated inference deployments with the DigitalOcean API:
aws s3 ls --endpoint-url https://nyc3.digitaloceanspaces.com.
Find code that calls either platform
Search your repositories for CLI invocations, hostnames, credentials, and Terraform resources:/notebooks, /storage, /datasets, /inputs, /outputs, /home/paperspace, and Droplet volume mount points under /mnt.
Step 2: Set up Runpod
Create a Runpod account, add credits, and create an API key. Then install the tools you’ll use. Installrunpodctl and configure it. runpodctl doctor sets your API key and an SSH key in one pass.
brew install runpod/runpodctl/runpodctl instead.
Install the Runpod SDK if you’ll migrate Workflows, write Serverless handlers, or call endpoints from Python. It requires Python 3.10 to 3.14 and includes the rp CLI.
rp login stores your key in ~/.runpod/config.toml. The RUNPOD_API_KEY variable is what the REST examples and the Terraform provider in this guide read.
To let a coding agent manage Runpod for you, connect the Runpod MCP server. For infrastructure as code, install the Terraform provider.
Step 3: Choose where each workload lands
Pick a target for each item in your inventory by its shape, not by the product it runs on today.Map your GPUs
Choose a GPU by what the workload needs (VRAM first, then generation), then confirm stock. The Runpod IDs below come from the GPU types reference. Pods take a GPU type ID. Serverless endpoints take a GPU pool ID.
GPU stock varies by data center and changes through the day, so check what’s available before you commit to a type:
Step 4: Move your images and code
Every Runpod target runs alinux/amd64 Docker image. What you do here depends on whether the source is already a container.
Machines and GPU Droplets: turn the VM into an image
Write a Dockerfile that reproduces what you installed on the VM. Start from a Runpod PyTorch image so you get CUDA, SSH, and JupyterLab conventions that the platform already understands.Dockerfile
--break-system-packages. Build for linux/amd64 and push to a registry Runpod can pull from:
--platform flag is required. Without it the image is arm64 and the Pod fails to start.
Translate the rest of the VM setup as follows:
- GPU drivers and CUDA. Don’t install NVIDIA drivers in the image. The host provides them. Your image supplies the CUDA user-space libraries, and you set a CUDA floor when you create the Pod (
--min-cuda-version 12.8) so it lands on a host whose driver supports your image. - Startup scripts and user data. A Paperspace startup script or Droplet
user_data(cloud-init) becomes either Dockerfile steps (for installs) or the container start command (for launching your process). - Docker and Docker Compose on the VM. If the Droplet ran
docker run --gpus all your-image, that image is your Pod image, and thedocker runflags become template fields:-pbecomesports,-ebecomesenv,-vbecomes a volume mount, and the trailing command becomes the start command. For a Compose stack, run one Pod per service and connect them with global networking (NVIDIA GPU Pods only), or combine the services into one image with a process supervisor. systemdservices. A container has one main process. Run your service in the foreground as the start command.- The
paperspaceuser. Paperspace Linux machines provision apaperspaceuser with a home directory at/home/paperspace. Runpod’s SSH examples connect asroot, and persistent data lives in/workspace. Update hardcoded paths. - ML-in-a-Box and the AI/ML-ready image. Both are VM images with a preinstalled stack. The closest starting point is a
runpod/pytorchimage plus your ownrequirements.txt.
Notebooks: reuse the container or switch to the PyTorch template
A Paperspace Notebook already runs in a container (for examplepaperspace/gradient-base), with your files in /notebooks. You have two options:
- Use the official PyTorch template (
runpod-torch-v280), which starts JupyterLab on port 8888 and mounts/workspace. Reinstall your Python packages from arequirements.txtkept in/workspace. This is the shortest path. - Build your own image from
runpod/pytorchwith your packages baked in, as in the Dockerfile above, if you want the environment to survive Pod deletion.
/notebooks, /storage, or /datasets to read from /workspace.
Deployments: keep the image, adjust the health check and port
A Deployment image already serves HTTP, so it can run as a load-balancing worker with configuration changes only. The worker must do two things: listen on the port named by thePORT environment variable, and answer a health check.
If your app already has a readiness route, point Runpod at it with HEALTH_CHECK_PATH instead of changing code. If it has none, add a /ping route. This FastAPI app is the Paperspace health check example adapted for Runpod: it returns 204 while the model loads and 200 when it’s ready.
{"input": {...}} to /run or /runsync instead of calling your paths.
handler.py
pip install runpod and a start command of python -u handler.py. See Handler functions for streaming and async handlers.
Workflows: rewrite the job graph in Python
A Workflow spec declares jobs, their order (needs), and data passed through /inputs and /outputs. With the Runpod SDK, each job becomes a function decorated with @app.task, the order becomes ordinary Python, and shared data moves through a network volume mounted on each task.
needs relationship is now the order of the two .remote() calls, and /outputs/model and /inputs/model are one directory on a shared network volume. Create the secret with rp secret add hf_token before the first run, and check the short GPU names the SDK accepts in SDK GPU types.
Workflows that a GitHub push triggers through the Gradient GitHub App need a new trigger. Run the pipeline from your CI system with rp flash dev main.py --once, which runs the entrypoint once and exits.
Runtime environment variables
Review code that reads platform-injected variables or fixed paths. See the Environment variable map.Step 5: Move your data and models
First decide where each data set lives on Runpod:
Create the network volume:
From a Machine, Droplet, or DigitalOcean Volume: push with the S3-compatible API
The source VM can push straight to the network volume, with no Pod running. Create an S3 API key on the Credentials page (it’s separate from your Runpod API key), then run the AWS CLI on the Machine or Droplet:s3://NETWORK_VOLUME_ID/datasets/a.bin appears at /workspace/datasets/a.bin on a Pod and /runpod-volume/datasets/a.bin on a Serverless worker. aws s3 sync can struggle with more than about 10,000 files, so for directories with many small files, create a tar archive first and copy that with aws s3 cp.
From a Machine or Droplet: push over SSH with rsync
If the data center you chose doesn’t support the S3-compatible API, or you wantrsync semantics, start a Pod with the network volume attached and push over SSH. Register the source VM’s public key with Runpod before you create the Pod, because keys are injected at creation.
runpodctl ssh info prints the host, port, and key to use. rsync needs the direct SSH connection, which is why the Pod exposes 22/tcp and uses an official Runpod image that starts an SSH server. Install rsync on the Pod first (apt update && apt install -y rsync). If runpodctl ssh info reports no public IP, recreate the transfer Pod as a GPU Pod on Secure Cloud. Delete the transfer Pod when the copy finishes.
From a Notebook or a dataset
Open a terminal in the Notebook, where/notebooks, /storage, and mounted datasets under /datasets are all visible, and push to the network volume with the S3-compatible API:
/workspace on the Pod is simpler than copying files.
From Spaces
Spaces is S3-compatible, so you can copy from it with the AWS CLI from inside a Pod that has the network volume mounted. Use a named profile for the Spaces keys so they don’t collide with other credentials.nyc3 with your bucket’s region. Running this inside a Pod writes straight to the volume’s file system. You can also leave data in Spaces and keep reading it from Runpod with the same S3 client code, since only the compute moved.
Models
For Hugging Face models on Serverless, attach the model to the endpoint instead of copying weights: add--model-reference to the runpodctl serverless create command you run in Step 6, as in the example below. Runpod stages it on the host before the worker starts, and it appears under /runpod-volume/huggingface-cache/hub/. This replaces a Paperspace Deployment git-lfs integration that clones a Hugging Face URL into /models.
Step 6: Deploy on Runpod
Deploy a Pod (from a Machine or GPU Droplet)
Create the Pod from your image with the GPU, storage, and ports from your inventory. This is the equivalent ofpspace machine create or doctl compute droplet create.
--network-volume-id with --volume-in-gb 500 (REST: "mounts": {"persistent": {"size": 500, "path": "/workspace"}}). A volume disk is tied to the Pod’s host and is deleted with the Pod, so use a network volume for data you can’t recreate. In the console, the same flow is Pods, then Deploy.
Wait for the Pod and connect:
runpodctl pod get reports runtimeStatus: running when the container is up. HTTP ports are at https://POD_ID-8888.proxy.runpod.net.
Deploy a notebook Pod (from a Notebook)
Create a Pod from the official PyTorch template and setJUPYTER_PASSWORD, which the template uses as the JupyterLab token. JupyterLab starts only when that variable is set.
https://POD_ID-8888.proxy.runpod.net and enter the token. Deploying the same template from the console sets the token for you. Stop the Pod when you finish a session (runpodctl pod stop POD_ID) and start it again later (runpodctl pod start POD_ID): /workspace is kept, and packages installed outside /workspace are not.
Deploy a load-balancing endpoint (from a Deployment)
Create the endpoint with REST API v2. The endpoint type is set at creation and can’t change later.runpodctl serverless create creates queue-based endpoints, so use REST, Terraform, or the console for load balancing.
requestUrls.base (https://ENDPOINT_ID.api.runpod.ai) and requestUrls.health. Set both PORT and PORT_HEALTH to your server’s port and list the same port in ports: each defaults to 80 on its own, and a mismatch leaves the worker unhealthy. {{ RUNPOD_SECRET_hf_token }} reads a Runpod secret named hf_token, which you create in the console or with POST /v2/account/secrets. This request sets HEALTH_CHECK_PATH to /ping, so it needs the image rebuilt with the /ping route from Step 4. An unchanged Paperspace image has no /ping route, and its workers never become healthy. Load-balancing endpoints scale on REQUEST_COUNT only. workers.min of 0 scales to zero. Set it to 1 or more to keep warm workers, which is the closest match to Paperspace replicas. In the console, the same flow is Serverless, then New Endpoint.
Deploy a queue-based endpoint (from a Deployment or a fan-out Workflow)
Create a Serverless template for the handler image, then an endpoint from it. A Serverless template binds to one endpoint.--scale-by delay adds workers when requests wait longer than the threshold in seconds. --scale-by requests scales on pending request count. You can also deploy a handler straight from a repository with the GitHub integration, which builds the image for you.
Deploy a vLLM endpoint (from serverless inference, dedicated inference, or a 1-Click Model)
Deploy the vLLM worker from the Hub with the Hugging Face model you served on DigitalOcean:--gpu-id. For gated models, set a Hugging Face token as described in Get started with vLLM. If Runpod already hosts the model as a Public Endpoint, there’s nothing to deploy: go to Step 7.
Deploy an SDK app (from a Workflow)
Run the pipeline from Step 4 in a dev session, then deploy any@app.queue or @app.api resources in the app as production endpoints:
.spawn() keeps running and billing until it finishes if your script exits without waiting on it.
Step 7: Update the code that calls Paperspace and DigitalOcean
Deployment clients
For a load-balancing endpoint, change the base URL and the auth header. Paths and bodies stay the same.input and choose sync or async:
client.py
POST https://api.runpod.ai/v2/ENDPOINT_ID/runsync and POST https://api.runpod.ai/v2/ENDPOINT_ID/run with Authorization: Bearer YOUR_API_KEY, then GET /status/JOB_ID. Results come back under output. To get a callback instead of polling, add "webhook": "https://your-app.example.com/hook" next to input. See Send requests.
OpenAI-compatible clients
If you call DigitalOcean serverless inference with the OpenAI SDK, swap the base URL, the key, and the model name./chat/completions, /completions, and /models. If your code uses DigitalOcean’s /v1/responses, /v1/messages, /v1/embeddings, image, audio, or video routes, check OpenAI compatibility and the Public Endpoints reference for what’s available before you cut over. Calls made through PyDo (client.chat.completions.create on a pydo.Client) need to move to the OpenAI SDK or runpod.Endpoint.
Dedicated inference clients change the same way: replace the do-infra.ai endpoint URL and its access token with the vLLM base URL and your Runpod API key. A private dedicated inference endpoint that you reach over a VPC with a CA certificate becomes a public HTTPS URL authenticated by API key. 1-Click Models serve the Hugging Face TGI API, so clients that call TGI-specific routes need to switch to the OpenAI-compatible routes.
Control-plane automation
Replace scripts that callpspace, doctl, the Paperspace API, or the DigitalOcean API with runpodctl or REST API v2. The full maps are in the Reference section. The pattern is the same throughout:
runpodctl and a Pod-scoped API key preinstalled, so a job can stop its own Pod when it finishes: end your script with runpodctl pod stop $RUNPOD_POD_ID.
Step 8: Verify, cut over, and shut down
1
Send a real request from outside
Call each new endpoint from the same network your production clients use, with production-shaped inputs. For a load-balancing endpoint:For a queue-based endpoint, check
https://api.runpod.ai/v2/ENDPOINT_ID/health and send a /runsync request. For a Pod, open the proxy URL and run nvidia-smi over SSH.2
Compare outputs and latency
Send the same inputs to the old and new deployments and compare results. Measure a cold request (after the endpoint has scaled to zero) and a warm one separately. If cold starts are too slow for your traffic, set a minimum worker count above 0, use cached models, or move weights from download-at-start to a network volume.
3
Run both in parallel and shift traffic
Keep the Paperspace or DigitalOcean deployment live. Route a small share of traffic to Runpod, watch error rates and logs, then increase the share. Keep the old deployment until you’ve run a full traffic cycle on Runpod.
4
Confirm your data
Verify file counts and checksums on the network volume before you delete any source disk, shared drive, dataset, or bucket. Paperspace snapshots are deleted when their machine is deactivated, so copy anything you need first.
5
Shut down Paperspace
Powering off a machine stops compute billing but storage, public IPs, snapshots, and templates keep billing until you delete them.Deleting a machine (Paperspace calls this deactivating) permanently removes the machine, its files, and its snapshots, and the machine must be off first, so wait for
pspace machine get MACHINE_ID to show it as off before you delete it. Delete Notebooks, Workflows, and datasets in the Paperspace console, and review your Gradient subscription plan there. Run pspace public-ip release --help and pspace snapshot delete --help for the exact arguments.6
Shut down DigitalOcean
A powered-off GPU Droplet still bills. Destroy it, and remove the volumes and snapshots that the destroy leaves behind.Droplet backups stay until their retention period ends. Delete Spaces buckets and model access keys in the Control Panel once nothing reads them. Revoke the Paperspace API keys and DigitalOcean tokens you created for the migration.
7
Guard costs on Runpod
Delete transfer Pods and stop development Pods you aren’t using (
runpodctl pod list --all). Network volumes bill until you delete them, including ones the SDK creates for you such as pipeline-artifacts (runpodctl network-volume list). Keep endpoint minimum workers at 0 unless you need warm capacity, and set an idle timeout that fits your traffic. Review spend with runpodctl billing pods and runpodctl billing serverless, and turn on low balance notifications. When your balance reaches zero, Pods with a network volume are stopped, and Pods without one are terminated and their volume disk data can’t be recovered.Migrate your Terraform
DigitalOcean resources are managed with thedigitalocean/digitalocean provider. The Runpod provider (runpod/runpod, version 2.x) is built on REST API v2 and reads RUNPOD_API_KEY from the environment. Paperspace resources aren’t covered by the digitalocean provider, so recreate them from the inventory in Step 1. If your configuration uses the community Paperspace/paperspace provider, map paperspace_machine to runpod_pod the same way as digitalocean_droplet, and move paperspace_script contents into the image or the start command.
The following example replaces a GPU Droplet with an attached volume.
setup.sh user data script has no direct counterpart: its install steps move into the Docker image. Changing gpu_type_id, gpu_count, cloud, or data_center_ids replaces the Pod, so keep data on the network volume. For a Deployment or DOKS inference service, use runpod_serverless_endpoint with endpoint_type = "LOAD_BALANCER" or "QUEUE", gpu_pools, scaling_type, scaling_value, workers_min, and workers_max. For every argument, see the provider reference.
Migrate in two applies: create the Runpod resources alongside the DigitalOcean ones, cut over, then remove the digitalocean_ resources and run terraform apply again to destroy them.
Reference
CLI command map
Run
runpodctl COMMAND --help for current flags.
API map
All three APIs authenticate with
Authorization: Bearer. Requests to deployed endpoints go to a different host than the management API: https://api.runpod.ai/v2/ENDPOINT_ID for queue-based endpoints and https://ENDPOINT_ID.api.runpod.ai for load balancing.
Configuration field map
Environment variable map
Status map
Queue-based jobs report
IN_QUEUE, IN_PROGRESS, COMPLETED, FAILED, CANCELLED, or TIMED_OUT. See Job states.
Migrate with a coding agent
A coding agent can run the inventory, propose a plan, and perform the migration with the Runpod skills and MCP server.1
Install the Runpod skills and MCP server
- Claude Code
- Other agents
The plugin also connects the hosted MCP server.
2
Give the agent the migration prompt
Run your agent in the repository that contains your application code and infrastructure files, and paste this prompt:
Troubleshooting
The Pod starts but files I saved are gone after a stop. On a VM the whole disk persists. On a Pod only the volume mount does. Move the files to/workspace, and install system packages in the image instead of at runtime.
JupyterLab returns a 502 on port 8888. The official PyTorch template starts JupyterLab only when JUPYTER_PASSWORD is set. Pods created from the console get it automatically. With runpodctl pod create, pass --env '{"JUPYTER_PASSWORD":"CHOOSE_A_TOKEN"}'. See Troubleshooting 502 errors.
The container fails with a CUDA or driver error. A VM image carries its own driver. A Pod uses the host’s, and hosts differ. Set a CUDA floor that matches your image (--min-cuda-version on runpodctl, gpu.minCudaVersion in REST, min_cuda_version in Terraform), and remove any driver installation from your Dockerfile.
exec format error when the Pod or worker starts. The image was built for arm64. Rebuild with docker buildx build --platform linux/amd64.
The load-balancing endpoint returns 502 and workers never become healthy. The server isn’t listening where Runpod is checking. Set PORT and PORT_HEALTH to the port your server binds, list that port in ports, bind to 0.0.0.0, and make sure the health path returns 200. A readiness route that returns 503 while loading keeps the worker unhealthy: return 204 instead.
Requests that worked on a Deployment now time out. Load-balancing endpoints cap each request at 5.5 minutes and 30 MB, and the Pod HTTP proxy closes connections after 100 seconds. Move long requests to a queue-based endpoint and poll or use a webhook, or expose a TCP port on a Pod.
Clients get 401 after the cutover. Paperspace protected endpoints use basic authentication with the username paperspace. Runpod endpoints require Authorization: Bearer YOUR_API_KEY. For OpenAI-compatible clients, replace the model access key with your Runpod API key.
The first request after idle is slow or fails. The endpoint scaled to zero and is cold starting. Retry with a delay on the client, raise workers.min, enable FlashBoot, or use cached models so weights don’t download on every cold start.
runpodctl pod create fails for lack of capacity. The GPU type has no stock in the data center your network volume pins you to. Check runpodctl gpu list, try another GPU type with the same VRAM, or create the volume in a data center that has stock for that GPU.
aws s3 sync to the network volume stalls or errors. The S3-compatible API handles cp, ls, mv, and rm well, and sync can have trouble past about 10,000 files. Archive small files into a tar first. Also check that --region is the data center ID, that the endpoint URL matches it, and that no old AWS_ACCESS_KEY_ID environment variable is overriding the Runpod S3 API key.
Next steps
Choose a Pod
Size GPU, memory, and storage for a workload.
Load-balancing endpoints
Serve your own HTTP server with autoscaling workers.
Network volumes
Share persistent storage across Pods and endpoints.
Terraform provider
Manage Runpod infrastructure as code.