Autometa

The real-time layer: presence, push and webhooks you can trust

August 21, 2026·10 min read
Cover illustration for “The real-time layer: presence, push and webhooks you can trust”

Most CRMs are secretly documents. The screen you are looking at is a snapshot from whenever you loaded it, and the truth has been drifting away ever since — which is why sales floors develop the refresh-button reflex, and why two reps occasionally call the same lead within ten minutes of each other. Autometa CRM is built on a different assumption: a system of record that many people work in simultaneously should behave like a multiplayer app. This post covers the real-time layer that makes that true, and the API surface that extends it into your own stack.

Why a CRM should behave like a multiplayer app

The moment two people share a pipeline, staleness becomes a coordination bug. A deal moves stage on one screen and not another; a lead gets claimed twice; a manager reads a board that stopped being true an hour ago. Real-time sync makes every open view a live view — a stage change, a new note, an inbound WhatsApp message appears on every screen watching that record, instantly, with no refresh.

Presence indicators close the other half of the loop: you can see who is viewing a record right now, the same way you see a teammate’s cursor in a shared doc. The two-reps-one-lead collision stops happening not because of a locking policy but because both reps can see each other standing there.

Push, not poll

Notifications ride the same live channel. When a hot lead submits a form, when a deal you own goes quiet, when an approval needs you — the notification is pushed the moment the event happens, not discovered on the next page load. The practical effect is that speed-to-lead workflows and approval gates actually run at the speed the automation engine promises: the human link in the chain is notified in seconds, because the notification system is an event stream, not an inbox that gets checked.

Background job queues: heavy work off the hot path

Real-time responsiveness is only possible if slow work never blocks the interactive path. Bulk imports, campaign sends, payroll runs and large automation batches are handed to background job queues: the request returns immediately, the job runs with retries and progress tracking, and the UI streams status as it goes. A 40,000-row CSV import or a broadcast to an entire segment never freezes the screen of the person who started it — or anyone else’s.

Webhooks with a signature you can verify

Everything above stays inside the product; webhooks are where the event stream leaves the building. Any record event or workflow step can fire an HTTP payload at your own services — and every payload is HMAC-signed, so your endpoint can verify that the request genuinely came from Autometa CRM and was not tampered with in transit. Verify the signature, and spoofed or replayed calls are rejected before they touch your logic.

  • HMAC signatures on every delivery — authenticate the source, not just the shape of the payload
  • Automatic retries with backoff when your endpoint is down, so a deploy on your side loses nothing
  • A per-endpoint delivery log — every attempt, status code and response time, so "did it fire?" is a lookup
  • Fired from workflows too — a stage change can notify your billing service with zero middleware

REST API keys for the rest

Webhooks push events out; the REST API lets your systems reach in. Scoped API keys give each integration exactly the access it needs — read-only for the analytics pipeline, write access to leads for the enrichment service — under the same RBAC model that governs human users. Keys are auditable and revocable individually, so rotating one integration never disturbs another.

One discipline, shared with Synkly

If this architecture sounds familiar, it is the same real-time discipline that keeps Synkly’s watch parties frame-accurate — server-authoritative state, low-latency channels, clients that reconcile instead of guessing. We wrote about that engine in "Getting playback sync under 60ms". Building it once and holding both products to it is the studio bet: infrastructure this hard should be paid for once and leveraged everywhere. The pipeline board that never goes stale and the movie that never drifts are the same code path wearing different clothes.

Enjoyed this? There's more where that came from.

New posts on product, engineering and the business every few weeks.