Tutorial: Self-Hosting Make to Optimize Automation Costs for SMBs

Introduction: Why Self-Host Make in 2026

SMBs face a tough economic reality: SaaS subscription inflation eats into margins. A Make cloud subscription costs between €9 and €299 per month depending on your needs. Over a year, that’s €108 to €3,588. By self-hosting Make on a Hostinger VPS at €8/month, you bring the annual bill down to €96 — an 88% to 97% savings depending on your current plan.

Self-hosting brings three major advantages: complete control over your data (crucial for GDPR compliance), independence from arbitrary price increases, and substantial long-term savings. For an SMB automating billing, customer management, and marketing campaigns, the ROI is measured in weeks.

This tutorial is aimed at SMB IT teams with basic Linux system administration and Docker knowledge. If you can SSH into a server and edit a configuration file, you’re ready.

Technical Prerequisites and Preparation

Before starting, make sure you have the basics of Docker, Linux command line, and basic networking concepts (ports, DNS, reverse proxy). You don’t need to be an expert, but you should be comfortable with a terminal.

For the VPS, three options stand out for SMBs:

We’ll use Hostinger in this tutorial for its price-performance ratio and support.

On the software side, you’ll need Docker (version 24.0+), Docker Compose (version 2.20+), and Git. We’ll install everything in the next steps.

Step 1: Provision and Secure Your VPS

Log into your Hostinger account and create a new VPS with Ubuntu 22.04 LTS. Choose the €8/month plan (4 GB RAM, 2 vCPU). Deployment takes 2 to 3 minutes.

Once the VPS is active, grab the public IP and connect via SSH with the provided root password:

ssh root@your_vps_ip

First critical step: create a non-root user to avoid working with unnecessary privileges.

adduser makeadmin
usermod -aG sudo makeadmin

Log out and reconnect with the new user:

ssh makeadmin@your_vps_ip

Now, secure the server with UFW (Uncomplicated Firewall):

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable

Install system updates and fail2ban to block SSH brute force attempts:

sudo apt update && sudo apt upgrade -y
sudo apt install fail2ban -y
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

Your VPS is now secured. We can move on to Docker.

Step 2: Install Docker and Docker Compose

The simplest way to install Docker on Ubuntu is to use the official script:

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

This script automatically detects your distribution and installs the latest stable Docker version. Verify the installation:

docker --version
# Expected output: Docker version 24.0.7, build afdd53b

Install Docker Compose v2 (integrated into the modern Docker CLI):

sudo apt install docker-compose-plugin -y
docker compose version
# Expected output: Docker Compose version v2.21.0

Add your user to the docker group to avoid typing sudo with every command:

sudo usermod -aG docker $USER
newgrp docker

Test the installation with a hello-world container:

docker run hello-world

If you see the “Hello from Docker!” message, your installation works perfectly. We can deploy Make.

Step 3: Deploy Make with Docker Compose

Create a directory for your installation:

mkdir -p ~/make-automation && cd ~/make-automation

Create the docker-compose.yml file:

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    container_name: make_postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: makeuser
      POSTGRES_PASSWORD: YourSecurePassword123!
      POSTGRES_DB: makedb
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - make_network

  redis:
    image: redis:7-alpine
    container_name: make_redis
    restart: unless-stopped
    networks:
      - make_network

  n8n:
    image: n8nio/n8n:1.23.0
    container_name: make_n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=YourAdminPassword456!
      - N8N_HOST=automation.yourdomain.com
      - N8N_PROTOCOL=https
      - N8N_PORT=5678
      - WEBHOOK_URL=https://automation.yourdomain.com/
      - GENERIC_TIMEZONE=Europe/Paris
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=makedb
      - DB_POSTGRESDB_USER=makeuser
      - DB_POSTGRESDB_PASSWORD=YourSecurePassword123!
      - EXECUTIONS_MODE=queue
      - QUEUE_BULL_REDIS_HOST=redis
      - QUEUE_BULL_REDIS_PORT=6379
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres
      - redis
    networks:
      - make_network

volumes:
  postgres_data:
  n8n_data:

networks:
  make_network:
    driver: bridge

This file configures three services: PostgreSQL for workflow persistence, Redis for execution queue management, and n8n as the automation engine.

Launch the containers:

docker compose up -d

Verify everything is working:

docker compose ps
# You should see 3 containers "Up"

docker compose logs -f n8n
# Check for no errors

n8n is now accessible at http://your_vps_ip:5678. But let’s secure this with HTTPS.

Step 4: Configure Reverse Proxy and SSL with Nginx

Install Nginx:

sudo apt install nginx -y
sudo systemctl enable nginx

Create the configuration file for your domain:

sudo nano /etc/nginx/sites-available/make

Paste this configuration:

server {
    listen 80;
    server_name automation.yourdomain.com;

    location / {
        proxy_pass http://localhost:5678;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;

        # Webhook and SSE support
        proxy_buffering off;
        proxy_read_timeout 3600s;
        proxy_send_timeout 3600s;
    }
}

Enable the configuration:

sudo ln -s /etc/nginx/sites-available/make /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

Install Certbot for free Let’s Encrypt SSL certificates:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d automation.yourdomain.com

Certbot automatically configures HTTPS and creates a cron job for automatic certificate renewal. Test access to https://automation.yourdomain.com — you should see the n8n login interface.

Step 5: Initial Configuration and Workflow Migration

Log into https://automation.yourdomain.com with the credentials configured in docker-compose.yml (admin / YourAdminPassword456!).

First login: n8n asks you to create an owner account. Use your professional email and a strong password. This account will have full administrator privileges.

To add additional users, go to Settings > Users and create accounts with appropriate permissions (Owner, Member, or Viewer depending on needs).

If you’re migrating from Make cloud, export your scenarios as JSON from the Make interface, then import them into n8n via Workflows > Import from File. n8n supports most Make integrations (Google Sheets, Slack, Airtable, HubSpot, etc.).

Create your first test workflow:

1. Click Add Workflow
2. Add a Webhook node as trigger
3. Add a Slack node to send a notification
4. Configure your Slack credentials (OAuth2 or Token)
5. Activate the workflow

Test the webhook with curl:

curl -X POST https://automation.yourdomain.com/webhook/test \
  -H "Content-Type: application/json" \
  -d '{"message": "Test from VPS"}'

You should receive a Slack notification. Your instance is operational.

For backups, configure a cron job that exports the PostgreSQL database daily:

crontab -e
# Add this line:
0 3 * * * docker exec make_postgres pg_dump -U makeuser makedb > ~/backups/makedb_$(date +\%Y\%m\%d).sql

Conclusion and Future Optimizations

Let’s recap the savings: a Make Pro subscription at €29/month costs €348/year. Your Hostinger VPS at €8/month comes to €96/year. Annual savings: €252 (72%). For a Teams plan at €299/month, savings climb to €3,492/year (97%).

The ROI is immediate from the first month. Over 12 months, you recover your time investment (approximately 4 hours of setup) by the second month.

Next steps to professionalize your installation:

• Monitoring with Grafana and Prometheus to track performance
• Automated backups to S3 with encryption
• Horizontal scaling with multiple n8n workers behind a load balancer
• Slack/email alerts for failed workflows

For maintenance, plan 30 minutes per month: Docker updates (docker compose pull && docker compose up -d), log checking, disk space monitoring.

Additional resources: the n8n documentation is excellent, and the self-hosting community is very active.

If your automation needs exceed 100 active workflows or require complex real-time processing, consider n8n as an alternative to Make. It’s exactly what we deployed here, and it’s perfectly suited for SMBs.

In the next article, we’ll explore how to integrate AI agents into your n8n workflows to automate lead qualification with GPT-4 and Qdrant.

Need help deploying your automation infrastructure? At Kodixar, I help SMBs transition to self-hosting and IT cost optimization.