DigitalOcean vs Vultr for CI/CD Pipelines

Compare DigitalOcean and Vultr for CI/CD: Vultr vc2 pricing, regions, GitHub Actions deploy steps and self-hosted runner setup, with checks.

Published

At a glance

Last reviewed
Versions referenced
actions/checkout@v7 digitalocean/action-doctl@v2
Reading time
5 min read

Code samples are not run in a live repository. See our editorial standards.

On this page

Pick Vultr if you want the cheapest small shared-CPU runner with published per-plan specs, and DigitalOcean if you want a compact region list and first-party doctl tooling in GitHub Actions. Both work well for self-hosted runners and deploy targets. Neither gives you ephemeral runner scaling out of the box.

Compute and pricing

Vultr’s regular Cloud Compute plans (vc2) are the closest match to DigitalOcean’s Basic Droplets with the Regular CPU option. These are the Vultr figures from Vultr’s pricing page as of 2026-10-08:

Vultr plan vCPU RAM Disk Bandwidth Monthly
vc2-1c-0.5gb 1 512 MB 10 GB 512 GB $3.50
vc2-1c-1gb 1 1024 MB 25 GB 1024 GB $5
vc2-1c-2gb 1 2048 MB 55 GB 2048 GB $10
vc2-2c-2gb 2 2048 MB 65 GB 3072 GB $15
vc2-2c-4gb 2 4096 MB 80 GB 3072 GB $20
vc2-4c-8gb 4 8192 MB 160 GB 4096 GB $40
vc2-6c-16gb 6 16384 MB 320 GB 5120 GB $80

Vultr also sells an IPv6-only vc2-1c-0.5gb-v6 at $2.50/month. Skip it for CI: most registries, package mirrors and github.com reachability checks assume IPv4.

For DigitalOcean, take current Basic Droplet prices, disk and transfer from the DigitalOcean Droplet pricing page. Compare plans by vCPU and RAM first, then by included transfer. Don’t assume either vendor has the larger allowance; check the same tier on both pages.

Faster CPUs

Vultr’s High Frequency plans (vhf) cost more than vc2 at the same RAM, but give more disk:

Vultr plan vCPU RAM Disk Bandwidth Monthly
vhf-1c-1gb 1 1024 MB 32 GB 1024 GB $6
vhf-1c-2gb 1 2048 MB 64 GB 2048 GB $12
vhf-2c-2gb 2 2048 MB 80 GB 3072 GB $18
vhf-2c-4gb 2 4096 MB 128 GB 3072 GB $24

DigitalOcean’s Premium CPU options are priced separately; check its pricing page. Benchmark your own build on both before committing, because compile and test times depend on your workload and host load. Shared vCPU plans on either provider can vary run to run.

Sizing a runner

Size by memory first. A runner that hits the OOM killer fails jobs in ways that look like flaky tests.

  • 1 vCPU / 1 GB: linting, small scripts, static site builds.
  • 2 vCPU / 2-4 GB: most Node.js, Python and Go builds with moderate test suites.
  • 4 vCPU / 8 GB: monorepos, parallel test runs, multi-stage Docker builds.

Billing is hourly on both providers, which suits short-lived runners. A powered-off instance still holds its disk and IP, so destroy it rather than stopping it when you no longer need it.

Deploying from GitHub Actions

DigitalOcean

DigitalOcean maintains digitalocean/action-doctl, which installs doctl and authenticates it with an API token. Store the token as the repository secret DIGITALOCEAN_ACCESS_TOKEN.

name: Deploy to DigitalOcean
on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v7

      - name: Install doctl
        uses: digitalocean/action-doctl@v2
        with:
          token: ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}

      - name: Verify doctl authentication
        run: doctl account get

doctl account get prints your account details when the token works and exits non-zero when it doesn’t. For Kubernetes, run doctl kubernetes cluster kubeconfig save <cluster-name> after the install step so later kubectl commands target your DOKS cluster.

Vultr

Vultr’s API accepts a bearer token, so a curl call is the simplest dependency-free check on a GitHub-hosted runner. Generate the key in the Vultr customer portal and store it as VULTR_API_KEY.

name: Deploy to Vultr
on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v7

      - name: Verify Vultr API access
        env:
          VULTR_API_KEY: ${{ secrets.VULTR_API_KEY }}
        run: |
          curl --fail --silent --show-error \
            -H "Authorization: Bearer ${VULTR_API_KEY}" \
            https://api.vultr.com/v2/account

--fail makes the step exit non-zero on an HTTP error, so a bad key fails the job instead of printing an error body and passing. Vultr API keys can be restricted by IP. GitHub-hosted runners use changing addresses, so either leave the allowlist open for this key or deploy from a self-hosted runner with a fixed IP.

Pass secrets through env, as above, rather than interpolating ${{ secrets.* }} directly into the shell script. This keeps the value out of the command text.

Self-hosted runners

Both providers run the standard GitHub Actions runner on a regular VM. The setup is the same on each:

  1. Create the instance with a cloud-init user-data script (DigitalOcean) or a startup script (Vultr).
  2. Have the script download the runner tarball from the actions/runner releases.
  3. Register it with ./config.sh --url <repo-or-org-url> --token <registration-token> --ephemeral.
  4. Install and start it as a service with sudo ./svc.sh install and sudo ./svc.sh start.

The --ephemeral flag makes the runner take one job and then unregister, which avoids state leaking between jobs. Registration tokens expire after a short time, so request one through the GitHub API at provisioning time rather than baking it into an image.

Neither provider offers a managed runner service. To scale runners with demand, run Actions Runner Controller on DigitalOcean Kubernetes (DOKS) or Vultr Kubernetes Engine (VKE), or script instance create and destroy calls yourself with doctl or the Vultr API.

To confirm a runner works, open the repository’s Settings, then Actions, then Runners. The runner should show as Idle. Trigger a job with runs-on: self-hosted and check that it runs on that machine.

Regions

DigitalOcean has 16 datacenters across 13 regions, per its regional availability page (last verified 1 Oct 2026). Droplet slugs: nyc1, nyc2, nyc3, ams3, sfo2, sfo3, sgp1, lon1, fra1, tor1, blr1, syd1, atl1, ric1, mkc1, mem1. ams2 and sfo1 are legacy datacenters with restricted resource creation, so don’t plan new runners there.

Vultr’s location list changes over time. Take the current regions from its locations page or from the API (GET https://api.vultr.com/v2/regions). Place runners in the region closest to your registry, artifact store and deploy target. Cross-region pulls add build time and, depending on the route, count against your transfer allowance.

Decision guide

If you need Choose
Lowest published entry price with 1 GB of RAM Vultr vc2-1c-1gb at $5/month
A first-party GitHub Action for CLI auth and Kubernetes access DigitalOcean (digitalocean/action-doctl)
More disk per dollar at the 2 vCPU / 4 GB tier Vultr vhf-2c-4gb (128 GB)
A fixed, short list of regions DigitalOcean

Verify your choice

Run the same pipeline on one instance size from each provider before committing.

  1. Record wall-clock time for three consecutive runs of the same job on each, since shared CPUs vary.
  2. Watch memory during the heaviest step with free -m or vmstat 5. If swap is in use, move up a size.
  3. Check transfer used against the plan allowance in each provider’s billing or usage page after a week of real pipeline traffic.
  4. Confirm the runner is registered under Settings, then Actions, then Runners, and that the deploy workflow’s authentication step exits with code 0.

Spotted an error? Report it on our Contact page and see our editorial standards for how we correct articles.