Monitoring Postiz with Vigilmon

Postiz is an open-source social media scheduling platform that handles post queuing, multi-platform OAuth connections, media uploads, and scheduled publishing — all running in your own infrastructure. The trade-off of self-hosting is that failures cascade quietly: the Redis queue broker goes down, scheduled posts pile up silently, and you only find out when a client asks why nothing published today. Vigilmon gives you HTTP, TCP, and heartbeat monitors covering every Postiz component so you catch failures the moment they happen.

What You'll Set Up

• Frontend web server availability monitor (port 4200)
• API backend health check (port 3000)
• PostgreSQL database connectivity probe
• Redis queue broker TCP monitor
• Post scheduling queue heartbeat
• SSL certificate monitoring
• Alert channel configuration

Prerequisites

• Postiz deployed via Docker Compose or a Node.js process manager
• Frontend accessible at port 4200, API at port 3000
• A free Vigilmon account

Step 1: Monitor the Postiz Frontend

The Postiz Next.js frontend serves the scheduling dashboard at port 4200. Add an HTTP monitor:

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter your frontend URL: https://postiz.yourdomain.com (or http://yourserver:4200 if not behind a reverse proxy).
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

If Postiz is behind Nginx or Caddy, monitor the public domain — this also validates your reverse proxy configuration, not just the Node.js process.

Step 2: Monitor the API Backend

The Postiz API (port 3000) handles all scheduling, OAuth, and media operations. Most Postiz deployments expose a health endpoint you can probe directly:

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: https://postiz.yourdomain.com/api/health (or http://yourserver:3000/health).
3. Set Expected HTTP status to 200.
4. Set Check interval to 1 minute.
5. Under Keyword match, enter ok or healthy.
6. Click Save.

If Postiz doesn't expose a /health route in your version, probe the root API path instead:

http://yourserver:3000/

A 200 or 404 response both confirm the API process is alive. A connection refused or 502 means the API is down.

You can also add a TCP monitor for port 3000 as a lower-level backstop:

1. Click Add Monitor → TCP Port.
2. Enter your server hostname and port 3000.
3. Set Check interval to 1 minute.
4. Click Save.

Step 3: Check PostgreSQL Connectivity

Postiz stores all posts, user accounts, and OAuth tokens in PostgreSQL. A database outage prevents any scheduling or publishing from working. Add a TCP monitor for the Postgres port:

1. Click Add Monitor → TCP Port.
2. Enter your database host and port 5432.
3. Set Check interval to 2 minutes.
4. Click Save.

If your PostgreSQL instance is on the same host as Postiz and not exposed externally, use a Vigilmon heartbeat from a health check script instead:

#!/bin/bash
# /usr/local/bin/postiz-db-check.sh

pg_isready -h localhost -p 5432 -U postiz -d postiz
if [ $? -eq 0 ]; then
  curl -fsS https://vigilmon.online/heartbeat/YOUR_DB_HEARTBEAT_ID
fi

Run every 2 minutes via cron:

*/2 * * * * /usr/local/bin/postiz-db-check.sh

Step 4: Monitor the Redis Queue Broker

Postiz uses Redis as the queue broker for deferred post scheduling and worker coordination. If Redis goes down, the scheduling worker silently stops consuming jobs — posts queue up but never publish.

Add a TCP monitor for Redis:

1. Click Add Monitor → TCP Port.
2. Enter your Redis host and port 6379.
3. Set Check interval to 1 minute.
4. Click Save.

For Redis instances protected by requirepass, the TCP check still succeeds as long as the port is reachable — the handshake doesn't require authentication for port probing.

If you're running Redis in Docker, verify the port is exposed in your docker-compose.yml:

redis:
  image: redis:7-alpine
  ports:
    - "6379:6379"

Step 5: Heartbeat for the Post Scheduling Worker

The Postiz worker process pulls jobs from Redis and publishes posts at their scheduled times. This worker has no HTTP endpoint — use a Vigilmon heartbeat to confirm it's running and processing.

1. Click Add Monitor → Cron Heartbeat.
2. Set Expected ping interval to 5 minutes.
3. Set Grace period to 2 minutes.
4. Copy the heartbeat URL.

Add a ping to your Postiz worker process or wrap your startup script:

#!/bin/bash
# /usr/local/bin/postiz-worker-watchdog.sh

# Check if the Postiz worker process is running
if pgrep -f "postiz.*worker" > /dev/null; then
  curl -fsS https://vigilmon.online/heartbeat/YOUR_WORKER_HEARTBEAT_ID
fi

Run via cron every 5 minutes:

*/5 * * * * /usr/local/bin/postiz-worker-watchdog.sh

If you run Postiz in Docker, check the container health instead:

#!/bin/bash
CONTAINER="postiz-worker"
if [ "$(docker inspect -f '{{.State.Running}}' $CONTAINER 2>/dev/null)" = "true" ]; then
  curl -fsS https://vigilmon.online/heartbeat/YOUR_WORKER_HEARTBEAT_ID
fi

Step 6: SSL Certificate and Alert Configuration

SSL monitoring:

1. Open the frontend HTTP monitor from Step 1.
2. Enable Monitor SSL certificate.
3. Set Alert when certificate expires in less than 21 days.
4. Click Save.

Alert thresholds:

1. Go to Alert Channels and add Slack, email, or a webhook.
2. Frontend monitor: Consecutive failures before alert → 2 (Next.js processes occasionally restart).
3. API monitor: Consecutive failures before alert → 2.
4. Redis TCP monitor: Consecutive failures before alert → 1 (Redis drops are never transient).
5. Heartbeat monitors alert automatically after one missed interval.

Maintenance windows for deployments:

Use the Vigilmon API to suppress alerts during Postiz upgrades:

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

docker compose pull && docker compose up -d

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP frontend | https://postiz.yourdomain.com | Next.js process crash, reverse proxy failure | | HTTP API | /api/health on port 3000 | API backend crash, startup failure | | TCP API port | Port 3000 | API process not listening | | TCP PostgreSQL | Port 5432 | Database down, connection refused | | TCP Redis | Port 6379 | Queue broker down, worker stalls | | Cron heartbeat | Worker watchdog | Scheduling worker crash, jobs not processing | | SSL certificate | Public domain | Let's Encrypt renewal failure |

Postiz handles your clients' social media presence — a missed post due to a silent Redis or worker failure is a real business impact. With Vigilmon monitoring every layer of the stack, you'll be alerted the moment any component fails, giving you time to intervene before scheduled content goes unpublished.