How to Choose a Hosting Provider for GitHub Actions Deploys
Choose a hosting provider for GitHub Actions deploys by comparing PaaS and VPS on deployment effort, cost predictability and environment control.
At a glance
- Last reviewed
- Versions referenced
actions/checkout@v7appleboy/[email protected]- Reading time
- 5 min read
Code samples are not run in a live repository. See our editorial standards.
On this page
Pick a PaaS (Render, Fly.io, Heroku, Railway) if your app runs on a standard runtime and you want the provider to own patching, TLS, and rollouts. Pick a VPS (DigitalOcean, Hetzner, Vultr, Linode) if you need root access, custom system packages, or a fixed monthly bill. GitHub Actions can deploy to either, because a workflow only needs a host it can reach.
GitHub Actions is a CI/CD platform and doesn’t require you to serve an app itself, so the deployment target is your decision. The four factors below decide it: deployment complexity, cost predictability, environment control, and runner network access.
Decision table
| Factor | PaaS | VPS |
|---|---|---|
| Deploy step | Provider CLI or webhook | SSH, rsync, or container pull |
| OS patching, TLS, rollouts | Provider | You |
| Root access, custom packages | No (unless custom Dockerfiles are supported) | Yes |
| Billing | Usage-based or tiered, can vary | Fixed instance price |
| Lock-in | Provider CLI and config format | Generic tools, easy to migrate |
| Private network targets | Depends on provider | Fully configurable |
Avoid a PaaS if you need kernel tuning, unsupported background daemons, or full control of the OS for compliance. Avoid a VPS if nobody on the team will own patching, firewalls, and backups.
Deployment complexity
A PaaS deploy is usually one CLI call, because the platform handles runtime provisioning, routing, and process supervision. The following workflow deploys to Fly.io:
name: Deploy to PaaS
on:
push:
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
environment: production
steps:
- name: Checkout code
uses: actions/checkout@v7
- name: Set up flyctl
uses: superfly/flyctl-actions/setup-flyctl@master
- name: Deploy application
run: flyctl deploy --remote-only
env:
FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
--remote-only builds the image on Fly.io’s builders instead of the runner. Store the token as a repository or environment secret, never in the workflow file.
A VPS deploy makes you own the host: SSH keys, a container runtime, systemd units or Docker Compose, a reverse proxy such as Nginx or Caddy, and firewall rules. This workflow deploys over SSH:
name: Deploy to VPS
on:
push:
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
environment: production
steps:
- name: Checkout code
uses: actions/checkout@v7
- name: Run remote deployment commands
uses: appleboy/[email protected]
with:
host: ${{ secrets.VPS_HOST }}
username: ${{ secrets.VPS_USER }}
key: ${{ secrets.VPS_SSH_KEY }}
script_stop: true
script: |
cd /opt/app
git pull origin main
docker compose up -d --build
script_stop: true stops the script at the first failing command, so a failed git pull doesn’t proceed to a rebuild. Use a dedicated deploy key with access to one host, not a personal key.
Day-two work
- Zero-downtime updates: PaaS platforms typically run health checks and replace instances gradually. On a VPS you build this yourself with blue/green containers or Nginx upstreams.
- TLS certificates: PaaS platforms usually issue and renew them. On a VPS, run Certbot or let Caddy manage renewals.
- Logs: PaaS platforms expose logs through a dashboard or CLI. On a VPS, configure
logrotate, watch disk usage, and ship logs to a collector yourself.
To gate production on either target, create a GitHub Environment (Settings → Environments) and add required reviewers or a wait timer. These rules control who can trigger a deploy and when. They don’t change what the target server allows.
Cost predictability
A VPS gives you a stable invoice, while a PaaS bill follows usage. The trade-off moves risk: on a VPS, overload means dropped requests or exhausted memory. On a PaaS, overload means a larger bill.
- VPS: You pay a fixed rate for vCPU, RAM, and storage whether the server is idle or busy. Most plans include an outbound transfer allowance. Extra volumes and static IPs carry their own fixed fees.
- PaaS: Costs commonly include per-instance runtime, egress above a free allocation, separately billed databases and disks, and in some cases build minutes. Autoscaling multiplies compute cost during traffic spikes.
Before committing, check the provider’s current pricing page for egress rates, build-minute metering, and what the base tier includes. Set spending alerts or hard caps where the provider offers them. Pricing changes often, so don’t rely on figures copied from articles.
Builds on a VPS target run on your GitHub Actions runners, so they count against your GitHub Actions minutes, not the host’s.
Control over the environment
A VPS gives you root on the OS, kernel, and network stack. A PaaS limits you to what it exposes: environment variables, build arguments, and its config files.
Check these against your app before choosing:
- System libraries or compilers missing from the platform’s runtime.
- Inbound ports other than the HTTP(S) port the platform routes.
- Custom firewall rules, VPN endpoints, or kernel parameters.
- Audit requirements that demand direct OS control.
If a PaaS supports custom Dockerfiles, it covers most package needs without a VPS. If your list includes kernel or network requirements, use a VPS.
On a VPS, the workflow does not manage the server for you. Patching, certificate rotation, and backups stay your responsibility unless you script them.
Runner network access and security
Check whether your target is reachable from the internet before choosing a runner. Traffic from GitHub-hosted runners comes from a wide range of network addresses. If your company restricts external traffic into private networks, workflows on GitHub-hosted runners may not reach internal services.
For internal targets, host your own runners inside that network. Self-hosted runners come with security obligations:
- They don’t run in ephemeral, clean virtual machines, so untrusted workflow code can persistently compromise them.
- A compromised runner defined at the organization or enterprise level can affect many repositories, because GitHub can schedule workflows from multiple repositories onto it.
- Put runners in separate runner groups for production, staging, and development. Restrict which repositories and organizations can use each group.
- Treat the runner machine as production infrastructure: audit its logs and keep it patched.
- Don’t use self-hosted runners with workflows triggered by untrusted code, such as pull requests from forks of public repositories.
If you can’t guarantee the runner’s integrity, deploy to publicly reachable hosts from GitHub-hosted runners instead.
Verify your choice before migrating
Run a trial deploy on your shortlisted provider before committing.
- Deploy a throwaway branch through a GitHub Environment with a required reviewer, and confirm the job waits for approval.
- Check that the workflow fails when the deploy fails. For SSH deploys, break a command deliberately and confirm the job turns red.
- Roll back once. Time how long it takes and note whether it needs manual steps.
- Compare the first invoice or usage dashboard against your estimate.
Spotted an error? Report it on our Contact page and see our editorial standards for how we correct articles.