Saleor on VPS: Modern Headless Platform for E-commerce

Saleor isn't just another e-commerce CMS. It's an API-first platform that gives complete control over store architecture, allows building any frontend, and scales without limitations. But this flexibility makes Saleor demanding on server resources and developer skills.

This guide shows who Saleor fits, how to install it on THE.Hosting VPS, and what you need to know before starting a project. No marketing and theory — only practice and real requirements.

What is Saleor

Saleor is an open-source headless ecommerce platform built on Python/Django with GraphQL API. Exists since 2012, actively developed and has 21,800+ stars on GitHub. Used by brands in publishing, fashion and other high-volume niches.

Platform Architecture:

Saleor consists of three independent components. Backend (Core) — Python/Django application providing GraphQL API for all operations: product management, orders, customers, payments, shipping. Dashboard — React application for store administrators with full catalog, order and settings management. Storefront — store frontend you create yourself on any technology (React, Vue, Next.js, mobile apps).

All three components interact only through GraphQL API. Backend knows nothing about frontend and vice versa. This is classic headless architecture giving maximum flexibility but requiring development.

Key Features:

GraphQL-first approach means all functionality accessible through powerful and flexible API. You request only data you need — no more, no less. Out-of-box multichannel allows managing multiple storefronts with different prices, currencies, warehouses and assortment through single backend. Support for 30+ languages and multicurrency makes global commerce simple from day one.

Platform extends through webhooks and apps instead of traditional plugins. Applications deploy independently from core which reduces downtime and simplifies development. Dashboard can be customized by adding own UI elements through 45+ mount points.

When to Choose Saleor

Saleor isn't universal solution. It's platform for teams ready to invest in development for complete control and flexibility.

Saleor perfectly fits if:

You need fully custom frontend. Standard WooCommerce or Shopify themes don't give needed UX, you want unique design or unusual purchase scenarios. You're building omnichannel commerce with sales through web, mobile apps, marketplaces, voice assistants or IoT devices. All channels work with single backend through API.

You plan scaling and high loads. You have thousands of products, complex logistics with multiple warehouses, ERP/CRM/WMS integrations and expected traffic from hundreds of thousands of users. You want to control entire technology stack without vendor lock-in. Open source Python/Django you can modify however you want.

Saleor does NOT fit if:

You don't have development team. Saleor requires programming for frontend setup and integrations. This isn't Shopify where you can assemble store from ready blocks in an hour. You need quick start. From installation to first sales takes minimum several weeks of development. Budget limited. Though platform free, frontend development and VPS infrastructure cost more than SaaS solutions at start.

You want out-of-box store. Saleor gives API and tools but not ready store with themes and plugins. Looking for something more ready — check WooCommerce, PrestaShop or Sylius (which is also headless but with more traditional approach).

System Requirements

Saleor is resource-demanding due to Python/Django backend and need to run multiple services simultaneously.

Minimum requirements for testing:

Configuration 4 vCPU / 8 GB RAM / 80 GB NVMe SSD allows running Saleor for development and tests with small catalog. PostgreSQL 15+ required as main database. Redis needed for Celery queues and caching. Python 3.12+ and Node.js 20 LTS for backend operation and Dashboard building.

Recommended configuration for production:

For real store with traffic need minimum 8 vCPU / 16 GB RAM / 160 GB NVMe SSD. Why more resources? Saleor Core (Django application) usually consumes 500-600 MB RAM per process. Run 4-6 worker processes for request handling — already 3-4 GB. Dashboard after build takes ~900 MB. Celery workers for background tasks — another 600-800 MB. PostgreSQL under load — 2-4 GB. Redis — 500 MB minimum. Operating system and buffers — 2 GB.

Total really need 10-12 GB RAM for comfortable operation under load. On 8 GB also runs but will have slowdowns at traffic peaks.

Which VPS to choose on THE.Hosting:

For development and tests suitable Standard VPS with 4 vCPU / 8 GB RAM / 90 GB NVMe for ~€15/month. For production store take Hi-CPU VPS with 8 vCPU / 16 GB RAM / 210 GB NVMe for ~€65/month. If planning high loads (50k+ visits per day) — immediately Dedicated server with 16+ CPU / 32+ GB RAM.

All THE.Hosting servers come with NVMe SSD which is critical for PostgreSQL performance, full root access for installing any software and Anti-DDoS protection. 24/7 support helps if problems arise with configuration.

Installing Saleor on Ubuntu 24.04

We'll install all components manually to understand architecture. Docker images exist but for production better to control each service.

System Preparation

Connect to server via SSH and update system:

sudo apt update && sudo apt upgrade -y

Install basic dependencies:

sudo apt install -y build-essential git curl wget \
  libpq-dev libffi-dev libssl-dev libjpeg-dev zlib1g-dev \
  libmagic1 gettext software-properties-common

Create separate user for Saleor:

sudo useradd -m -s /bin/bash saleor
sudo usermod -aG sudo saleor

Installing PostgreSQL 15

sudo apt install -y postgresql postgresql-contrib
sudo systemctl start postgresql
sudo systemctl enable postgresql

Create database:

sudo su - postgres
createuser saleor --pwprompt
createdb saleor --owner=saleor
exit

When prompted for password, set something strong — this is production database.

Installing Redis

sudo apt install -y redis-server
sudo systemctl start redis
sudo systemctl enable redis

# Check operation
redis-cli ping
# Should respond PONG

Installing Python 3.12

Ubuntu 24.04 already comes with Python 3.12 but let's check version:

python3 --version

If version older than 3.12 install via PPA:

sudo add-apt-repository ppa:deadsnakes/ppa -y
sudo apt update
sudo apt install -y python3.12 python3.12-venv python3.12-dev

Installing Node.js 20 LTS

Needed for Dashboard building:

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs
node --version
npm --version

# Install pnpm (preferred package manager for Saleor)
sudo npm install -g pnpm

Installing Saleor Core

Switch to saleor user:

sudo su - saleor
mkdir -p ~/apps
cd ~/apps

Clone repository:

git clone https://github.com/saleor/saleor.git
cd saleor
git checkout main

Create Python virtual environment:

python3.12 -m venv venv
source venv/bin/activate

Install dependencies:

pip install --upgrade pip wheel setuptools
pip install -r requirements.txt

This takes 5-10 minutes. Django and all dependencies quite heavy.

Environment Configuration

Create .env file:

nano .env

Main variables for production:

# Environment
SECRET_KEY=your-secret-key-here-generate-strong-one
DEBUG=False
ALLOWED_HOSTS=your-domain.com,www.your-domain.com

# Database
DATABASE_URL=postgres://saleor:your-password@localhost:5432/saleor

# Redis
CELERY_BROKER_URL=redis://localhost:6379/0
CACHE_URL=redis://localhost:6379/1

# Email (configure SMTP)
EMAIL_URL=smtp://user:password@smtp.example.com:587/?tls=True

# Media and static
STATIC_URL=/static/
MEDIA_URL=/media/

# GraphQL API domain
API_URI=https://api.your-domain.com/graphql/

Generate SECRET_KEY:

python -c "import secrets; print(secrets.token_urlsafe(50))"

Migrations and Creating Superuser

Apply database migrations:

python manage.py migrate

Create superuser for Dashboard access:

python manage.py createsuperuser

Load test data (optional for development):

python manage.py populatedb

Configuring systemd Services

Exit from saleor user:

exit

Create systemd unit for API server:

sudo nano /etc/systemd/system/saleor-api.service

Content:

[Unit]
Description=Saleor GraphQL API
After=network.target postgresql.service redis-server.service
Requires=postgresql.service redis-server.service

[Service]
Type=simple
User=saleor
Group=saleor
WorkingDirectory=/home/saleor/apps/saleor
Environment="PATH=/home/saleor/apps/saleor/venv/bin"
EnvironmentFile=/home/saleor/apps/saleor/.env
ExecStart=/home/saleor/apps/saleor/venv/bin/gunicorn saleor.wsgi:application \
  --bind 127.0.0.1:8000 \
  --workers 4 \
  --worker-class uvicorn.workers.UvicornWorker \
  --access-logfile - \
  --error-logfile -
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Similarly create service for Celery:

sudo nano /etc/systemd/system/saleor-celery.service

[Unit]
Description=Saleor Celery Worker
After=network.target redis-server.service
Requires=redis-server.service

[Service]
Type=forking
User=saleor
Group=saleor
WorkingDirectory=/home/saleor/apps/saleor
Environment="PATH=/home/saleor/apps/saleor/venv/bin"
EnvironmentFile=/home/saleor/apps/saleor/.env
ExecStart=/home/saleor/apps/saleor/venv/bin/celery -A saleor worker \
  --loglevel=info \
  --detach \
  --logfile=/home/saleor/logs/celery.log
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Create logs directory:

sudo su - saleor
mkdir ~/logs
exit

Start services:

sudo systemctl daemon-reload
sudo systemctl enable saleor-api saleor-celery
sudo systemctl start saleor-api saleor-celery

# Check status
sudo systemctl status saleor-api
sudo systemctl status saleor-celery

GraphQL API now available at http://localhost:8000/graphql/.

Installing Dashboard

Return to saleor user:

sudo su - saleor
cd ~/apps

Clone Dashboard:

git clone https://github.com/saleor/saleor-dashboard.git
cd saleor-dashboard

Install dependencies:

pnpm install

Create .env file:

nano .env

Content:

API_URI=https://api.your-domain.com/graphql/
APPS_MARKETPLACE_API_URI=https://apps.saleor.io/api/v2/saleor-apps
APPS_TUNNEL_URL_KEYWORDS=

Build production:

pnpm build

Build takes 3-5 minutes and creates build folder with static files.

Configuring Nginx

Install Nginx:

exit
sudo apt install -y nginx

Create configuration for API:

sudo nano /etc/nginx/sites-available/saleor-api

server {
    listen 80;
    server_name api.your-domain.com;

    client_max_body_size 50M;

    location / {
        proxy_pass http://127.0.0.1:8000;
        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;
    }

    location /media/ {
        alias /home/saleor/apps/saleor/media/;
    }

    location /static/ {
        alias /home/saleor/apps/saleor/static/;
    }
}

Create configuration for Dashboard:

sudo nano /etc/nginx/sites-available/saleor-dashboard

server {
    listen 80;
    server_name dashboard.your-domain.com;

    root /home/saleor/apps/saleor-dashboard/build;
    index index.html;

    location / {
        try_files $uri $uri/ /index.html;
    }
}

Activate configurations:

sudo ln -s /etc/nginx/sites-available/saleor-api /etc/nginx/sites-enabled/
sudo ln -s /etc/nginx/sites-available/saleor-dashboard /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

SSL Certificates

Install Certbot:

sudo apt install -y certbot python3-certbot-nginx

Get certificates:

sudo certbot --nginx -d api.your-domain.com
sudo certbot --nginx -d dashboard.your-domain.com

Certbot automatically configures HTTPS and redirects.

Installation Check

Open https://api.your-domain.com/graphql/ — GraphQL Playground should load.

Open https://dashboard.your-domain.com — Dashboard with login form should open.

Login with superuser credentials created earlier.

Initial Configuration

After installation need to configure basic store parameters through Dashboard.

Configuring Sales Channels

Saleor supports multichannel out-of-box. Go to Configuration → Channels and create first channel. For example "Web Store" with EUR currency and slug "default-channel". For each channel can configure own product prices, warehouse availability, shipping and payment methods.

Adding Products

Go to Catalog → Products → Create product. Set name, description, price, upload images. Specify which channels product available in and which warehouses have stock. Can configure product variants (sizes, colors) through Product Types and Attributes.

Configuring Shipping

Configuration → Shipping methods → Add shipping method. Create shipping zones linking them to countries. For each zone configure shipping methods with price or calculation by weight/order amount.

Configuring Payment

Configuration → Payment methods. Saleor supports integrations through webhooks and apps. Popular: Stripe, Braintree, PayPal. Installed through Saleor Apps marketplace or custom integration.

Webhooks for Integrations

Configuration → Webhooks. Here configure notifications for external systems. For example when order created send data to CRM, when payment send to accounting system, when product updated synchronize with marketplaces.

Frontend Development

Saleor doesn't give ready frontend — need to develop it. There's starter template on Next.js you can use as base.

Saleor Storefront (example)

sudo su - saleor
cd ~/apps
git clone https://github.com/saleor/storefront.git
cd storefront

Install dependencies:

pnpm install

Configure .env.local:

NEXT_PUBLIC_SALEOR_API_URL=https://api.your-domain.com/graphql/
NEXT_PUBLIC_STOREFRONT_URL=https://shop.your-domain.com

Develop store changing components in app/ and styles in styles/. GraphQL requests to API made through client already configured in project. Documentation on GraphQL schema available in Playground.

Build and run:

pnpm build
pnpm start

For production configure Nginx to proxy to Next.js server or deploy to Vercel/Netlify as static if using SSG.

Advantages and Limitations

What Saleor gives:

Complete architecture flexibility. You control every store aspect and can implement any business logic through API. Powerful GraphQL API with detailed typing and documentation allows building complex integrations and automations. Open source Python means can modify platform for specific requirements.

True headless approach gives ability to use any frontend: PWA, mobile apps, even voice assistants and IoT devices. Everything works with single backend. Multichannel without workarounds allows launching multiple stores with different logic on one installation.

Platform Limitations:

Requires development. No ready themes and designs. Frontend need to write from scratch or heavily modify starter template. High entry barrier. Need to know Python/Django for backend and jаvascript/React for frontend. GraphQL API also requires learning.

Resource demanding. Django applications hungry for memory and CPU compared to PHP. Need good VPS even for medium loads. Deployment more complex than WordPress/WooCommerce. Need to configure multiple services and understand how they interact.

Performance and Optimization

Caching

Redis used for caching database queries and GraphQL query results. Configure in .env:

CACHE_URL=redis://localhost:6379/1

Django caches automatically but can add custom caching rules for heavy queries.

PostgreSQL Optimization

Edit /etc/postgresql/15/main/postgresql.conf:

shared_buffers = 4GB
effective_cache_size = 12GB
work_mem = 64MB
maintenance_work_mem = 1GB
max_connections = 100

After changes restart PostgreSQL:

sudo systemctl restart postgresql

Scaling Celery

Run multiple Celery workers for parallel background task processing. Change ExecStart in systemd unit:

ExecStart=/home/saleor/apps/saleor/venv/bin/celery -A saleor worker \
  --concurrency=8 \
  --loglevel=info

CDN for Media Files

Configure django-storages for uploading product images to S3-compatible storage. Install:

pip install django-storages boto3

In settings.py add S3 configuration and images will upload directly to cloud not local server disk.

Frequently Asked Questions

Can you use Saleor without development?

No. Saleor provides only API and admin panel. Store frontend need to develop yourself or order from developers.

What minimum VPS needed?

For tests enough 4 vCPU / 8 GB RAM. For production store need minimum 8 vCPU / 16 GB RAM.

Does Saleor support multilingual?

Yes, built-in support for 30+ languages. Content can be translated through Dashboard for each language separately.

How fast does Saleor work?

GraphQL API responds in 50-200ms with proper caching configuration. Frontend speed depends on your implementation but headless approach allows making very fast PWAs.

Can you migrate from WooCommerce/Shopify?

Yes but migration needs programming. No standard migration tools. Export data from old platform and import through GraphQL mutations or directly into PostgreSQL.

Are there ready-made plugins?

There's Saleor Apps marketplace with payment, shipping, analytics integrations. But ecosystem much smaller than WooCommerce. Most integrations need to make yourself through webhooks and API.

Conclusion

Saleor is powerful platform for teams wanting complete control over e-commerce store architecture. Modern stack (Python/Django/GraphQL), true headless approach and multichannel make it excellent choice for complex projects and scalable solutions.

But this isn't plug-and-play system. Requires development experience, good VPS and time for configuration. If you have development team and budget for infrastructure — Saleor gives flexibility hard to get in other platforms.

On THE.Hosting servers you get performant VPS with NVMe SSD ideally suited for PostgreSQL, full root access for installing entire stack and 24/7 tech support if deployment difficulties arise.

Order VPS for Saleor