Monitoring Outline with Vigilmon: Health Endpoint, Web UI Uptime, Auth API Check & SSL Alerts

Outline is the open-source team wiki and knowledge base — a self-hosted alternative to Notion and Confluence that gives your team a fast, searchable place to write documentation, runbooks, and internal guides. Because Outline hosts your team's institutional knowledge, its availability matters more than it might seem: when Outline goes down during an incident, the runbooks your engineers need to resolve the incident are inaccessible. When the web UI fails due to a reverse proxy issue, teams lose access to onboarding docs, API references, and process documentation exactly when they need them. Vigilmon gives you external visibility into Outline's health endpoint, web UI, authentication API, and SSL certificate so your team's knowledge base is always reachable.

What You'll Build

• A monitor on Outline's /_health endpoint
• An HTTP monitor for the Outline web UI
• A monitor for the /api/auth.info endpoint
• SSL certificate monitoring for your Outline domain
• An alerting setup that distinguishes server failures from authentication issues

Prerequisites

• A running Outline instance with a public or network-reachable domain
• HTTPS configured (e.g., https://wiki.example.com)
• An SSO or authentication provider configured (Slack, Google, or OIDC)
• A free account at vigilmon.online

Step 1: Verify Outline's Health Endpoint

Outline exposes a dedicated health check at /_health:

curl https://wiki.example.com/_health

A healthy Outline returns HTTP 200 with a plain OK response body, confirming the application server is running and its dependencies (database, Redis) are reachable.

Step 2: Create a Vigilmon HTTP Monitor for the Health Endpoint

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: https://wiki.example.com/_health.
3. Check interval: 60 seconds.
4. Response timeout: 10 seconds.
5. Expected status: 200.
6. Keyword: OK.
7. Click Save.

This monitor catches:

• Outline Node.js process crashes or unexpected restarts
• PostgreSQL database connectivity failures (Outline stores all documents, collections, and user data in Postgres)
• Redis failures (Outline uses Redis for sessions and real-time collaboration)
• Configuration errors after Outline upgrades or environment variable changes

The health endpoint is the fastest signal that something is fundamentally wrong with Outline's infrastructure — database down, process crashed, or memory exhausted. A 60-second check interval ensures your team gets alerted before the missing runbook becomes a blocker during an incident.

Step 3: Monitor the Outline Web UI

The /_health endpoint confirms the backend is alive, but the web UI involves additional layers: the React frontend, authentication middleware, and the WebSocket connections that power collaborative editing. Monitor the main web interface independently:

1. Add Monitor → HTTP.
2. URL: https://wiki.example.com.
3. Check interval: 60 seconds.
4. Expected status: 200.
5. Keyword: Outline.
6. Label: Outline Web UI.
7. Click Save.

This monitor catches reverse proxy failures, TLS termination issues, and static asset serving problems that wouldn't affect the health endpoint but would prevent your team from accessing documentation.

Note: Outline's login page also contains the word Outline in the page title, so this keyword check works whether you're checking the authenticated editor or the unauthenticated login page. If you've customized your Outline instance name, use your custom name as the keyword.

Step 4: Monitor the Auth Info Endpoint

Outline's /api/auth.info endpoint returns authentication provider configuration — the SSO providers available, their status, and whether users can authenticate. It's an unauthenticated endpoint that Outline's frontend calls before showing the login page:

curl https://wiki.example.com/api/auth.info

A healthy Outline returns a JSON object describing available authentication providers:

{"data":{"providers":[{"id":"google","name":"Google","authUrl":"..."}],"hostname":"..."},"ok":true}

1. Add Monitor → HTTP.
2. URL: https://wiki.example.com/api/auth.info.
3. Check interval: 5 minutes.
4. Expected status: 200.
5. Keyword: ok.
6. Label: Outline Auth API.
7. Click Save.

When the auth info endpoint fires but the health endpoint is green, Outline's core server is running but the authentication API is failing — users will see a broken login page even though the application process appears healthy. This can happen after SSO provider configuration changes, environment variable issues with OAuth credentials, or API routing failures introduced by a reverse proxy update.

Step 5: Monitor SSL Certificates

Outline's SSL certificate affects every user's ability to access the wiki:

• A certificate expiry locks out all team members simultaneously — no fallback, no HTTP access
• Collaborative editing uses WebSockets over HTTPS — an expired certificate breaks real-time editing even for users who can still load cached pages
• If Outline is integrated with Slack or other SSO providers, certificate errors break the OAuth callback URLs and prevent login entirely

1. Add Monitor → SSL Certificate.
2. Domain: wiki.example.com.
3. Alert when expiry is within: 30 days.
4. Alert again: 14 days, 7 days, 3 days, 1 day.
5. Click Save.

For a team wiki, an SSL expiry at 3am on a Monday means your engineers arrive to find they can't access the deployment runbook for a production issue. A 30-day warning provides plenty of time for certificate renewal before the deadline becomes an emergency.

Step 6: Configure Alerting

In Vigilmon under Settings → Notifications, configure your alert channels:

| Monitor | Trigger | Action | |---|---|---| | /_health | Non-200 or OK missing | Check systemctl status outline or docker ps; inspect Outline logs for DB/Redis errors | | Web UI | Non-200 or Outline missing | Check reverse proxy; verify Outline frontend assets are serving | | /api/auth.info | Non-200 or ok missing | Check SSO configuration; inspect OAuth environment variables | | SSL certificate | < 30 days to expiry | Renew certificate; check ACME automation on reverse proxy |

Alert after: 2 consecutive failures for HTTP monitors. 1 failure for the SSL monitor — certificate expiry warnings require action, not retries.

On-call consideration: Add Outline monitoring alerts to your on-call rotation. When an incident triggers, the first thing on-call engineers do is check runbooks — those runbooks need to be available exactly when everything else is broken.

Common Outline Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Outline process crash | /_health unreachable; alert within 60 s | | PostgreSQL goes down | Health check returns non-200; documents unreadable | | Redis goes down | Health check may degrade; real-time collaboration breaks | | Reverse proxy misconfiguration | Web UI monitor fires; /_health may be unreachable | | SSO provider configuration failure | Auth info monitor fires; users can't log in | | SSL certificate expires | SSL monitor alerts at 30-day threshold; all access blocked | | Outline upgrade failure | Health check non-200 or missing keyword; rollback needed | | S3/file storage misconfiguration | Health check stays green; image uploads and attachments fail | | DNS misconfiguration | All HTTP and SSL monitors fire simultaneously | | Memory exhaustion | Process restarts; health check temporarily unreachable |

A team wiki is easy to deprioritize when it comes to monitoring — documents don't expire, users aren't transacting money, and the consequences of downtime seem deferred. But during a production incident, a deployment procedure, or an employee's first week, Outline availability becomes urgent instantly. Vigilmon watches Outline's health endpoint, web UI, authentication API, and SSL certificate so your knowledge base is always available when your team needs it most.

Start monitoring Outline in under 5 minutes — register free at vigilmon.online.