Monitoring Automatisch with Vigilmon

Automatisch is an open-source workflow automation platform built on Node.js and TypeScript — a self-hosted alternative to Zapier and Make that lets you connect 100+ services (Slack, GitHub, Gmail, Notion, HubSpot, Airtable, and more) into trigger/action flows without per-task pricing. When Automatisch goes down, your automation flows stop silently. Vigilmon keeps watch: web UI availability, built-in health API, worker service health, SSL certificate expiry, and heartbeat monitoring for flow execution — all from one dashboard.

What You'll Set Up

• HTTP uptime monitor for the Automatisch web UI (port 3000)
• REST API health check for /api/v1/healthcheck (application + database connectivity)
• Worker service health via the same /api/v1/healthcheck endpoint
• SSL certificate expiry alerts for HTTPS-proxied deployments
• Heartbeat monitoring for Automatisch flow execution (polling triggers and webhook receiver)

Prerequisites

• Automatisch running via Docker Compose or Kubernetes (default port 3000)
• HTTPS proxy configured (Nginx or Traefik) for production deployments
• A free Vigilmon account

Step 1: Monitor the Automatisch Web UI

The Automatisch web interface is the first thing that fails when the Node.js process crashes or the container loses its port binding. Add an HTTP monitor to catch it:

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter your Automatisch URL: https://automatisch.yourdomain.com (or http://your-server:3000 for a local deployment).
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

If you want a more precise check, target the login page directly:

https://automatisch.yourdomain.com/sign-in

The login page renders only when the Node.js server is healthy and the frontend build is served correctly, making it a reliable proxy for overall web UI health.

Step 2: Monitor the /api/v1/healthcheck Endpoint

Automatisch ships with a built-in REST health endpoint that verifies both the application server and its database connection. This is more reliable than the web UI check alone because it validates the full stack:

1. Add a new HTTP / HTTPS monitor in Vigilmon.
2. Set the URL to https://automatisch.yourdomain.com/api/v1/healthcheck.
3. Set Check interval to 1 minute.
4. Set Expected HTTP status to 200.
5. Under Response body contains, enter "healthy" or "ok" to assert that the response payload confirms a healthy state.
6. Click Save.

You can verify the endpoint manually before adding the monitor:

curl -s https://automatisch.yourdomain.com/api/v1/healthcheck | jq .

A healthy response looks like:

{
  "status": "healthy",
  "services": {
    "database": "connected",
    "app": "running"
  }
}

If the database connection drops, this endpoint will return a non-200 status or a degraded payload — and Vigilmon will fire an alert before your users notice broken flows.

Step 3: Monitor the Automatisch Worker Service

Automatisch runs a separate worker process that executes the action steps in each flow. If the worker crashes, existing flows will queue up or silently drop executions without any visible error in the UI.

The same /api/v1/healthcheck endpoint covers worker health — the health check verifies that the Node.js worker responsible for processing automation step executions is running alongside the main application.

To give the worker check a distinct identity in Vigilmon:

1. Add another HTTP / HTTPS monitor.
2. Set the URL to https://automatisch.yourdomain.com/api/v1/healthcheck.
3. Name it Automatisch Worker Health to distinguish it from the main app check.
4. Set Check interval to 1 minute.
5. Add a response body assertion: "worker" present in the response, if your Automatisch version surfaces worker status.
6. Click Save.

For deployments running the worker as a separate container (the automatisch-worker service in the official Docker Compose), confirm its internal port is healthy by checking the shared API endpoint — the main application will report worker connectivity failures in its health response.

Step 4: SSL Certificate Alerts

Automatisch is typically deployed behind Nginx or Traefik, which handle TLS termination. Let's Encrypt certificate auto-renewal can fail silently — a lapsed certificate will block all browser access to your flows and API integrations.

Enable SSL monitoring on your existing Automatisch HTTP monitors:

1. Open the Automatisch web UI monitor created in Step 1.
2. Enable Monitor SSL certificate in the SSL section.
3. Set Alert when certificate expires in less than 21 days.
4. Click Save.

Repeat for the /api/v1/healthcheck monitor if it runs on a separate subdomain.

For Nginx-proxied deployments, verify your renewal config:

# Test the renewal process (dry run)
certbot renew --dry-run

# Check current certificate expiry
certbot certificates

A 21-day Vigilmon alert window gives you enough runway to investigate renewal failures before the certificate actually expires.

Step 5: Heartbeat Monitoring for Flow Execution

Automatisch uses polling-based triggers for services that don't support webhooks (checking Gmail every 15 minutes, polling an RSS feed, etc.). If the polling scheduler stops — due to a worker crash, a database lock, or a memory issue — no error surfaces in the UI. Flows just silently stop running.

Use Vigilmon's heartbeat monitor to catch this:

1. In Vigilmon, click Add Monitor → Cron Heartbeat.
2. Set the expected ping interval to match your shortest polling interval (e.g. 15 minutes for a 15-minute polling flow).
3. Copy the heartbeat URL (e.g. https://vigilmon.online/heartbeat/abc123).

Now configure Automatisch to ping that heartbeat. The cleanest way is a dedicated Automatisch flow that triggers on a schedule and calls an HTTP action:

• Trigger: Schedule (every 15 minutes)
• Action: HTTP Request to https://vigilmon.online/heartbeat/abc123 (GET)

When this flow runs successfully, it pings Vigilmon and resets the heartbeat timer. If Automatisch stops processing flows, the ping stops — and Vigilmon alerts you after the expected interval passes.

You can also verify the webhook receiver is alive with a TCP port check:

1. Add a TCP Port monitor in Vigilmon.
2. Set the host to your Automatisch server hostname.
3. Set the port to 3000.
4. Click Save.

This catches port-binding failures even if the HTTP health checks are behind a proxy.

Step 6: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook endpoint.
2. Set Consecutive failures before alert to 2 on UI and worker monitors — a container restart takes a few seconds and may cause one probe to fail transiently.
3. Use Maintenance windows to suppress alerts during Automatisch upgrades:

# Pause the monitor during a Docker image update
curl -X POST https://vigilmon.online/api/maintenance \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"monitor_id": "abc123", "duration_minutes": 10}'

docker compose pull && docker compose up -d

# Maintenance window expires automatically

Summary

| Monitor | Target | What It Catches | |---|---|---| | Web UI | https://automatisch.domain.com | Node.js crash, container failure | | App health API | /api/v1/healthcheck | Database disconnection, app errors | | Worker health | /api/v1/healthcheck | Worker crash, stalled executions | | SSL certificate | Main domain | Let's Encrypt renewal failure | | Heartbeat flow | Vigilmon heartbeat URL | Polling scheduler stopped, flows not running | | TCP port | :3000 | Port binding failure, proxy unreachable |

Automatisch gives you full data ownership and unlimited automation flows — but self-hosting means you own the uptime too. With Vigilmon watching the web UI, health API, worker, and a canary heartbeat flow, you'll catch Automatisch failures in seconds rather than discovering them when a critical integration silently stopped running hours ago.