Self-Hosting a No-Code Workflow Platform: Building a Make.com Alternative with Refine and Supabase on a Single VPS

Introduction: The Cost and Sovereignty Challenges of Modern Automation

In the contemporary digital ecosystem, workflow automation platforms like Make.com and Zapier have become indispensable assets for businesses seeking to optimize operational efficiency. These platforms bridge the gap between disparate software systems, allowing organizations to orchestrate complex data flows without writing extensive custom code. However, as an organization scales, two critical challenges invariably emerge: exponential licensing costs and stringent data privacy compliance.

Commercial no-code platforms typically operate on volume-based pricing models. As your business processes thousands of tasks or transfers gigabytes of operational data daily, monthly subscription fees can skyrocket. Furthermore, passing sensitive customer information or proprietary business logic through third-party servers can present severe compliance risks under frameworks such as GDPR, HIPAA, or local data sovereignty laws. The solution? Self-hosting your own internal tooling infrastructure.

This technical guide will demonstrate how to architect and deploy a robust, enterprise-grade, no-code workflow management platform on a single Virtual Private Server (VPS). By leveraging the synergy between Refine (a highly adaptable React-based framework for data-intensive applications) and Supabase (the premier open-source Firebase alternative powered by PostgreSQL), you can achieve complete data sovereignty, eliminate predictable scaling bottlenecks, and slash infrastructure costs.

The Architecture: Why Refine and Supabase?

Building an internal automation platform requires an architectural stack that balances rapid development with long-term stability and high throughput. Our chosen blueprint relies on three core pillars:

• Refine (Frontend & Admin Panel): Unlike rigid out-of-the-box internal tool builders, Refine is a headless React framework designed specifically for data-driven applications. It provides built-in enterprise features such as access control, state management, and seamless data provider integrations while leaving full UI customization control in your hands.
• Supabase (Backend, Auth, & Database): Built on top of enterprise-grade PostgreSQL, Supabase delivers real-time database capabilities, instant RESTful APIs via PostgREST, robust user authentication, and secure row-level security (RLS) policies without the operational overhead of a traditional custom backend.
• Single VPS (Infrastructure): By consolidating these components onto a single, high-performance VPS using Docker containers, we minimize network latency between the application layers and dramatically simplify server maintenance.

Step 1: Setting Up Your Infrastructure (VPS & Docker)

To begin, you will require a clean Linux VPS running an active distribution such as Ubuntu 24.04 LTS. Ensure your server has a minimum of 2 vCPUs and 4GB of RAM to reliably host both the frontend and database layers concurrently.

First, access your server via SSH and update the system packages:

sudo apt update && sudo apt upgrade -y

Next, install the requisite containerization tools, Docker and Docker Compose, which will allow us to run isolated instances of our services without dependency conflicts:

sudo apt install docker.io docker-compose-v2 -y

Step 2: Deploying the Supabase Backend

Supabase provides a comprehensive, self-hosted Docker configuration that contains everything needed to spin up an independent backend ecosystem. Execute the following commands on your server to clone the official configuration repository:

1. Clone the repository: git clone --depth 1 [https://github.com/supabase/supabase.git](https://github.com/supabase/supabase.git)
2. Navigate to the docker directory: cd supabase/docker
3. Copy the example environment file: cp .env.example .env

Before launching the containers, you must modify the .env file. Generate secure, cryptographically strong keys for your POSTGRES_PASSWORD, JWT_SECRET, ANON_KEY, and SERVICE_ROLE_KEY. Once updated, initialize the infrastructure:

sudo docker compose up -d

Your self-hosted Supabase stack is now operational, exposing a secure PostgreSQL instance, an automated API layer, and an intuitive web dashboard accessible via port 8000.

Step 3: Creating the Core Workflow Database Schema

To mirror the core capabilities of Make.com, our database must support users, workflow configurations, custom integration credentials, and execution history logs. Access your Supabase SQL Editor and execute the following schema definitions:

-- Create Workflows Table
CREATE TABLE workflows (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
  name TEXT NOT NULL,
  trigger_config JSONB NOT NULL,
  steps_config JSONB NOT NULL,
  is_active BOOLEAN DEFAULT false,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT timezone('utc'::text, now()) NOT NULL
);

-- Create Execution Logs Table
CREATE TABLE execution_logs (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  workflow_id UUID REFERENCES workflows(id) ON DELETE CASCADE,
  status TEXT NOT NULL CHECK (status IN ('success', 'failed', 'running')),
  payload JSONB,
  error_message TEXT,
  executed_at TIMESTAMP WITH TIME ZONE DEFAULT timezone('utc'::text, now()) NOT NULL
);

Ensure that you enable Row-Level Security (RLS) on these tables to guarantee that tenants can only view, modify, or execute their own specific automated tasks.

Step 4: Developing the Custom Workflow Interface with Refine

With the backend infrastructure securely locked down, we move to the orchestration layer. Refine enables us to build a lightning-fast, reactive interface for users to build and monitor their automation pipelines.

Initialize a new Refine application locally using their automated CLI tool:

npm create refine-app@latest -- --preset supabase

During the interactive prompt, select the Supabase Data Provider. This instantly wires up your frontend application to listen to your server\'s PostgreSQL tables natively. Refine uses a standardized structure where hooks like useTable and useForm automatically handle pagination, sorting, and state mutations out-of-the-box.

To provide a drag-and-drop experience similar to Make.com, integrate a visualization library such as React Flow into your Refine dashboard. Users can visually map Node A (e.g., a webhook trigger) to Node B (e.g., a data transformation utility) and save the resulting node graph directly into the steps_config JSONB column we provisioned in the database.

Step 5: Consolidating and Reverse-Proxying the Entire Stack

To serve both your Refine UI and Supabase API securely on a single VPS over HTTPS, you must configure a reverse proxy. Nginx or Caddy is highly recommended for this task.

Install Caddy on your host machine to benefit from automated SSL certificate generation via Let\'s Encrypt:

sudo apt install caddy -y

Configure your Caddyfile to route incoming web traffic to the appropriate container endpoints based on clear domain definitions:

automation.yourdomain.com {
    reverse_proxy localhost:5173 # Refine UI Application
}

api.yourdomain.com {
    reverse_proxy localhost:8000 # Supabase API Gateway
}

Restart Caddy with sudo systemctl restart caddy. Your platform is now fully optimized, isolated, and publicly accessible under an enterprise-grade security layer.

Conclusion and Next Steps

By migrating from restrictive commercial subscription models to a self-hosted architecture combining Refine and Supabase, you take complete ownership of your organization\'s computational workflow infrastructure. You eliminate costly monthly API overhead, ensure total data residency compliance, and retain the flexibility to build highly tailored integrations that generic third-party SaaS vendors simply cannot support.

As your internal platform matures, consider implementing an asynchronous background worker layer using Node.js or Go to poll your Supabase workflows table and process heavy analytical operations outside of the core web server loop. The blueprint is yours to expand—built on open standards, deployed on your hardware, and entirely under your strategic control.