How to Monitor Saleor E-Commerce Platform Infrastructure 2026

Saleor is a cloud-native, headless e-commerce platform built on Django and GraphQL. A typical production Saleor stack includes the Django API server, Celery workers, a PostgreSQL database, Redis, and one or more decoupled storefronts (Next.js, React). Each layer can silently degrade — a checkout that returns HTTP 200 while the payment webhook queue is backed up costs you real revenue. Vigilmon gives you end-to-end visibility across all of those layers.

What You'll Set Up

• HTTP uptime monitoring for the Saleor GraphQL API and storefront
• Health endpoint to expose Django and database readiness
• Celery worker heartbeat via Vigilmon cron monitors
• Webhook delivery monitoring for payment, order, and fulfillment events
• SSL certificate expiry alerts

Prerequisites

• Saleor 3.x deployment (Docker, Kubernetes, or bare-metal)
• Saleor Dashboard and at least one storefront connected to the API
• A free Vigilmon account

Step 1: Monitor the GraphQL API Endpoint

The Saleor API is your platform's backbone. All checkout, product, and order operations flow through it.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter your API URL: https://api.yourdomain.com/graphql/.
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

The GraphQL endpoint returns 200 for both successful queries and GraphQL-layer errors. To catch application errors, pair this monitor with the health endpoint in Step 2.

Step 2: Add a Health Check Endpoint to Saleor

Saleor exposes a basic health check at /health/ by default. You can verify it returns 200:

curl -I https://api.yourdomain.com/health/
# HTTP/2 200

If you need a deeper health check that validates the database and cache connections, add a custom view in your Saleor deployment's Django settings or a middleware extension:

# saleor/health.py
from django.http import JsonResponse
from django.db import connection
from django.core.cache import cache

def health_check(request):
    status = {"api": "ok"}
    try:
        connection.ensure_connection()
        status["database"] = "ok"
    except Exception as e:
        status["database"] = str(e)
    try:
        cache.set("healthcheck", "1", 5)
        status["cache"] = "ok"
    except Exception as e:
        status["cache"] = str(e)
    code = 200 if all(v == "ok" for v in status.values()) else 503
    return JsonResponse(status, status=code)

Register the view in your URL configuration and point your Vigilmon monitor at /healthz/ instead of /health/ to use this richer check.

Step 3: Monitor the Storefront

Your headless storefront (Next.js, React, or any SPA) is what customers actually see. A broken storefront is a broken store, even if the API is up.

1. Add a second HTTP / HTTPS monitor pointing to your storefront URL: https://store.yourdomain.com.
2. Set Check interval to 1 minute.
3. Optionally add a keyword check for your store name or a key element (e.g., "Add to Cart") — if the response body doesn't include it, Vigilmon fires an alert even when the HTTP status is 200.

For Next.js storefronts using Vercel or a Node.js server, add a simple health route:

// pages/api/health.ts
import type { NextApiRequest, NextApiResponse } from 'next';

export default function handler(req: NextApiRequest, res: NextApiResponse) {
  res.status(200).json({ status: 'ok' });
}

Point the Vigilmon monitor at https://store.yourdomain.com/api/health.

Step 4: Monitor Celery Workers with a Heartbeat

Saleor offloads email sending, webhook delivery, thumbnails, and export jobs to Celery workers. If your workers crash, orders queue silently and customers never get confirmation emails.

Add a heartbeat task to your Celery beat schedule:

# saleor/celery.py (add to existing file)
import os
import requests
from celery import shared_task

VIGILMON_HEARTBEAT_URL = os.environ.get("VIGILMON_HEARTBEAT_URL", "")

@shared_task
def vigilmon_heartbeat():
    if VIGILMON_HEARTBEAT_URL:
        try:
            requests.get(VIGILMON_HEARTBEAT_URL, timeout=5)
        except Exception:
            pass

Schedule it in CELERY_BEAT_SCHEDULE:

CELERY_BEAT_SCHEDULE = {
    # ... existing tasks ...
    "vigilmon-heartbeat": {
        "task": "saleor.celery.vigilmon_heartbeat",
        "schedule": 60.0,  # every 60 seconds
    },
}

In Vigilmon:

1. Click Add Monitor → Cron Heartbeat.
2. Set the expected ping interval to 2 minutes (allows one missed beat before alerting).
3. Copy the heartbeat URL and set it as the VIGILMON_HEARTBEAT_URL environment variable on your Celery worker containers.

Step 5: Monitor Webhook Delivery

Saleor uses webhooks to notify payment gateways, fulfillment providers, and your storefront of order events. Failed webhooks mean unprocessed payments and missed fulfillments.

Add a monitor for each webhook receiver:

1. Add an HTTP / HTTPS monitor for your payment gateway webhook handler: https://api.yourdomain.com/webhooks/stripe/.
2. Set Expected HTTP status to 200 or 204.
3. Repeat for each provider (fulfillment, shipping, ERP).

To verify webhook delivery from the Saleor side, query the Saleor API for recent webhook delivery attempts:

{
  webhooks(first: 10) {
    edges {
      node {
        id
        name
        isActive
        app {
          name
        }
      }
    }
  }
}

A webhook returning isActive: false means Saleor has disabled it due to repeated failures — your Vigilmon alert should fire before Saleor disables the hook.

Step 6: SSL Certificate Alerts

1. Open each HTTP / HTTPS monitor in Vigilmon.
2. Enable Monitor SSL certificate.
3. Set Alert when certificate expires in less than 21 days.

Run this check for:

• api.yourdomain.com (Saleor API)
• store.yourdomain.com (storefront)
• dashboard.yourdomain.com (Saleor Dashboard)

Step 7: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and connect Slack, email, or PagerDuty.
2. Set Consecutive failures before alert to 2 on the API monitor — Django cold starts after a container restart can cause a single slow probe.
3. Use the Vigilmon API to pause monitors during planned maintenance windows:

curl -X POST https://vigilmon.online/api/maintenance \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"monitor_id": "your-monitor-id", "duration_minutes": 10}'

Summary

| Monitor | Target | What It Catches | |---|---|---| | GraphQL API | /graphql/ | API server down, Django errors | | Health endpoint | /healthz/ | Database or cache unreachable | | Storefront | https://store.yourdomain.com | Frontend deployment failure | | Celery heartbeat | Heartbeat URL | Worker crash, beat schedule stopped | | Webhook receivers | /webhooks/* | Payment handler down | | SSL certificates | API + storefront | Certificate expiry |

Saleor's composable architecture means failure can occur at any layer without the others immediately noticing. With Vigilmon monitoring each component independently, you catch issues at the infrastructure layer before customers report failed checkouts or missing order emails.