velda.io

Velda reduces GPU compute costs by provisioning compute only while your jobs are actually running. According to the site, you "pay only for compute when your jobs run, not during development or between workloads." That means coding time, breaks, and idle gaps between jobs don't consume GPU capacity or budget. This model fits individuals and small teams using Velda Cloud, as well as organizations running self-hosted or dedicated infrastructure through Velda Enterprise.

The core mechanism: compute follows the job, not the developer

Traditional setups keep a GPU attached to a development machine or a cluster node whether or not work is executing. Velda inverts that: the compute resource is provisioned when a job runs and released when it finishes.

The site's comparison makes the distinction explicit:

The result the site describes is "utilized compute" under Velda versus "underutilized compute" on a traditional dev machine. The saving comes from eliminating the idle windows, not from a discount on the GPU rate itself.

Why idle time is the cost driver

Two idle patterns typically inflate GPU spend:

1. Development and coding time. Writing, debugging, and iterating don't need a GPU, but a dedicated workstation or reserved node holds one anyway.
2. Gaps between workloads. After a training run or inference job ends, the hardware stays reserved until the next job starts.

Velda's model targets both. The site states you "provision the compute resource when the jobs are running, not during coding, with no setup overhead." It also frames the benefit as avoiding GPUs "wasted on idle time or setup."

No need for a high-end local workstation

Because compute is provisioned on demand, you don't have to buy or maintain a powerful local machine to run heavy workloads. The site lists this directly: "Access powerful compute on demand — no need for high-end workstations."

This shifts cost from a capital purchase (a GPU workstation that sits idle much of the time) to usage-based consumption tied to actual job runtime. For workloads that are intermittent rather than continuous, that difference is the main lever on total spend.

What workloads this applies to

The cost behavior applies across the workload types Velda lists:

• Training jobs
• Inference and serving
• Data pipelines

The site describes running "training, serving, or data pipelines with a simple vrun prefix, for any workload." The same provisioning logic applies to each: compute exists while the job runs.

How to start reducing cost

1. Confirm your workload is intermittent. The savings come from idle gaps. If a job runs continuously, the advantage is smaller.
2. Run jobs with the vrun prefix instead of reserving a machine. The site's example is vrun -P h200-1 python train.py, which runs a training script on an H200 resource.
3. Develop without holding a GPU. Use the browser-based VS Code or connect your preferred IDE, then provision compute only when you launch a job.
4. Choose the deployment that matches your scale. Velda Cloud is described as a managed cloud with instant VS Code and GPU access plus a free monthly credit, aimed at individuals and small teams. Velda Enterprise covers self-hosted or dedicated infrastructure with premium support.

What to verify before committing

The site does not publish per-GPU rates or billing granularity in the material available here, so treat the pricing page as the place to confirm:

• The exact billing unit (per second, per minute, or otherwise)
• Whether the free monthly credit applies to your usage level
• Which GPU types are available and at what cost

The cost-reduction claim itself rests on one verifiable behavior: compute is provisioned during job execution and not during development or between workloads. If your usage pattern has significant idle time, that is where the savings come from.

Velda is a serverless GPU cloud for AI workloads. It lets you run training, inference, serving, and data pipeline jobs by prefixing a command with vrun, without building container images or managing a cluster. You pay for compute only while jobs run, not during development or between workloads. It fits individuals and small teams through Velda Cloud, and larger organizations through self-hosted or dedicated enterprise infrastructure.

How Velda works

The core mechanism is the vrun prefix. Instead of packaging your code into an image and submitting it through a cluster scheduler, you take a command you would run locally and prefix it:

vrun -P h200-1 python train.py

The -P h200-1 selects the compute profile (here, an H200 GPU), and the rest is your normal command. According to the site, this means:

• No image builds
• No manifests
• No dependency drift
• Your local development experience, with access to remote compute

The job runs from your cloud or cluster, and the compute resource is provisioned when the job runs rather than held during coding.

What you can run

Velda positions itself around AI workloads broadly:

The site also lists a "Slurm Alternative" page, indicating Velda targets teams currently using cluster schedulers like Slurm.

Development environment

Velda provides a browser-based VS Code option, or you can connect with your preferred IDE. Prebuilt templates are available to start quickly — the site shows a PyTorch ML template with base dependencies such as torch==1.12.1, pandas==1.4.2, and matplotlib==3.5.2. You can then tailor the environment to your workflow.

The cost model

The stated billing principle is: pay only for compute when your jobs run. The site contrasts this with a traditional dev machine, where compute sits idle during coding and breaks, and with Kubernetes/cluster setups that add management overhead. Velda's claim is that compute is utilized during heavy workloads and not underutilized between them.

Velda Cloud is described as including a free monthly credit. Specific pricing figures are not given in the available page content — check velda.io/pricing for current numbers.

Deployment options

• Velda Cloud — managed cloud with instant VS Code and GPU access, plus free monthly credit. Aimed at individuals and small teams.
• Enterprise — self-hosted or dedicated infrastructure with premium support, for organizations of any size.

When Velda is a good fit

Choose Velda if you want to run GPU jobs from your existing dev environment without writing Dockerfiles or managing cluster infrastructure, and if your workloads are bursty enough that paying only during execution matters. Consider the enterprise option if you need self-hosting or dedicated hardware. If you already have a well-tuned Slurm or Kubernetes setup and don't mind its overhead, the comparison pages on the site are the place to check whether the tradeoffs favor switching.

Velda offers two deployment options: Velda Cloud, a managed cloud with instant VS Code and GPU access plus a free monthly credit, suited to individuals and small teams; and Enterprise, which runs on self-hosted or dedicated infrastructure with premium support for organizations of any size. You can start on Cloud by signing up, or talk to the team for Enterprise. Both paths use the same core workflow — prefixing a command with vrun to run it on cloud or cluster GPUs.

Velda Cloud

The managed option. According to Velda, it includes instant VS Code + GPU access and a free monthly credit, and is positioned for individual users and small teams.

Getting started:

1. Sign up from the site (a Sign-up link sits in the main navigation).
2. Launch VS Code in your browser, or connect with your preferred IDE.
3. Start from a prebuilt template — for example the PyTorch ML template with torch==1.12.1, pandas==1.4.2, and matplotlib==3.5.2 — then tailor dependencies to your workflow.
4. Run a job by prefixing your command with vrun, e.g. vrun -P h200-1 python train.py.

Expected result: your command runs on Velda's compute rather than your local machine, without image builds, manifests, or cluster setup.

Enterprise

Self-hosted or dedicated infrastructure with premium support, for organizations of any size. The stated entry path is to book a demo rather than self-serve sign-up. Use this route if you need your own infrastructure or organizational support terms.

Choosing between them

The workflow both options share

Velda's core idea is the vrun prefix: put it in front of any command to run that command from your cloud or cluster. The page's example is:

vrun -P h200-1 python train.py

The -P h200-1 flag selects the compute profile in that example. No image builds, no manifests, no dependency drift — your local development experience is preserved while the compute runs remotely. The same prefix is described as working for training, serving, or data pipelines, and for scaling from a CPU head node to H200 worker nodes.

Cost model to be aware of

Velda states you pay only for compute while your jobs run — not during development or between workloads. The page contrasts this with a traditional dev machine, where compute sits idle during coding and breaks, and with running workloads on Kubernetes or a cluster. This is the mechanism behind the "save on compute" claim: provisioning happens when jobs run, not while you code.

Where to go next

• Pricing — the site links a Pricing page for plan details.
• Docs — for setup and command reference.
• Blog — for background and comparisons.
• Talk to the team / Schedule a call — for Enterprise or questions before signing up.

If you want to try the workflow immediately, sign up for Velda Cloud and run a vrun command from your IDE. If you need your own infrastructure or organizational support, book a demo instead.

Velda is a serverless GPU cloud that replaces the container-image and cluster-management overhead of Slurm and Kubernetes with a single command prefix: vrun. You prefix any command with vrun and it runs on cloud or cluster GPUs — no image builds, no manifests, no dependency drift — and you pay only for compute while jobs run, not during development or between workloads. It fits teams that want to keep their local development experience while scaling AI training, inference, and data pipelines without operating a scheduler.

The core difference: job submission vs. command prefix

Traditional clusters require you to package and schedule work before it runs. Velda collapses that into one step.

The practical consequence: with Slurm or Kubernetes, a meaningful share of effort goes into getting the job to run (images, manifests, scheduling config). With Velda, that effort shifts to the command itself.

What vrun actually replaces

Velda's own framing is "vrun is all you need" — prefix any command to instantly run from your cloud or cluster. The documented example is:

vrun -P h200-1 python train.py

Here the input is your existing local command (python train.py), the action is prefixing it with vrun plus a resource profile (-P h200-1), and the expected result is that the job runs on an H200 GPU without you building an image or writing a manifest. In a Slurm or Kubernetes setup, the equivalent work would be a batch script with resource directives or a pod spec with node selectors and resource requests — plus the image build and push that precedes it.

This is the mechanism behind Velda's cost claim: because there is no image-build step and no always-on cluster to maintain, GPUs are provisioned when jobs run rather than during coding, breaks, or idle periods between workloads.

Where the two approaches diverge in practice

Development environment

Velda lets you launch VS Code in the browser or connect with your preferred IDE, starting from prebuilt templates (for example, a PyTorch ML template with pinned dependencies like torch==1.12.1, pandas==1.4.2, matplotlib==3.5.2) and then tailoring them. On a Slurm or Kubernetes cluster, the development environment is typically separate from the execution environment, which is where dependency drift between "works on my machine" and "works on the cluster" originates.

Scaling model

Velda describes a CPU head node with GPU worker nodes and scaling "in seconds" for training, serving, or data pipelines using the same vrun prefix. A Kubernetes or Slurm cluster can reach the same scale, but scaling is a cluster operation you configure and maintain rather than a property of the command you already ran.

Cost behavior

Velda's comparison graphic contrasts "utilized compute" against "underutilized compute": running a heavy workload directly versus processing data via multi-processing on a single machine or distributing it across a cluster. The stated model is on-demand provisioning — compute is provisioned when jobs run, not while coding — which is the structural reason idle time stops being billed.

When Velda is the better fit

• You want to run AI workloads from your existing dev environment without learning a scheduler or writing manifests.
• Your team is small or individual-focused and does not want to operate cluster infrastructure.
• Your workloads are bursty — training, inference, and data pipelines that would leave provisioned nodes idle between runs.
• You want development and scaling on one platform to avoid environment switching.

Velda offers a managed cloud with instant VS Code + GPU access and a free monthly credit, positioned for individuals and small teams, plus an enterprise option (self-hosted or dedicated infrastructure with premium support).

When a Slurm or Kubernetes cluster is the better fit

• You already run a cluster and have sunk cost and operational expertise in it.
• You need self-hosted or dedicated infrastructure with organizational controls — Velda addresses this through its enterprise offering rather than the managed cloud.
• Your workloads are long-running and steady enough that provisioned nodes stay busy, reducing the idle-time advantage.
• You require cluster-level customization that a command-prefix model does not expose.

The decision rule: if the bottleneck is operating the cluster, Velda removes that layer; if the bottleneck is controlling the infrastructure, a cluster you already run may still be the right call. For pricing specifics and current plan details, check Velda's pricing page, since the source material does not state figures.

vrun is Velda's single entry point for running a command on cloud or cluster compute. You prefix any command with vrun, and Velda executes it remotely instead of on your local machine — for example, vrun -P h200-1 python train.py runs that training script on an H200 GPU. The point is that you keep your local development workflow (your editor, your files, your dependencies) while the actual compute happens elsewhere. There are no image builds, no manifests, and no dependency drift to manage.

What vrun actually does

Velda describes vrun as "all you need" — the entire interface is a prefix. When you type:

vrun -P h200-1 python train.py

you are telling Velda to take the command that follows (python train.py) and run it on a resource described by the flags (-P h200-1, i.e. an H200 GPU instance). The command itself is unchanged; only where it runs changes.

This matters because it removes the usual steps between writing code and using remote hardware:

• No image builds. You don't package your environment into a container first.
• No manifests. You don't write YAML or cluster config to describe the job.
• No dependency drift. Because you run from your dev environment, the dependencies you developed against are the ones that execute.

How to use it

1. Develop locally as usual. Write and test your script in your normal environment — Velda's templates include options like a PyTorch ML template with torch, pandas, and matplotlib preinstalled, or you can tailor your own.
2. Prefix the command with vrun. Take the exact command you'd run locally and put vrun in front of it.
3. Specify the compute with flags. -P h200-1 selects the target resource. The example in Velda's docs uses an H200 GPU; the platform also shows CPU head nodes and worker nodes for scaling.
4. Run it. The command executes on Velda's compute rather than your machine, and you get the result back in your dev loop.

The expected result is that a workload which would be too heavy for your local machine — training, inference, data pipelines — runs on provisioned GPU or cluster resources without you leaving your editor.

Why the prefix model matters

The design choice is deliberate: Velda provisions compute while jobs are running, not while you're coding. The site contrasts this with a traditional dev machine, where a high-end workstation sits idle during breaks and coding, and with Kubernetes/cluster setups that add container and manifest overhead. With vrun, the same local workflow scales from a single command to distributed work, and you pay for compute when jobs run rather than during development or between workloads.

Practical notes

• IDE flexibility. You can launch VS Code in the browser or connect your preferred IDE, so vrun fits into whichever environment you already use.
• Templates as a starting point. Prebuilt templates (e.g. the PyTorch ML template) let you start instantly, then customize.
• Scope of workloads. Velda positions vrun for training, serving, and data pipelines — anything you'd otherwise run on a GPU box or cluster.
• Pricing and access. Velda lists a Pricing page and mentions a free monthly credit for its managed cloud tier, plus self-hosted/enterprise options. Check the pricing page for current terms rather than assuming a free tier covers your usage.

If your goal is to run a heavy command without rebuilding your environment or writing cluster config, vrun is the mechanism: prefix, target, run.