SignalrySignalry

API-first event ingestion for modern SaaS

Send events explicitly from your backend.
Store immutable JSON. Inspect and query with confidence.

Create accountLog in

System behavior

Introduce Signalry when backend teams need a durable event ledger for incidents, support, or audits across services.

Events are discrete backend facts (e.g. account.created, subscription.updated) with JSON payloads and minimal assumptions.

Ingestion is explicit by design: only POSTed events become part of the record, keeping the write path deterministic.

Immutability is intentional; corrections are modeled as new events rather than retroactive edits.

Raw JSON is preserved to prevent schema drift and retain original context.

Signalry sits between production services and downstream analytics or ETL; logs and metrics capture telemetry, while Signalry preserves canonical event payloads.

Inspection happens after ingestion so storage remains stable; analysis is performed later via dashboard/API alongside logs, metrics, and traces.

API request

POST /v1/events
Authorization: Bearer sk_live_9a32d0b1
Content-Type: application/json

{
  "type": "user.signup",
  "timestamp": "2024-08-10T14:32:11Z",
  "payload": {
    "userId": "user_123",
    "plan": "starter",
    "region": "eu-west-1"
  }
}

System guarantees

Immutable event storage

Raw JSON preserved

Organisation-scoped by default

These invariants are enforced at ingestion and storage boundaries.

WHEN SHOULD I USE SIGNALRY?

Use Signalry when you need a deterministic event ledger for audits, incident investigation, compliance review, or reconstructing system behavior across services.

  • Incident investigation and post-incident forensics
  • Audit trails and compliance evidence
  • Reconstructing behavior after deployments
  • Traceability across multi-service workflows

Logs and metrics describe system telemetry, and analytics summarizes behavior; neither preserves canonical event payloads over time.

Signalry acts as the source-of-truth event ledger that downstream analytics or ETL can consume without mutating the record.

What Signalry is not

Not an analytics dashboardNot a metrics productNot a webhook receiverNot a no-code tool

Signalry stores explicit domain events alongside logs, metrics, and traces. It does not compute aggregates, dashboards, or workflow automation.

Analytics and ETL consume the event record downstream; they do not live inside Signalry.

Core flow

Send / Store / Inspect

Signalry keeps the lifecycle narrow so the event record remains explicit and auditable.

Introduce it when your backend needs a shared, deterministic record of domain events before downstream analytics or ETL.

Events should represent discrete backend facts with JSON payloads, not derived metrics or client-side tracking.

Send

Defines the explicit ingress point for backend events.

Explicit POSTs keep ingestion deterministic; nothing is recorded unless you send it.

Separating ingestion from storage and inspection keeps the write path narrow and predictable.

  • POST /v1/events from trusted services.
  • Payload shape stays under backend control.
  • No inference or passive collection.

Store

Preserves the raw record as the system source of truth.

Immutability trades editability for auditability; changes become new events.

Storage is isolated so retention and auditability stay stable regardless of query tooling.

  • Immutable, append-only history.
  • Timestamped at ingestion.
  • Organisation-scoped by API key.
  • Raw JSON stored without transformation.

Inspect

Enables deterministic inspection when you need to reconstruct behavior.

Inspection is downstream to keep writes minimal and avoid inline analysis.

Querying is separated from ingestion so inspection never alters the event record.

  • Developer-focused dashboard.
  • Tables, payload views, and filters.
  • Inspection, debugging, and traceability.