Penpot is the open-source, self-hosted alternative to Figma — a collaborative design and prototyping tool that runs entirely on your own infrastructure. Design teams rely on Penpot for creating UI mockups, design systems, and prototypes. When Penpot's backend API goes down, designers can't save work or access files. When the exporter service fails, PNG/SVG/PDF exports break silently. When the frontend becomes unreachable, the entire design workflow stops. Vigilmon gives you external visibility into Penpot's backend health endpoint, frontend web app, exporter TCP port, and SSL certificate so you catch failures before a designer loses unsaved work or a developer is blocked waiting on design exports.
What You'll Build
- A monitor on Penpot's backend health endpoint (returning 401 = server is alive)
- An HTTP monitor for the Penpot frontend web application
- A TCP monitor for the Penpot exporter service
- SSL certificate monitoring for your Penpot domain
- An alerting setup that distinguishes backend failures from exporter or frontend failures
Prerequisites
- A self-hosted Penpot instance (backend, frontend, and exporter containers)
- A public domain with HTTPS (e.g.,
https://penpot.example.com) - Docker Compose deployment (the standard Penpot installation method)
- A free account at vigilmon.online
Step 1: Verify the Backend Health Endpoint
Penpot's backend exposes an RPC endpoint at /api/rpc/command/get-profile. When called without authentication, it returns HTTP 401 Unauthorized — which is your health signal. A 401 means the backend is running, handling requests, and enforcing authentication correctly:
curl -I https://penpot.example.com/api/rpc/command/get-profile
# Expected: HTTP/2 401
A 502 Bad Gateway, connection refused, or timeout indicates the backend itself is down, not just an authentication rejection.
Step 2: Create a Vigilmon HTTP Monitor for the Backend API
- Log in to Vigilmon → Add Monitor → HTTP.
- URL:
https://penpot.example.com/api/rpc/command/get-profile. - Check interval: 60 seconds.
- Response timeout: 10 seconds.
- Expected status:
401. - Label:
Penpot Backend API. - Click Save.
Why 401? Vigilmon lets you configure any HTTP status code as the expected healthy response. For Penpot's RPC API, a 401 from an unauthenticated request is the correct liveness signal — the backend is alive and enforcing access control.
This monitor catches:
- Clojure backend process crashes or JVM OOM failures
- PostgreSQL connectivity failures (Penpot stores all design files and user data in Postgres)
- Redis connectivity failures (used for session management and real-time collaboration pub/sub)
- Configuration errors introduced during Penpot version upgrades
Step 3: Monitor the Penpot Frontend Web Application
The backend API and the frontend are separate services in Penpot's Docker Compose stack. The frontend is an nginx-served ClojureScript/React application. Monitor it independently:
- Add Monitor → HTTP.
- URL:
https://penpot.example.com. - Check interval: 60 seconds.
- Expected status:
200. - Keyword:
Penpot. - Label:
Penpot Frontend. - Click Save.
This monitor catches nginx container failures, static asset serving errors, and reverse proxy misconfigurations that wouldn't affect the backend health check but would block designers from loading the application entirely.
Step 4: Create a TCP Monitor for the Exporter Service
Penpot includes a dedicated exporter service that handles PNG, SVG, and PDF export rendering. It runs as a separate Node.js/Puppeteer container and listens on an internal port (default: 6061). If the exporter goes down, export operations silently fail — designers click "Export" and nothing happens, or they receive timeout errors.
- Add Monitor → TCP.
- Host:
penpot.example.com(or the internal host if the exporter is not publicly exposed). - Port:
6061(or your configured exporter port). - Check interval: 60 seconds.
- Response timeout: 10 seconds.
- Label:
Penpot Exporter. - Click Save.
Note: If the Penpot exporter is bound to an internal Docker network and not reachable from external monitoring nodes, you may need to expose the port or use a Vigilmon agent running inside your network. The exporter should not be exposed to the public internet — only to the Penpot backend.
When the TCP exporter monitor fires but the frontend and backend monitors are green, the design tool appears fully functional but all export operations will fail. This is a common failure pattern after Docker container memory exhaustion.
Step 5: Monitor SSL Certificates
Penpot's SSL certificate is critical because the entire application runs over HTTPS. An expired certificate:
- Prevents browsers from loading the frontend application
- Blocks the WebSocket connections Penpot uses for real-time collaborative editing
- Breaks all API calls from the frontend to the backend
- Add Monitor → SSL Certificate.
- Domain:
penpot.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 |
|---|---|---|
| Backend API (/api/rpc/command/get-profile) | Non-401 response | Check backend container; inspect Postgres and Redis connectivity |
| Frontend | Non-200 or keyword missing | Check nginx/frontend container; inspect reverse proxy config |
| Exporter TCP | Connection refused or timeout | Restart exporter container; check Puppeteer/Chrome memory usage |
| SSL certificate | < 30 days to expiry | Renew certificate; check ACME/Let's Encrypt renewal configuration |
Alert after: 2 consecutive failures for HTTP monitors. 1 failure for the TCP exporter monitor — exporter failures affect design export immediately and are rarely transient.
Common Penpot Failure Modes and What Vigilmon Catches
| Scenario | Vigilmon monitor | |---|---| | Backend (Clojure) JVM crash | API returns non-401; design saves fail; alert within 60 s | | PostgreSQL down | Backend returns 500; all design files inaccessible | | Redis down | Session management fails; real-time collaboration broken | | Exporter container OOM killed | TCP monitor fires; exports silently fail; backend appears healthy | | Frontend nginx crash | Frontend monitor fires; users can't load the app | | Reverse proxy misconfiguration | Frontend and API monitors fire simultaneously | | SSL certificate expires | SSL monitor alerts at 30 days; browsers block all connections | | Disk full on Docker host | Backend may fail to write files; exporter may crash on render | | Penpot upgrade migration failure | Backend returns 500 after upgrade; design files may be inaccessible |
Design tools occupy a unique space in your infrastructure: they're used by non-technical team members who expect them to "just work," and failures during design sessions can result in lost work that's difficult to recover. Vigilmon watches Penpot's backend API, frontend, exporter service, and SSL certificate so your design team has reliable access and you're alerted before a container crash turns into lost design work.
Start monitoring Penpot in under 5 minutes — register free at vigilmon.online.