---
description: "A working starting point for each Verda product and the account setup required before any of them."
revision_date: 25.10.2026
---

# Quickstart

Account setup is required before using any product below. Each section is a self-contained walkthrough, enough to get the thing running without leaving this page. For the full walkthrough, follow the link at the end of each section to that product's own dedicated page.

## Account setup

1. **Create your account.** Go to [console.verda.com/signin](https://console.verda.com/signin), fill in the registration form, and click **Create account**. Check your email and verify your address, then log in to the console.
2. **Add funds.** In the dashboard, open **Billing & settings**. Under **Add funds to your project balance**, enter an amount, add a payment method, and click **Save billing details**, then **Complete payment**. (For a bank transfer instead of a card, use **My Account → Bank transfer**.)
3. **Generate a credential.** Open the **Credentials** page from the sidebar. Under **Cloud API credentials**, click **+ Create** and copy the **Client ID** and **Client Secret**. The secret is shown only once, so store it safely. This one pair authenticates the CLI, Terraform, OpenTofu, and integrations like dstack and SkyPilot. For hosted model endpoints, create a key under **Inference API Keys → + Create** instead. Both are tied to the team member who created them and are deleted automatically if that member is removed from the project.

See [Account & access](https://docs.verda.com/account/) for the full account setup guide.


## Instances

Getting a working instance takes three steps: deploy it, add an SSH key so you can reach it, then connect. Steps 1 and 2 can be done in either order.

1. **Create an instance.** On the **Instances** page, click **Deploy Instance** (top right). Then:
    - Choose a contract: **On-demand** (Pay As You Go, billed in 10-minute increments) or **Spot** (cheaper, but can be evicted at any time).
    - Pick a GPU or CPU model, then a size from the card (greyed-out sizes are unavailable). The location is usually selected automatically; any storage you attach must be in that same location.
    - Choose an operating system (Ubuntu, or JupyterLab in various configurations).
    - Optionally add storage (**Add volume** / **Add shared filesystem** / **Add existing storage**) and a startup script.
    - Set a hostname and description (the hostname can't be changed after deployment).
    - Review the order summary and click **Deploy now**.
2. **Add an SSH key.** Generate a key pair on your own machine, then register the public half with Verda:
    - On Linux or macOS, run `ssh-keygen -t ed25519` and view the public key with `cat ~/.ssh/id_ed25519.pub`. On Windows, generate an Ed25519 key in PuttyGen and copy the **Public key** field.
    - In the console, go to **Keys → SSH Keys → Create** and paste the public key. Add it before you deploy and it's authorized on the instance automatically.
3. **Connect.** Copy the SSH login shown on the instance card, then connect with your private key:

    ```bash
    ssh -i /path/to/your/key root@<INSTANCE_IP>
    ```

    Use the username `root` for a standard instance. If your key has a passphrase, you'll be prompted for it.

See [Get started with Instances](https://docs.verda.com/instances/#quickstart) for the full walkthrough.


## Private Networks

!!! warning "Pilot feature"
    Private Networks is in a limited pilot. It is enabled per project and only offered in some datacenters.

A private network gives your project its own private IPv4 address space, so instances talk to each other over addresses that are never routed on the public internet. Networking is chosen when you deploy an instance and can't be changed afterwards.

1. **Create a network.** In the console sidebar, under **Networking**, open **Private networks** and create a network. You can skip this step: if your project has no network, the first deploy that asks for a private address creates one named `default`.
2. **Deploy an instance onto it.** In the deploy form's **Network** step, pick a subnet, or choose **Create new** next to the **Subnet** dropdown and enter an IP range in CIDR notation from a private range, for example `10.0.0.0/24`. Then choose:
    - **Public + Private IP**: the instance gets a private address and a public IPv4, so you can SSH to it directly.
    - **Private IP only**: the instance has no public address and no outbound internet. Reach it through a jump host on the same network that has a public IP.
3. **Connect.** SSH to the public IP as usual. Inside the instance, `ip addr` shows only the private address; the public IP is applied as 1:1 NAT outside the guest.

!!! danger "Plan your access before deploying"
    An instance deployed with a private IP only, into a network with no jump host and no route, is unreachable.

See [Private Networks](https://docs.verda.com/private-networks/) for the full walkthrough.


## Clusters

1. **Deploy an Instant Cluster.** On the **Clusters** page, click **Deploy Cluster** (top right). Then:
    - Choose a contract duration (from one day) and the number of GPUs.
    - Select a job orchestrator (**Kubernetes** or **Slinky**/Slurm), an OS, and a CUDA toolkit.
    - Choose a shared filesystem size. The SFS mounts to `/home` on every node including the jump host; local storage mounts to `/mnt/local_disk` on each worker.
    - Supply your SSH public key and set a hostname (worker nodes inherit it as a prefix), then deploy.
2. **Wait and connect.** Allow around 20 minutes for the cluster to validate; the jump host becomes reachable a few minutes before the workers. The default user is `ubuntu`. Copy the `ssh ubuntu@<CLUSTER_IP>` command from the console to log in to the jump host, and reach a worker from there with `ssh <WORKER_NAME>` (tab-completion works).
3. **Run your first job.** Manage jobs through the orchestrator you chose at deploy time, following its getting-started guide (Kubernetes or Slinky). Deployment and jump-host access use the same SSH basics as Instances.

See [Get started with Clusters](https://docs.verda.com/clusters/#quickstart) for the full walkthrough.


## Serverless Containers

1. **Create a deployment.** Go to **Serverless Containers → New deployment** and give it a name.
2. **Pick a Compute Type** with enough VRAM for the workload.
3. **Set the image.** Point at a public image to start, for example the official vLLM container `docker.io/vllm/vllm-openai`, toggled **Public**. Always use a specific version tag (e.g. `:1.0`); `:latest` is rejected. For a private image, add registry credentials under **Container registries** first.
4. **Configure the port and health check** to match what the container serves on. For vLLM: exposed HTTP port `8000`, health path `/health`.
5. **Deploy**, then generate an inference API key under **Credentials → Inference API Keys** and call the endpoint shown on the deployment page.

See [Serverless Containers](https://docs.verda.com/serverless-containers/quickstart/) for the full walkthrough.


## Storage

Verda has four storage types. Which one you reach for depends mostly on how many machines need to read the data:

- **Block Volumes**: a persistent disk for a single VM, for datasets, checkpoints, or a database beyond the boot disk.
- **Shared Filesystems (SFS)**: a POSIX filesystem several VMs can mount at once, for distributed training or a shared team dataset.
- **Object Storage**: S3-compatible buckets, with sync tooling and presigned URLs.
- **Container Registry**: a private image registry for storing and deploying container images inside Verda.

**For a single VM**, attach a Block Volume (during instance creation, or from the **Storage** page). Once attached it appears as a device such as `/dev/vdb`; format it if it's new, then mount it:

```bash
mkfs.ext4 /dev/vdb                 # new volumes only
mkdir /mnt/data
mount /dev/vdb /mnt/data
echo "/dev/vdb /mnt/data ext4 defaults,nofail 0 0" >> /etc/fstab   # mount on every reboot
```

**For several VMs**, create a Shared Filesystem: on the **Shared filesystems** screen click **Create filesystem**, choose size and region, and share it with the instances that need it. Then mount it on each one (replace `SFS_NAME`, the datacenter `DC`, and the filesystem's `PSEUDO` path):

```bash
mkdir -p /mnt/SFS_NAME
mount -t nfs -o nconnect=16 nfs.DC.verda.com:PSEUDO /mnt/SFS_NAME
```

See [Storage](https://docs.verda.com/storage/quickstart/) for the full walkthrough.
