Website Monitoring with GitHub Actions & Playwright

Introduction: The Hidden Dangers of Silent Failures

Many businesses operate under a false sense of security, assuming that since their website was recently launched or updated, it will continue to run flawlessly. However, modern web infrastructures are dynamic and fragile. A "silent failure" is the worst nightmare of any digital marketer or IT manager.

A minor CMS plugin update in the background, a small change in your third-party email provider's API, or a tweak to your captcha system can easily block your contact form or checkout page. The worst part? The website looks visually perfect. It returns an HTTP `200 OK` status, meaning classic ping-based uptime services will detect no errors. Only weeks later, after noticing a drop in leads or sales, does the team realize that user inputs have been failing silently.

This is where modern website monitoring becomes vital. It transitions the question from "Is the server responding?" to "Are the critical business flows actually working?" In 2026, maintaining a high-performance web presence requires testing inside a real browser to guarantee that bots, AI engines, and human users get a working experience.

The Subscription Cost Trap of Traditional SaaS

When looking for monitoring solutions, companies usually evaluate established tools like Pingdom, Uptime Robot, Datadog, or Statuscake. While useful, these SaaS tools carry significant drawbacks for growing agencies and multi-site owners:

What is Serverless Monitoring with GitHub Actions?

The alternative lies in a tool that development teams already use: GitHub Actions. GitHub Actions is a powerful automation platform integrated directly into GitHub repositories, designed to compile code, run tests, and deploy packages.

Crucially, it is also ideal for Serverless Website Monitoring. Workflows can be scheduled to run automatically on virtual machines using standard cron schedules (e.g., every 15 minutes or once a day).

The economics are highly attractive: GitHub offers 2,000 free runner minutes per month in every free account. Since a lightweight monitoring script (fetching URLs via cURL or executing a quick Playwright browser test) takes less than 15 to 30 seconds to complete, you can monitor dozens of sites in 15-minute intervals completely free of licensing and hosting fees.

Playwright for Real E2E Form & Checkout Tests

To validate business flows, we utilize Playwright. Developed by Microsoft, Playwright is a modern open-source framework for E2E-Testing, enabling programmatic control of real, Headless Browsers (Chromium, Firefox, and WebKit).

Playwright launches a browser instance, navigates to the page, clicks cookie banners, targets input selectors, types test data, and clicks the submit button. It then verifies that a success element is rendered in the DOM. If the form script fails, the test reports a failure immediately.

Here is a basic Playwright test script written in JavaScript to check contact form submissions:

import { test, expect } from '@playwright/test';

test('submit contact form and verify success', async ({ page }) => {
  // 1. Navigate to form page
  await page.goto('https://www.pragma-code.de/en/contact');

  // 2. Accept cookies if visible
  const cookieBtn = page.locator('#cookie-accept-btn');
  if (await cookieBtn.isVisible()) {
    await cookieBtn.click();
  }

  // 3. Populate form fields
  await page.fill('input[name="name"]', 'Monitoring Bot');
  await page.fill('input[name="email"]', '[email protected]');
  await page.fill('textarea[name="message"]', 'Automated system check. Please ignore.');

  // 4. Submit
  await page.click('button[type="submit"]');

  // 5. Verify success state
  const successMessage = page.locator('.form-success-message');
  await expect(successMessage).toBeVisible({ timeout: 5000 });
});

The 5 Pillars of a Complete Website Audit

A robust monitoring strategy combines multiple checks into a unified pipeline. When building monitoring systems for our clients, we structure them around five core pillars:

Comparison: Traditional SaaS vs. Serverless Monitoring

To evaluate costs, control, and code integration, here is how traditional SaaS platforms compare to serverless GitHub Workflows:

The Technical Execution Pipeline

The execution lifecycle is entirely serverless: runner nodes are spun up dynamically on-demand, run the checks, and terminate immediately afterwards, leaving no persistent infrastructure to maintain.

Step-by-Step Configuration Guide

To set up this pipeline, add this YAML config under `.github/workflows/check-contact-forms.yml`:

name: Daily Contact Form Check

on:
  schedule:
    - cron: '10 0 */3 * *' # Every 3 days at 00:10 UTC
  workflow_dispatch: # Enable manual run via GitHub UI

jobs:
  check-forms:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Playwright & Dependencies
        run: |
          npm install playwright
          npx playwright install --with-deps chromium

      - name: Run Test Script
        run: |
          node .github/scripts/check_contact_forms.js

      - name: Upload Failure Screenshots
        if: failure()
        uses: actions/upload-artifact@v4
        with:
          name: error-screenshots
          path: .github/scripts/*.png

Sensitive keys like SMTP passwords should be stored securely as GitHub Secrets and passed to your scripts as environment variables.

Best Practices for Robust Monitoring

To avoid false alarms and ensure stable workflow execution:

• Use Stable Selectors: In Playwright, avoid using fragile styling classes that change frequently. Instead, rely on robust IDs or accessible roles (e.g., page.getByRole('button', { name: 'Submit' })).
• Set Practical Timeouts: Avoid excessive wait times. Set timeouts to 5-10 seconds to discover network bottlenecks quickly.
• Commit Logs to Git: For performance charts, commit JSON logs back to your repository, building a lightweight performance history directly in Git.

Conclusion: The Future of Monitoring Belongs to Code

Serverless monitoring via GitHub Actions and Playwright provides an efficient, highly customizable, and cost-effective approach to keeping your websites healthy. By integrating monitoring into code, you maintain control over your tools and align checks with your business goals.

For digital agencies and growing SMBs, this setup is a massive competitive advantage: it drastically improves support quality while keeping operational SaaS costs at zero.

Frequently Asked Questions (Glossary)