SrotaX logo Talk to an architect
Multi-tenant SaaS Temporal-native Deterministic aggregation

SrotaX is the production-grade automation fabric for multi-tenant SaaS.

SrotaX fuses deterministic aggregation, resilient streaming, and Temporal workflows into a single platform. Build rules, pipelines, and connectors once—run them safely for every tenant with strict isolation, observability, and zero in-place mutation.

Book a demo See how it works

Deterministic by design

SrotaX’s evaluator enforces strict aggregation semantics, ensuring predictable outcomes across rules, streaming pipelines, and Temporal activities.

Strict typing · IR + visitor pattern · Deterministic replay
Tenant isolation
Full
Retries & backoff
Built-in
Connectors
Universal

Four-layer platform

SrotaX separates evaluation, orchestration, and execution so teams gain determinism, safety, and scale without reinventing workflow engines.

SrotaX Core (Aggregation Engine)

Full aggregation operator coverage with strict typing and deterministic evaluation. Generates an internal IR with visitor pattern for predictable rewrites.

Expression tree · Deterministic

Rule Engine

Versioned JSON/DSL rules with composition (rule sets/groups), nested expressions, and consistent error semantics. Reusable across pipelines and workflows.

Strongly typed · Composable

Streaming Engine

Microbatch or streaming pipelines triggered by connectors. Routing, throttling, batching, and DLQ powered by the same evaluator.

Kafka · CDC · Webhooks

Workflow Layer (Temporal)

SrotaX logic runs as Temporal activities. Temporal owns retries, backoff, cancellation, and saga patterns; SrotaX focuses on decisions and connectors.

Deterministic replay

Universal connector architecture

One execution model for every integration. Shared logging, metrics, retries, and error taxonomy keep behavior consistent across tenants.

Execution types
http — generic REST/GraphQL
javaBean — Spring beans for SDKs/DBs
pipelineCall — invoke another pipeline/ruleset
httpServer — inbound webhooks
polling — periodic pull
reactiveStream — Kafka/PubSub/CDC
timer — cron/delays

Each connector defines config schema, operations with input/output schemas, and shared retry/timeout policies. Secrets are only referenced by ID.

Shared behaviors
Retries & timeouts
Circuit breakers, jittered backoff, tenant-aware limits.
Tracing & logs
Correlation IDs with tenant, pipeline, workflow IDs.
Metrics
Latency, throughput, DLQ depth, connector failures.
Error taxonomy
Permanent vs transient, DLQ or retry with fallback.

Multi-tenant SaaS guardrails

Isolation and governance are default. Every execution path carries tenant identity, quotas, and audit trails.

Tenant isolation

Separate namespaces for connectors, rules, pipelines, executions, and secrets. Tenant IDs flow into logs, traces, and workflow context.

Zero cross-tenant leakage

RBAC & audit

Owner/Admin/Developer/Viewer/Support roles with fine-grained permissions. All config changes are versioned and audit logged.

Least privilege

Secrets management

Per-tenant Vault/KMS-backed storage. Runtime references secret IDs only; sensitive fields masked in logs and traces.

Never log secrets

Quotas & limits

Per-tenant caps for events/sec, pipeline runs, connector calls, and storage. Soft/hard limits prevent noisy neighbors.

Adaptive rate limits

Resiliency & safety nets

Every layer has clear failure semantics. Temporal covers workflow retries; SrotaX covers connector retries, idempotency, and DLQs.

Reliability patterns
  • Jittered backoff with circuit breakers; classify permanent vs transient faults.
  • Idempotent activities and replay-safe evaluation to avoid double-processing.
  • DLQ per tenant with simple replay and visibility metrics.
  • Backpressure for streams: consumer lag, batch sizing, flow control.
  • Partial failure handling with compensating actions and sagas.
Operations ready
  • Health checks and graceful shutdown for long-running streams.
  • Structured logs: tenant, pipeline, workflow, correlation IDs with field masking.
  • Metrics: latency, retries, connector failures, queue lag, DLQ size.
  • Distributed tracing across Temporal, activities, and connectors.

Versioning & safe change management

Immutable versions and staged releases keep production stable while teams ship fast.

Draft → Published → Deprecated

Rules, pipelines, and connectors are immutable once published. New edits create new versions; traffic canary/blue-green between them.

No surprise mutations

Safe rollouts

Dev → Staging → Prod promotion with sample-data tests, dry runs, and diff views before activation.

Rollback ready

Cost & usage visibility

Per-tenant dashboards for rate limits, connector calls, and storage. Chargeback-friendly metrics to spot noisy neighbors.

Transparent usage

Architecture in motion

Clean separation of evaluator, engines, and orchestration lets SrotaX stay deterministic while scaling horizontally.

      ┌──────────────┐    ┌─────────────────────┐    ┌─────────────────────┐
      │  Connectors  │    │   SrotaX Core IR    │    │     Temporal WF      │
      │ http, kafka, │───▶│ Aggregation engine  │───▶│ Activities, retries, │
      │ polling, etc │    │ evaluator + typing  │    │ backoff, sagas       │
      └─────┬────────┘    └──────────┬──────────┘    └──────────┬──────────┘
            │                        │                          │
            │                        ▼                          │
            │                ┌──────────────┐                   │
            │                │  Rule Engine │ (JSON/DSL,        │
            │                │  versioned)  │ composition)      │
            │                └──────┬───────┘                   │
            │                       ▼                           │
            │                ┌──────────────┐                   │
            ▼                │ Streaming    │◀──────────────────┘
      Tenants/Logs/Secrets   │ Engine       │ microbatch/stream
      RBAC/Quotas            └──────────────┘ routing, DLQ, HPA

Example connector & pipeline

Universal execution model with typed schemas and Temporal-backed delivery.

Connector (http)

{
  "name": "zendesk-search",
  "execution": { "type": "http" },
  "configSchema": { "$ref": "#/schemas/zendeskAuth" },
  "operations": {
    "searchTickets": {
      "inputSchema": { "type": "object", "properties": { "query": { "type": "string" } } },
      "outputSchema": { "type": "array", "items": { "$ref": "#/schemas/ticket" } },
      "execution": {
        "method": "GET",
        "url": "https://{{subdomain}}.zendesk.com/api/v2/search.json",
        "retry": { "strategy": "jitteredBackoff", "maxAttempts": 5 }
      }
    }
  }
}

Pipeline invoking rules

{
  "name": "ticket-triage",
  "trigger": { "type": "reactiveStream", "topic": "tickets" },
  "steps": [
    { "type": "ruleSet", "ref": "triage-v3" },
    { "type": "connector", "ref": "zendesk-search.searchTickets" },
    { "type": "pipelineCall", "ref": "notify-oncall" }
  ],
  "idempotency": { "key": "{{event.id}}" },
  "dlq": { "topic": "tickets-dlq" }
}

Ready to see SrotaX live?

Schedule a deep dive to map SrotaX to your stack, compliance needs, and tenant model. We respond within one business day.

Book a demo View capabilities