DEV Community: SignalWatch

An invoice PDF that never leaves the browser

SignalWatch — Sun, 04 Oct 2026 02:40:43 +0000

I wanted a one-page invoice I could send without opening a billing app, and without pasting a client's name into someone else's database.

Clearquire is a free page that does that. You type the seller, the client, the lines, an optional tax rate, notes, and payment instructions. The browser writes an A4 PDF. You download it and email it yourself.

Nothing in the form is uploaded. There is no account. An optional draft can sit in this browser's localStorage, and that switch starts off. A logo (PNG, JPEG, or WebP, up to 2 MB) is resized in the browser and drawn on the PDF.

There are two templates. Minimal keeps the page quiet. Modern puts an accent colour in a header band. GBP is the default currency. USD, EUR, and a longer list are there too. Symbols and decimal separators follow the browser language.

It is a layout tool. It does not choose a VAT rate, file a return, take a payment, or connect to a bank. The page says that plainly.

The useful part, if you build similar tools, is the boundary. The server never receives the invoice. The PDF is generated in the page. That is the whole product.

Fail a GitHub Actions job when a vendor page changes

SignalWatch — Tue, 29 Sep 2026 00:43:53 +0000

A scheduled workflow can fail when a vendor pricing page, docs page, or changelog changes its text. The job below reads the latest event from a SignalWatch monitor and exits 1 if that event is a content change from the last six hours.

This is for public, server-rendered pages. It does not render JavaScript, log in, or take a screenshot. If the price only exists after a client-side render, the monitor will not see it.

The workflow

Save this as .github/workflows/upstream-drift.yml. It uses GNU date, which ubuntu-latest provides.

name: upstream-drift
on:
  schedule:
    - cron: "0 */6 * * *"
  workflow_dispatch:
jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - name: Fail if the vendor page changed in the last 6h
        env:
          KEY: ${{ secrets.SIGNALWATCH_KEY }}
          CHECK_ID: "123"
        run: |
          latest=$(curl -fsS "https://signalwatch.litework.me/api/v1/checks/$CHECK_ID/events?limit=1" -H "X-API-Key: $KEY")
          event=$(echo "$latest" | jq -r '.[0].event // "none"')
          when=$(echo "$latest" | jq -r '.[0].created_at // "1970-01-01T00:00:00Z"')
          age=$(( $(date +%s) - $(date -d "$when" +%s) ))
          if [ "$event" = "changed" ] && [ "$age" -lt 21600 ]; then
            echo "::error::Upstream page changed"
            echo "$latest" | jq -r '.[0].diff'
            exit 1
          fi
          echo "no recent change ($event, ${age}s ago)"

Add the API key as a repository secret named SIGNALWATCH_KEY. Replace 123 with the monitor id from the dashboard.

The events endpoint returns the newest row first. On that API a content change is event: "changed". Webhook deliveries for the same moment use content.changed. diff is a unified text diff. change_ratio is changed characters divided by the longer of the two texts.

Create the monitor

Free covers 3 monitors at a 15 minute interval, no card: https://signalwatch.litework.me/

Two settings matter more than the schedule:

A CSS selector, so you hash the price table or the docs section instead of the whole document.
An ignore regex, so a line like "updated 3 minutes ago" does not fail the build.

There is a public monitor on the Hacker News front page if you want to read real diffs before creating an account: https://signalwatch.litework.me/live.html

Curl, Python, and signature checks, including this workflow, are on the examples page: https://signalwatch.litework.me/examples.html

What a failure looks like

The Actions log prints the diff and the job goes red:

--- before
+++ after
@@ -3 +3 @@
-Starter $10/mo
+Starter $14/mo

Downtime is a different event (down, then up when the fetch recovers). Those do not fail this job. Extend the if if a failed fetch should fail CI as well.

Limits

Public http(s) URLs only. Fetches are capped at 2 MB and follow up to 3 redirects. JavaScript is not executed.

Email, Slack, Discord, and HMAC-signed JSON are the push path. This workflow is the pull path, for a repo that already lives in Actions and wants upstream drift to turn the badge red.

The same idea as a push into n8n: https://dev.to/signalwatch/run-an-n8n-workflow-when-a-pages-text-changes-38m0

Run an n8n workflow when a page's text changes

SignalWatch — Thu, 24 Sep 2026 04:12:02 +0000

The last post was the product. This one is the wiring: an n8n Webhook trigger that runs when a public page's text changes, with the unified diff in the payload.

Screenshot monitors are built for an inbox. If you already live in n8n, you want a POST you can branch on.

What you need

An n8n instance (cloud or self-hosted) with a Webhook node
A public URL whose text you care about: a pricing page, a changelog, a status page, a terms page
A SignalWatch monitor. Free is 3 monitors at 15 minutes, no card: https://signalwatch.litework.me/

It does not render JavaScript and it does not log in. If the price only exists after a client-side render, this will not see it. Server-rendered HTML is the fit.

1. Catch the webhook in n8n

Add a Webhook node. Method POST. Copy the production URL (the test URL is only for a trial run).

n8n's default Webhook output looks like { headers, params, query, body }. The event fields are under body.

2. Point a monitor at that URL

Create a monitor for the page. Two noise controls matter more than the schedule:

CSS selector, so you hash one region (the price table) instead of the whole document
Ignore regex, so "updated 3 minutes ago" does not page you

Paste the n8n production URL into the monitor's webhook URL. Press Send test alert. The Webhook node receives an event with "event": "test". Map your later nodes from that payload so you are not waiting for a real change.

3. Branch on the event

{{$json.body.event}}

If your Webhook node is set to put the JSON at the top level, drop the .body.

Event	What to do
`content.changed`	`{{$json.body.diff}}` is a unified diff. `change_ratio` is how much of the text moved. Post the diff to Slack, append a row, or hand it to an LLM node for one sentence.
`check.down`	The fetch failed. `error` says why.
`check.up`	It recovered.
`test`	The button. Use it to pin the schema.

A real change looks like this:

{
  "check_id": 123,
  "name": "Competitor pricing",
  "url": "https://example.com/pricing",
  "event": "content.changed",
  "change_ratio": 0.031,
  "diff": "--- before\n+++ after\n@@ -3 +3 @@\n-Starter $10/mo\n+Starter $14/mo"
}

Slack and Discord webhook URLs are special-cased: paste https://hooks.slack.com/... or a Discord webhook and you get a formatted message with a fenced diff, not this raw JSON. Everything else, including n8n, gets the JSON.

4. Check the signature if the workflow does something expensive

Every delivery sends:

X-SignalWatch-Event
X-SignalWatch-Delivery (new id per attempt)
X-SignalWatch-Timestamp
X-SignalWatch-Signature: sha256=...

The signature is HMAC-SHA256 of timestamp + "." + raw body, using the webhook signing secret on the dashboard. Reject timestamps older than five minutes. An n8n Crypto node can do the compare before you open a ticket or spend an LLM call.

Deliveries are queued. If n8n is down, they retry with backoff for hours instead of dying inside the poll.

See a real diff first

There is a public monitor on the Hacker News front page, scoped to story titles, so you can read actual diffs with no account: https://signalwatch.litework.me/live.html

Curl, Python, and Node signature checks are on the examples page: https://signalwatch.litework.me/examples.html#n8n

The product post, if you want the constraints in one place: https://dev.to/signalwatch/i-wanted-the-diff-not-a-screenshot-a-small-url-change-api-1aoh

If you wire this up, I want to know which page you pointed it at and which noise filter you actually needed.

I wanted the diff, not a screenshot: a small URL-change API

SignalWatch — Thu, 24 Sep 2026 04:05:26 +0000

I kept wanting one thing: paste a public URL, and get a unified diff when the text changes — in email, Slack, or a JSON webhook I can point at n8n.

Screenshot tools are built for that inbox moment ("something changed, go look"). Self-hosting changedetection.io is the right answer if you want a container. I wanted the hosted, boring version: visible text, a CSS selector, an ignore regex, and a signed webhook.

So I built SignalWatch.

What it does

Polls a public URL (15 min on the free plan)
Hashes the visible text, optionally scoped to a CSS selector
Strips noise with an ignore regex, ignore-line-order, and a minimum change ratio
Sends email, a Slack/Discord message with a diff block, or HMAC-signed JSON
Keeps the event history so the dashboard can show what actually moved

What it does not do

It does not render JavaScript, log in, or take screenshots. If the price only exists after client-side rendering, it will not see it.

There is a public monitor on the Hacker News front page so you can see real diffs without an account: live sample.

Free tier is 3 monitors, no card.

I would like to know what you would watch with it, and which noise filter you actually need.