How to Build Server Uptime Monitoring with Paradime and OpenClaw

Downtime is expensive. Every minute a critical endpoint is unreachable, your team burns time diagnosing the root cause—instead of shipping fixes. The gap between "something's wrong" and "here's the first clue" is where incidents spiral.

This guide walks you through building an automated server uptime monitoring system using Paradime and OpenClaw. You'll create a Python script that pings a list of endpoints on a 5-minute cron schedule, checks HTTP status codes and response times, and alerts your team on Slack when failures occur—with full error context for faster incident resolution.

By the end, you'll have a reproducible, minimal-fix monitoring pipeline that prioritizes time to first clue and keeps your infrastructure observable around the clock.

What is Paradime?

Paradime is an all-in-one AI platform purpose-built for data teams. It replaces dbt Cloud™ with a unified workspace for dbt™ development, CI/CD, production scheduling, observability, and collaboration. Think of it as Cursor for Data—a platform where analytics engineers code, ship, fix, and scale data pipelines from a single interface.

The three pillars of Paradime are:

• Code IDE — An AI-native development environment for dbt™ and Python, powered by DinoAI. It cuts dbt™ development time by 83%+.

• Bolt — A production orchestration engine for scheduling dbt™ commands, Python scripts, and multi-step workflows with built-in Slack/email/Teams notifications.

• Radar — A FinOps module that surfaces warehouse cost optimization opportunities for Snowflake and BigQuery.

For this guide, we'll lean heavily on Bolt—specifically its ability to run Python scripts on a cron schedule, manage environment variables securely, and send failure notifications to Slack.

Why Paradime for monitoring? Bolt schedules support Python scripts natively, meaning you can run custom HTTP health checks alongside your dbt™ pipelines—no separate infrastructure needed. One platform, one scheduling layer, full observability.

What is OpenClaw?

OpenClaw is an open-source autonomous AI agent with 68,000+ GitHub stars. Originally created by PSPDFKit founder Peter Steinberger, it runs as a self-hosted agent runtime on your own machine (Mac, Windows, Linux, or cloud VM). It connects AI models to your local files, tools, and messaging platforms—WhatsApp, Discord, Slack, iMessage, Telegram—through a unified gateway.

Key features relevant to our monitoring setup:

• Built-in cron scheduler — The Gateway includes a persistent scheduler that survives restarts and supports at (one-shot), every (interval), and cron (5-field expression) scheduling.

• 100+ AgentSkills — Pre-built skill bundles (like the uptime-monitor skill) that extend OpenClaw's capabilities.

• Multi-channel messaging — Route alerts to Slack, Discord, WhatsApp, or any of 25+ supported channels.

• Exec and file I/O tools — Run shell commands, read/write files, and interact with APIs directly from the agent runtime.

For this guide, we use OpenClaw's Python SDK (openclaw-py) and its cron infrastructure to complement Paradime's Bolt scheduler—giving you two independent monitoring layers.

Architecture Overview

Before diving into setup, here's how the pieces fit together:

Figure 1: Dual-layer uptime monitoring architecture with Paradime Bolt and OpenClaw Gateway.

This dual-layer approach gives you redundancy: if one scheduler misses a tick, the other catches it. The Python script in Bolt handles structured HTTP checks with detailed error context, while OpenClaw's uptime-monitor skill tracks streak data and dead/alive state.

Setup: openclaw-py + requests Library

Prerequisites

Step 1: Initialize your Python project in Paradime

In the Paradime Code IDE, create a pyproject.toml at the root of your dbt™ project:

Then install dependencies:

Note: When configuring a Bolt schedule, the first command must always be poetry install to ensure dependencies are resolved in the production environment. See the Paradime Poetry docs for details.

Step 2: Install OpenClaw (optional second layer)

If you want the dual-layer approach with OpenClaw running independently:

Verify the installation:

Script: Ping Endpoints, Check Status, Alert on Failures

Create scripts/uptime_monitor.py in your dbt™ project:

Decision Tree: Incident Response Flow

When the script detects a failure, here's the structured decision tree for your on-call team:

Figure 2: Incident response decision tree—from alert to first clue in under 60 seconds.

Environment Variables: ENDPOINTS_JSON, OPENCLAW_API_KEY, SLACK_WEBHOOK_URL

The monitoring script relies on three environment variables. Here's what each one does and how to configure it.

Variable Reference

ENDPOINTS_JSON Format

Configuring in Paradime Bolt

1. Navigate to Settings → Workspaces → Environment Variables

2. In the Bolt Schedules section, click Add New

3. Add each variable:

4. Click the Save icon (💾)

Tip: For bulk configuration, use the Bulk Upload option with a CSV file containing Key,Value columns. See Bolt Environment Variables docs for details.

Figure 3: Environment variable flow from Paradime Settings to the monitoring script at runtime.

Bolt Schedule: Cron Every 5 Minutes

Now wire everything together with a Bolt schedule. You have two options: the Paradime UI or schedules-as-code via YAML.

Option 1: Paradime UI

1. Navigate to Bolt from the left sidebar

2. Click + New Schedule

3. Configure the schedule:

4. Trigger Type: Select Scheduled Run

5. Command Settings — Add two commands in order:

6. Notification Settings:

7. Click Deploy

Option 2: Schedules as Code (YAML)

Create or update paradime_schedules.yml at the root of your dbt™ project:

File structure after setup:

Bonus: OpenClaw Cron Job (Second Layer)

For redundancy, add an OpenClaw cron job that runs independently:

Or using the JSON tool-call format:

Verify it's running:

Monitoring and Debugging

Once your schedule is live, monitoring the monitor itself is critical. Here's your structured approach.

Viewing Run History in Bolt

Figure 4: Step-by-step path to diagnosing a failed uptime check in Bolt.

Three Levels of Logs

Key Metrics to Track

Monitor these signals over time to catch degradation before it becomes an outage:

• Response time trends — A gradual increase in response_time_ms often precedes failures

• Failure frequency — Track how often each endpoint fails per day/week

• Alert latency — Time between endpoint failure and Slack alert delivery

• Script execution time — If the check itself starts exceeding the SLA threshold, add more parallelism or reduce the endpoint list

Accessing Logs

1. Navigate to Bolt → Click uptime-monitor-5min

2. In Run History, click the specific run

3. Scroll to Logs and Artifacts

4. Click the python scripts/uptime_monitor.py command to see:

Troubleshooting Common Issues

Issue 1: ENDPOINTS_JSON parsing errors

Symptom: Script exits with Failed to parse ENDPOINTS_JSON

Root Cause: JSON stored in environment variable contains unescaped quotes or newlines.

Fix: Ensure the JSON is stored as a single-line string. Validate with:

If storing in Paradime UI, paste the minified (single-line) JSON. Use jsonlint.com to validate before saving.

Issue 2: poetry install fails in Bolt

Symptom: First command fails with dependency resolution errors.

Root Cause: Missing pyproject.toml or version conflicts.

Fix:

1. Ensure pyproject.toml is committed to the main branch (or whichever branch the schedule targets)

2. Run poetry lock locally and commit the poetry.lock file

3. Check that the Python version constraint in pyproject.toml matches the Paradime runtime

Issue 3: Slack alerts not arriving

Symptom: Script logs show Slack alert sent for 2 failure(s) but no message appears in Slack.

Decision Tree:

Figure 5: Decision tree for diagnosing missing Slack alerts.

Issue 4: False positives from transient network errors

Symptom: Intermittent failures for endpoints that are actually healthy.

Fix: Add retry logic to the check_endpoint function:

Issue 5: OpenClaw cron job not firing

Symptom: openclaw cron list shows the job but openclaw cron runs uptime-5m shows no recent executions.

Root Cause: Gateway not running or cron job is disabled.

Fix:

Issue 6: Script times out on the SLA threshold

Symptom: Bolt marks the run as an SLA breach (notification sent for sla event).

Root Cause: Too many endpoints or endpoints with slow DNS resolution.

Fix:

• Reduce the per-endpoint timeout from 10s to 5s

• Use concurrent.futures.ThreadPoolExecutor for parallel checks

• Split endpoints across multiple schedules if the list exceeds ~50 URLs

Wrapping Up

You now have a production-grade server uptime monitoring system with two independent layers:

What you've built

1. A Python monitoring script that checks HTTP endpoints with detailed error context—not just "it's down" but "it returned a 503 with this response body."

2. A Bolt schedule that runs every 5 minutes with poetry install → python scripts/uptime_monitor.py, with Slack failure alerts and SLA monitoring.

3. Environment variable management using Paradime's secure variable store for ENDPOINTS_JSON, SLACK_WEBHOOK_URL, and OPENCLAW_API_KEY.

4. A structured incident response workflow with decision trees that get your on-call team from alert to first clue in under 60 seconds.

5. An optional OpenClaw second layer for redundancy, using the Gateway's built-in cron scheduler.

Time to first clue: the metric that matters

The entire design philosophy here is reproducibility and minimal fixes. Every failure alert includes:

• The exact endpoint that failed

• The HTTP status code (or timeout/connection error)

• The first 200 characters of the response body

• The response time in milliseconds

• The UTC timestamp of the check

That's your first clue—delivered to Slack within seconds of detection, every 5 minutes, 24/7.

Next steps

• Add response body assertions — Check for specific JSON keys or strings in the response, not just status codes.

• Track historical uptime — Write check results to your data warehouse using a dbt™ source, then build uptime dashboards.

• Escalation policies — Use Paradime's notification templates to escalate from Slack to PagerDuty after consecutive failures.

• Integrate with dbt™ pipelines — Run uptime checks as a pre-condition before triggering downstream dbt™ models that depend on external APIs.

For full documentation on Bolt scheduling, see the Paradime Bolt docs. For OpenClaw cron configuration, see the OpenClaw Cron Jobs docs.