Monitoring Planka with Vigilmon: Uptime, API Health & WebSocket Alerts for Self-Hosted Kanban

Planka is a self-hosted, open-source Trello alternative that runs entirely on your own infrastructure — a Node.js application backed by PostgreSQL with real-time WebSocket updates for card movements and board changes. That self-hosted freedom means you're responsible for keeping it online. When Planka's process dies, its PostgreSQL connection drops, or the WebSocket server stops broadcasting, your team loses access to the board they depend on for sprint planning and task tracking. Vigilmon gives you external uptime monitoring that watches Planka from outside your server and notifies you the moment something goes wrong.

What You'll Build

• A Vigilmon HTTP monitor on Planka's /api/health endpoint
• A keyword assertion confirming the API reports healthy status
• A secondary monitor on the main app URL to catch proxy or WebSocket failures
• SSL certificate expiry alerts for proxied deployments
• Alerting rules tuned for a team productivity tool

Prerequisites

• A running Planka instance (default port :1337, typically proxied via Nginx or Caddy)
• A free account at vigilmon.online

Step 1: Verify Planka's Health Endpoint

Planka exposes a built-in health endpoint at /api/health. It checks that the application server is running and that it can communicate with the PostgreSQL database.

curl https://your-planka-domain.com/api/health

A healthy Planka instance returns HTTP 200 with a JSON body similar to:

{"status":"OK"}

If PostgreSQL is unreachable, Planka will either return a non-200 status or fail to respond entirely. If the Node.js process has crashed, the connection will be refused.

Reverse proxy required: Planka binds to port 1337 by default. Expose it over HTTPS using Nginx or Caddy. Caddy auto-provisions TLS:

your-planka.example.com {
  reverse_proxy localhost:1337
}

Step 2: Create a Vigilmon HTTP Monitor on /api/health

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: https://your-planka-domain.com/api/health
3. Check interval: 60 seconds.
4. Response timeout: 10 seconds.
5. Expected status: 200.
6. Click Save.

Vigilmon will probe your Planka health endpoint from an external location every 60 seconds. If the Node.js process crashes or PostgreSQL drops, Vigilmon catches it within one to two minutes.

Step 3: Add a Keyword Assertion

An HTTP 200 response confirms the server answered, but a reverse proxy can return 200 even when Planka itself is down (for example, a cached Nginx error page). Add a keyword assertion to verify the response body:

In the monitor settings under Assertions:

• Keyword: OK
• Must be present: yes

This fails the check if Planka is replaced by a proxy error page, the process is mid-restart and returning an empty body, or the database connection silently failed and the health response changed.

Step 4: Monitor the Main Application URL

The /api/health endpoint confirms the backend API and database are running, but it doesn't confirm the frontend is serving correctly or that WebSocket upgrades are being accepted. Add a second monitor on the root URL:

1. Add Monitor → HTTP.
2. URL: https://your-planka-domain.com/
3. Expected status: 200.
4. Keyword: Planka (appears in the page <title>).
5. Check interval: 2 minutes.

If the frontend build is broken, static assets are missing, or the reverse proxy fails WebSocket upgrade (101 Switching Protocols), this monitor catches the degradation even when the API backend is healthy.

Step 5: Monitor SSL Certificate Expiry

Planka's mobile-friendly board requires HTTPS, and an expired certificate locks out every team member with a browser warning. Vigilmon monitors certificate validity automatically:

1. Open your primary HTTP monitor → SSL Certificate.
2. Enable Alert before expiry and set the threshold to 21 days.

You'll receive an alert three weeks before expiry, giving plenty of time to renew via Let's Encrypt:

sudo certbot renew --quiet
# or with Caddy: certificate renewal is automatic

For Caddy deployments, certificate renewal is fully automatic — but the Vigilmon SSL alert acts as a safety net in case Caddy's ACME renewal fails silently.

Step 6: Configure Alerting

In Vigilmon under Settings → Notifications, set up alert channels:

| Trigger | Channel | Notes | |---|---|---| | /api/health returns non-200 | Email + Slack/Teams | Node.js process or PostgreSQL down | | Response timeout (> 10 s) | Email | Database query may be hanging | | Keyword OK missing | Email | Proxy misconfiguration or partial startup | | Main URL returns non-200 | Email | Frontend broken or static assets missing | | SSL certificate expires < 21 days | Email | Renew with certbot renew immediately |

Alert after: 1 consecutive failure — Planka is a stateful team tool; a single failed check almost always means a real outage.

Recovery notification: enable it so your team knows when the board is back online.

Keeping Planka Running with Docker Compose

Most Planka deployments use Docker Compose. Ensure the Planka container has a restart policy and a health check:

services:
  planka:
    image: ghcr.io/plankanban/planka:latest
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:1337/api/health"]
      interval: 30s
      timeout: 5s
      retries: 3
    environment:
      - BASE_URL=https://your-planka-domain.com
      - DATABASE_URL=postgresql://planka:password@postgres/planka

  postgres:
    image: postgres:15-alpine
    restart: unless-stopped
    volumes:
      - postgres_data:/var/lib/postgresql/data

With Docker's restart policy and Vigilmon's external monitoring:

1. Planka container crashes → Docker restarts it within seconds
2. If it doesn't recover, Vigilmon detects the outage within 60–120 seconds and alerts you
3. You SSH in and run docker compose logs planka --tail 50

What Vigilmon Catches That Server Logs Miss

| Scenario | Server logs | Vigilmon | |---|---|---| | Node.js process OOM crash | Container exit log | HTTP monitor fires within 60–120 s | | PostgreSQL connection pool exhausted | DB timeout in app log | /api/health returns non-200; alert fires | | Reverse proxy misconfiguration after update | Nginx/Caddy error log | Keyword assertion catches wrong response body | | SSL certificate expired | Not in app logs | SSL alert fires 21 days before expiry | | VPS network partition | Logs inaccessible | External Vigilmon still sees the outage | | Frontend assets missing after bad deploy | JS errors in browser | Root URL monitor catches non-200 response |

Planka keeps your team organized — Vigilmon keeps Planka online. External monitoring catches outages your internal logs never see, including network issues, expired certificates, and proxy misconfigurations that affect users but not server-side processes.

Start monitoring your Planka instance in under 5 minutes — register free at vigilmon.online.