DPTCloud
Back to articles
Technology Insight

Building a Cost-Effective CI/CD System for Freelancers: GitLab Runner with Docker on a Single VPS

May 18, 2026

Introduction: The Freelancer's CI/CD Challenge

For freelance developers and small teams, establishing a robust Continuous Integration and Continuous Deployment (CI/CD) pipeline often seems like a luxury reserved for larger organizations with dedicated DevOps resources. The perceived complexity, time investment, and cost of cloud-based CI/CD services can be prohibitive. However, in today's competitive market, delivering code quickly, reliably, and with automated testing is no longer optional—it's a fundamental requirement for professional credibility and client satisfaction.

This guide presents a practical, cost-effective solution: building your own CI/CD system using GitLab Runner and Docker on a single Virtual Private Server (VPS). This approach gives you complete control over your build environment, eliminates recurring SaaS fees after the initial VPS cost, and provides a flexible foundation that scales with your freelance business. By the end of this post, you'll have a production-ready pipeline that automatically tests, builds, and deploys your applications.

Why a Self-Hosted GitLab Runner on a VPS?

Before diving into the implementation, let's examine why this architecture is particularly suited for freelancers.

  • Cost Efficiency: A single VPS (e.g., from DigitalOcean, Linode, or Hetzner) costing $5-20 per month replaces potentially expensive minutes on platforms like GitLab.com Shared Runners or GitHub Actions. For multiple projects, the savings compound.
  • Control and Customization: You control the runner's environment, installed software, Docker images, and cache. No more waiting for SaaS providers to support a specific version or tool.
  • Performance and Predictability: Your runner's performance is consistent and isolated from the "noisy neighbor" effect common in shared CI environments. You can tailor the VPS resources (CPU, RAM) to your project's needs.
  • Privacy and Security Sensitive code and environment variables remain on infrastructure you control, which can be crucial for client projects with strict data handling requirements.
  • Learning and Portfolio Value Setting up and maintaining this system deepens your understanding of DevOps practices, a valuable skill you can market to future clients.

Architecture Overview: How It All Fits Together

The system revolves around three core components interacting on your VPS:

  1. GitLab.com (or Self-Hosted GitLab): Hosts your source code repositories. When you push code or create a merge request, GitLab triggers a pipeline.
  2. GitLab Runner: A lightweight, Go-based application installed on your VPS. It listens for new jobs from GitLab, picks them up, and executes them.
  3. Docker: The runner uses Docker to create isolated, ephemeral containers for each job. This ensures a clean, consistent environment for every build and test run, defined by a Dockerfile or image in your project.

The VPS acts as the execution engine. A single runner can handle multiple projects and concurrent jobs (depending on VPS resources), making it a versatile hub for all your freelance work.

Step-by-Step Implementation Guide

1. Provisioning and Securing Your VPS

Start by choosing a VPS provider and selecting a plan. For most freelance web applications, a server with 2-4 GB of RAM, 1-2 vCPUs, and 50-80 GB SSD storage is an excellent starting point. Ubuntu 22.04 LTS or a similar stable Linux distribution is recommended.

Initial server setup is critical:

  • Create a non-root user with sudo privileges.
  • Set up a firewall (UFW) to allow only SSH (port 22), HTTP (80), HTTPS (443), and potentially a custom port for the Docker registry.
  • Enable SSH key authentication and disable password login for enhanced security.
  • Configure automatic security updates.

2. Installing Docker and Docker Compose

Docker is the foundation for your build environments. Install the official Docker Engine and Docker Compose plugin.

Pro Tip: Always install Docker from the official repositories to ensure you receive security updates and the latest stable features.

After installation, add your user to the docker group to run commands without sudo. Remember to log out and back in for this change to take effect. Verify the installation with docker --version and docker compose version.

3. Installing and Registering GitLab Runner

Install the GitLab Runner package following the instructions for your Linux distribution from GitLab's official documentation. Once installed, you need to register the runner with your GitLab instance.

The registration process requires a registration token. For GitLab.com:

  • Go to your project → Settings → CI/CD → Runners.
  • Expand the "Set up a specific runner manually" section to find the token.

Run sudo gitlab-runner register on your VPS. You will be prompted for:

  1. The GitLab instance URL (https://gitlab.com).
  2. The registration token.
  3. A description for the runner (e.g., "Freelance VPS Runner").
  4. Associated tags (e.g., docker, vps, freelance). Tags are powerful; you can assign specific runners to specific jobs in your .gitlab-ci.yml file.
  5. The executor: Choose docker.
  6. The default Docker image (e.g., docker:24 for Docker-in-Docker jobs, or node:20-alpine for a Node.js base).

After registration, start the runner service: sudo gitlab-runner start and ensure it's set to launch on boot: sudo gitlab-runner enable.

4. Configuring the Runner for Optimal Performance

The runner configuration file (/etc/gitlab-runner/config.toml) is key to tuning performance. Important settings for a single-VPS setup:

  • concurrent: Limits how many jobs run simultaneously. Set this to a safe number (e.g., 2-4) based on your VPS resources to prevent out-of-memory errors.
  • check_interval: How often the runner polls GitLab for new jobs (default is 3 seconds).
  • Docker volume mounts: Configure cache and build artifact persistence. Mounting a directory (e.g., /var/lib/gitlab-runner/cache) as a volume allows dependencies (like node_modules or Python packages) to be cached between pipeline runs, dramatically speeding up builds.

Crafting Your .gitlab-ci.yml Pipeline

The pipeline definition lives in your repository root. A basic pipeline for a Node.js application might look like this:

stages:
  - test
  - build
  - deploy

cache:
  key: ${CI_COMMIT_REF_SLUG}
  paths:
    - node_modules/
    - .yarn/

test:
  stage: test
  image: node:20-alpine
  script:
    - npm ci
    - npm run test
    - npm run lint

build:
  stage: build
  image: docker:24
  services:
    - docker:24-dind
  variables:
    DOCKER_TLS_CERTDIR: ""
  script:
    - docker build -t my-app:${CI_COMMIT_SHORT_SHA} .
    - docker save my-app:${CI_COMMIT_SHORT_SHA} > app-image.tar
  artifacts:
    paths:
      - app-image.tar
    expire_in: 1 week

deploy:
  stage: deploy
  image: alpine:latest
  script:
    - apk add --no-cache rsync openssh-client
    - scp -o StrictHostKeyChecking=no app-image.tar user@production-server:/tmp/
    - ssh user@production-server "docker load -i /tmp/app-image.tar && docker-compose up -d"
  only:
    - main

This pipeline demonstrates key concepts: stages for workflow order, caching for speed, Docker-in-Docker (dind) for building images, and artifacts to pass the built image to the deployment stage. The deployment stage uses SSH to transfer and load the image on a production server, then restarts the services via Docker Compose.

Advanced Optimizations and Best Practices

Managing Secrets Securely

Never hardcode passwords or API keys in your .gitlab-ci.yml file. Use GitLab's CI/CD Variables (Project → Settings → CI/CD → Variables). Store secrets like DEPLOY_SSH_PRIVATE_KEY, DOCKER_REGISTRY_PASSWORD, or database URLs here. They are injected as environment variables into your job environments and are masked in logs.

Implementing a Private Docker Registry

For a more polished workflow, deploy a private Docker registry (e.g., registry:2) on your VPS alongside the runner. Instead of saving/loading tarballs, your build job can docker push the image to your private registry, and your production server can docker pull from it. This simplifies deployment and acts as a built image store.

Monitoring and Maintenance

Your VPS is now critical infrastructure. Implement basic monitoring:

  • Use docker system prune in a weekly cron job to clean up unused images, containers, and volumes to prevent disk fill-up.
  • Monitor disk space, CPU, and memory usage. Simple tools like glances or a cron script that emails you alerts can suffice.
  • Regularly update the VPS OS, Docker, and GitLab Runner software to apply security patches.

Conclusion: Empowering Your Freelance Workflow

Building your own CI/CD system with GitLab Runner and Docker on a VPS is a powerful investment in your freelance development practice. It moves you from a manual, error-prone deployment process to an automated, professional pipeline that enhances code quality, client trust, and your own productivity. The initial setup time is quickly repaid by the hours saved on repetitive tasks and the avoidance of "it works on my machine" issues.

This system is not static. As your needs grow, you can expand it—add more runners, integrate more sophisticated testing, or implement canary deployments. You own the platform, and you control its evolution. Start with the basic pipeline outlined here, iterate, and watch as your ability to deliver robust software efficiently becomes a defining feature of your freelance services.