Tabla and Make: a webhook into a scenario

A Make scenario starts when something arrives. Give it a Tabla webhook and "something" is a record changing: an order created, a status crossed, a record deleted. Two modules carry the whole loop — a Custom webhook to receive, and an HTTP module when the scenario writes back.

Module names only, no screenshots — Make redraws its interface often enough that pictures of it lie within a year. The example: a new order in the Orders table posts to the fulfillment system, then gets its assignee set.

Get an address from Make

1. In a new scenario, make the first module Webhooks → Custom webhook.
2. Add a new hook, name it, and copy the address Make shows — the shape is https://hook.eu2.make.com/….

That address is public, which suits Tabla's rule that a webhook URL must be reachable from the public internet. It's also unauthenticated — anyone holding it can POST — which is why the signature section below exists.

Point a Tabla webhook at it

In the database's Webhooks tab, Add webhook:

When a record is created in Orders → Send to the Make address.

The demo database's own webhook is exactly this, named "New orders → automation". Narrow it later with conditions — Total is greater than 1000, only paid orders, whatever the scenario is actually for.

Teach Make the shape

A Custom webhook determines its data structure from the first request it sees. So: put the hook in its listening state (Make shows the hook as waiting), then click Send a test on the Tabla webhook's page.

The test delivery is built for precisely this step: sample values, but your table's real field names — Status, Total, Customer email — so the structure Make learns is the structure real deliveries will have, not a placeholder you'd then re-map. After the test lands, Make's mapping panels offer the payload's fields: event, record_id, after.fields.Status, the lot. The payload reference explains each one.

Two mapping habits that survive contact with colleagues:

• Key cells by field id for production. The Tabla webhook's Cells keyed by toggle switches payloads from name-keyed (readable) to id-keyed (rename-proof). A name-keyed mapping breaks the day someone renames Customer email; an id-keyed one doesn't. Re-determine the hook's data structure after flipping it.
• Branch on test and dedupe on delivery_id. Filter out test = true before anything real, and remember processed delivery_ids (a Data store works) — delivery is at-least-once, so the same delivery can arrive twice around a timeout.

Write back through the API

To act on the record — set the assignee, stamp a confirmation — add an HTTP → Make a request module:

• URL: https://tabladb.com/api/tables/tbl_sf6ir2p5y3uc/records
• Method: PATCH
• Headers: Authorization: Bearer key_xxxx.your-secret
• Body type: Raw, content type JSON
• Request content:

{
  "records": [
    {
      "id": "<map record_id from the webhook here>",
      "fields": { "Assigned to": "omar@sakkaraplants.com" }
    }
  ]
}

The webhook already carried record_id, so there's nothing to search for — one PATCH, done. The same module shape covers creating records (POST, no id) and everything else in writing over the API.

Mind the loop: that PATCH is an update, and an a record is updated webhook on the same table would fire for it. Trigger on one field, write to another, and use watched fields so the circle can't close.

Go live, and what failure looks like

Turn the scenario on; the hook now accepts deliveries the moment they're sent. When the scenario is off or broken, Tabla's side stays honest: the attempt fails, retries on the published schedule — 10 seconds, 1 minute, 5 minutes — and the failure sits in the ledger with a Replay button for after you've fixed things. Twenty straight failures pause the webhook, loudly.

Make acknowledges deliveries as they arrive and runs the scenario after — long scenarios don't turn into timeouts on Tabla's side.

If the scenario does real work, verify the signature — the headers are on every delivery, including tests. For the architecture of the whole pattern, the concept piece is database webhooks with Make and n8n.