Plane is the open-source project management platform that engineering and product teams use to track issues, plan sprints, manage roadmaps, and collaborate on work — all on infrastructure they control. Unlike a simple static site, Plane is a full-stack Django application backed by PostgreSQL and Redis, with background workers handling notifications, search indexing, file uploads, and webhook delivery. When Plane goes down, your team loses visibility into ongoing work, sprint progress, and release tracking. Vigilmon gives you external visibility into Plane's health endpoint, web UI availability, background worker signals, and SSL certificate so you're notified the moment your project management instance becomes unreachable.
What You'll Build
- An HTTP monitor for Plane web UI availability
- A liveness check on the Plane API health endpoint
- SSL certificate monitoring for your Plane domain
Prerequisites
- A running Plane instance with a public or network-reachable domain
- HTTPS configured via a reverse proxy (e.g.,
https://plane.example.com) - A free account at vigilmon.online
Step 1: Verify Plane Web UI Availability
Plane serves its dashboard from the root path. A successful response confirms the Next.js frontend is running and the reverse proxy is routing traffic correctly:
curl -I https://plane.example.com
# Expected: HTTP/2 200
The root path returns either the project dashboard or the sign-in page depending on authentication state. A 200 response confirms the application is serving traffic. This is your primary availability signal — if it fails, no one on your team can access their projects, issues, or cycles.
Step 2: Create a Vigilmon HTTP Monitor for Web UI Availability
- Log in to Vigilmon → Add Monitor → HTTP.
- URL:
https://plane.example.com. - Check interval: 60 seconds.
- Response timeout: 10 seconds.
- Expected status:
200. - Keyword:
Plane. - Label:
Plane Web UI. - Click Save.
This monitor catches:
- Next.js frontend crashes or container restarts
- Database connection failures that prevent Plane from serving requests
- Reverse proxy misconfigurations blocking traffic to the application
- Out-of-memory kills that terminate the application process
- Configuration errors after upgrades that prevent the application from starting
When this monitor fires, your entire team loses access to issue tracking, sprint planning, and roadmap visibility.
Step 3: Monitor the Plane API Health Endpoint
Plane exposes an API health endpoint that confirms the Django backend is running and able to respond to requests:
curl https://plane.example.com/api/health/
# Expected: HTTP 200 with JSON body
A typical response:
{"status": "ok"}
This confirms the Django application server is running, the database connection is healthy, and the API layer is processing requests correctly.
- Add Monitor → HTTP.
- URL:
https://plane.example.com/api/health/. - Check interval: 2 minutes.
- Expected status:
200. - Keyword:
ok. - Label:
Plane API Health. - Click Save.
Why monitor the API separately? The web UI (Next.js) and the API (Django) are separate services in Plane's Docker Compose stack. The frontend can be serving cached content while the API backend is failing — monitoring both gives you independent signals and helps isolate whether the problem is in the frontend layer or the application backend.
Step 4: Monitor Background Worker Health
Plane's background workers handle critical operations: email notifications, webhook delivery, search indexing, and file attachment processing. Worker failures are silent — the web UI continues to load while these operations queue up and eventually fail.
The most reliable external signal for worker health is via Vigilmon's cron heartbeat monitor:
- Add a health-ping to your Plane worker container's startup script or a periodic task:
# Add to a cron job or Plane periodic task
curl -s https://vigilmon.online/heartbeat/YOUR_HEARTBEAT_URL
- In Vigilmon, click Add Monitor → Cron Heartbeat.
- Set the expected ping interval to match your task frequency (e.g., every 10 minutes).
- Copy the heartbeat URL and add it to the periodic task in your Plane configuration.
If the worker container crashes or the task queue stalls, the heartbeat stops arriving and Vigilmon alerts you — before your team notices that notifications have stopped or file uploads are silently failing.
Step 5: Monitor SSL Certificates
Plane stores your team's roadmaps, sprint plans, and issue history — losing HTTPS access disrupts all of that at once. An expired SSL certificate:
- Blocks all browser access to the Plane dashboard with certificate error pages
- Breaks integrations that communicate with the Plane API (CI/CD pipelines, automations)
- Disrupts webhook delivery to external tools (GitHub, GitLab, Slack)
- Add Monitor → SSL Certificate.
- Domain:
plane.example.com. - Alert when expiry is within: 30 days.
- Alert again: 14 days, 7 days, 3 days, 1 day.
- Click Save.
Step 6: Configure Alerting
In Vigilmon under Settings → Notifications, configure your alert channels:
| Monitor | Trigger | Action | |---|---|---| | Web UI | Non-200 or keyword missing | Check Next.js container; inspect nginx/Caddy proxy logs | | API Health | Non-200 or keyword missing | Check Django container; inspect database connectivity; review Plane logs | | Worker Heartbeat | Heartbeat missing | Check worker container; inspect Celery/Redis logs; verify task queue | | SSL certificate | < 30 days to expiry | Renew certificate; verify Let's Encrypt auto-renewal is running |
Alert after: 2 consecutive failures for HTTP monitors. This filters transient network blips while catching real outages within 2 minutes.
Common Plane Failure Modes and What Vigilmon Catches
| Scenario | Vigilmon monitor | |---|---| | Django API process crash | API Health monitor fires; alert within 2 minutes | | Next.js frontend crash | Web UI monitor fires; alert within 60 seconds | | Database connection failure | API backend fails; API Health monitor fires | | Redis connection failure | Background tasks queue but don't execute; heartbeat monitor fires | | Worker container crash | Heartbeat monitor fires after expected interval passes | | Reverse proxy misconfiguration | Web UI fires; API containers remain healthy | | SSL certificate expires | SSL monitor alerts at 30 days; browser access breaks for all users | | Disk full (file attachments) | File uploads fail silently; worker heartbeat may stop |
Plane centralises your team's entire project management workflow — issues, sprints, roadmaps, and the history that informs every planning decision. Vigilmon watches the web UI, API health endpoint, background workers, and SSL certificate so you're alerted within 60 seconds of any failure, before your team discovers it themselves.
Start monitoring Plane in under 5 minutes — register free at vigilmon.online.