Feature · Low-Code Workflow

A low-code workflow builder with the execution engine that actually runs.

Trigger-to-action semantics, 180-plus node types, branching logic, loops, error handlers, dry-run test mode, sub-second execution on live CRM data, version history with git-like diffs, three environments per tenant, and immutable audit on every run.

The workflow runtime question

A workflow tool is only as good as its runtime.

A low-code workflow tool's canvas is the surface the user sees; the runtime is where the work actually happens. The canvas can look impressive and still produce a tool that cannot run reliably in production: slow execution, dropped runs under load, silent failures, no way to inspect what happened, no way to roll back a bad version. Buyers who evaluate low-code workflow tools by the canvas screenshots pick the pretty option; buyers who evaluate by the runtime pick the one that will still be running in three years. Strkr's low-code workflow builder ships both: a visual canvas that produces useful flows within an hour of first use, and a runtime engineered for production; sub-second execution latency, at-least-once delivery semantics, idempotent action handling, per-flow versioning with rollback, three environments per tenant, dry-run test mode, and immutable audit on every execution. The sections below describe the canvas and the runtime in detail.

The canvas-only trap

Pretty surfaces, broken runtimes.

Many low-code workflow tools ship a shiny canvas built on a runtime that silently fails under load, loses runs during deploys, and does not expose logs when a flow misfires. The buyer who evaluates the canvas screenshot picks the tool; six months later the production misfires start.

The latency ceiling

Flow latency affects user experience.

A flow triggered by a record change should execute within sub-second of the change. Tools with multi-second or multi-minute latency create visible lag: the user updates a record and the automation does not fire for 30 seconds. The lag erodes trust in the automation.

The delivery semantics

At-least-once, exactly-once, best-effort.

The runtime's delivery semantics determine whether every triggered flow actually runs. At-least-once (with idempotent actions) is the operational standard. Best-effort runtimes silently drop runs under load; the automation that was supposed to send the welcome email simply does not run some fraction of the time.

The error-handling gap

What happens when a step fails?

A step fails: external API 500, record constraint violation, mapping error. The runtime has to retry on transient failures, dead-letter persistent failures, run compensating actions, and surface the failure to the owner. Runtimes that lack this handling leave failed runs in silent limbo.

The versioning gap

Rollback has to be possible.

A flow published 10 minutes ago turns out to have a bug. The team needs to roll back to the prior version. Runtimes without per-flow versioning force the author to recreate the prior logic from memory. Serious runtimes maintain version history with one-click rollback.

The observability gap

When something breaks, where is the log?

A flow is misfiring. The debugger needs the trace: trigger payload, each step's input and output, the branches taken, the external calls made, the final outcome, the duration. Runtimes without full-fidelity trace output force the debugger to guess.

The environment gap

Dev and prod should not be the same.

A workflow tool with no environment separation forces the author to test in production. Buggy flows touch real records. Serious tools provision dev, stage, and prod environments per tenant with per-environment configuration.

The scale ceiling

Workflows have to run under real volume.

A revenue team's workflow volume runs tens of thousands of executions per day under peak load. The runtime has to handle this without degraded latency or dropped runs. Scale-tested runtimes beat scale-untested ones every time.

What Strkr delivers

A canvas and a runtime that both hold up.

Visual canvas with 180-plus node types, sub-second execution latency, at-least-once delivery with idempotent action semantics, per-flow versioning, three environments per tenant, dry-run test mode, full-fidelity trace output, and immutable audit on every execution.

The canvas and the node catalog

A visual builder that produces real flows.

The canvas is where the author composes a workflow. Drag a trigger from the panel; drop it on the canvas. Add actions, branches, loops, error handlers. Save and publish. The canvas feels familiar to anyone who has used a visual workflow tool before. The depth comes from the node catalog: 180-plus trigger and action types covering the real operational surface. The elements below describe the canvas and the node catalog in detail.

Trigger nodes

What starts the flow.

Trigger nodes include record changes (on create, update, delete, specific field change), time triggers (cron, scheduled, delayed), inbound webhooks, email received, form submits, external events (Stripe payment, DocuSign signed, Zoom ended), chat conversations, and manual triggers. Any trigger can start any flow.

Action nodes

What the flow does.

Action nodes include record writes (create, update, delete), HTTP calls to any URL, native connector actions (post Slack, send DocuSign, create Stripe charge), data transforms (parse, format, join, split), approval gates, timer actions (wait N days), task creation, and alert emission.

Branch nodes

If-this-then-that logic.

Branch nodes split the flow based on conditions: up to 10 conditions per branch, up to 20 branches per decision. The conditions evaluate against the trigger payload and the current flow state. The chosen branch continues; the others skip.

Loop nodes

Iterate over list fields.

Loop nodes iterate over list fields (contacts in a segment, line items in an order, tasks in a project). Each iteration runs the loop body with the current item as input. Bulk-action limits apply so loops cannot runaway.

Sub-flow nodes

Call another flow as a function.

Sub-flow nodes call another flow as a function with typed input and output. The posture lets the author decompose complex logic into reusable units. A deal-close flow calls a billing-notify sub-flow; a renewal flow calls the same billing-notify sub-flow.

Error-handler nodes

What happens when a step fails.

Error-handler nodes attach to any step with configurable behavior: retry with exponential backoff, skip and continue, abort the flow, route to a recovery branch, notify a user. The error handler is a first-class part of the canvas rather than an afterthought.

Approval-gate nodes

Pause until a human approves.

Approval-gate nodes pause the flow until a named approver (or role) approves or denies. The approver sees the context, decides, and the flow resumes based on the decision. Timeouts can escalate or auto-decide.

Code-block nodes

JavaScript inside the canvas.

Code-block nodes run a sandboxed JavaScript function with typed input and output for logic that resists canvas expression. The engineering team writes the function; the business team composes the canvas around it.

Node discoverability

Search, categories, favorites.

The node panel supports search ("send slack") and category browsing (triggers, actions, logic, integrations). Favorite nodes pin to the top. A user familiar with workflow tools reaches the right node in seconds.

The execution engine

Sub-second latency, at-least-once delivery, idempotent actions.

The execution engine is the invisible layer under the canvas. A flow that composed in the canvas lands in a definition that the engine interprets on every trigger. The engine runs on a tenant-scoped execution pool with sub-second latency on native triggers, at-least-once delivery semantics, idempotency on repeat executions, and horizontal scale under load. The elements below describe how the engine runs.

Sub-second trigger-to-start

Record change to flow start in under a second.

When a record changes, the trigger evaluation runs on the write path within milliseconds. Flows matching the trigger start executing within sub-second. The user updating the record sees the automation effect before they pivot to the next task.

At-least-once delivery

Every triggered flow runs at least once.

The engine guarantees at-least-once delivery: every triggered flow executes at least once, even under system restart, deploy, or temporary database connectivity blips. The guarantee holds through the use of durable queues and transactional state writes.

Idempotent action semantics

Repeat executions do not double-write.

Actions that write to external systems (Stripe charge, DocuSign create, email send) carry idempotency keys. If the engine retries after a timeout, the external system deduplicates on the key. Repeat executions do not produce double charges, double documents, or double emails.

Horizontal scale

Execution scales with volume.

The execution pool scales horizontally based on queue depth. Peak-hour triggered flows (end-of-quarter close, campaign send, provisioning burst) run with no degradation to steady-state flows. The scaling happens below the surface; the admin does not provision capacity manually.

Per-tenant fairness

One tenant's burst does not slow others.

The execution pool enforces per-tenant fairness. A tenant's burst of 10,000 flow executions does not starve another tenant's steady-state flows. The posture matters in multi-tenant SaaS where neighbors can affect each other.

Retry and backoff

Transient failures retry; persistent fail cleanly.

Transient failures (external API 500, rate limit hit, network blip) retry on exponential backoff: 1s, 5s, 30s, 2m, 10m, 1h. Persistent failures (invalid data, auth expired) stop retrying and route to the dead-letter queue with full context for human review.

Dead-letter queue

Failed runs do not disappear.

Flow executions that fail persistently land in the dead-letter queue with the trigger payload, the state at failure, the error details, and the step trace. The RevOps lead reviews the queue, fixes the cause (data, mapping, auth), and replays. Nothing drops silently.

Execution timeout

A runaway flow does not hang forever.

Each flow carries an execution timeout (default 15 minutes, configurable). A flow that exceeds the timeout aborts with a timeout error and routes to the dead-letter queue. The posture prevents runaway loops or hung external calls from consuming engine capacity indefinitely.

Full-fidelity trace

Every step inputs, outputs, duration logged.

Every execution produces a full-fidelity trace: the trigger payload, each step's input and output, the branches taken, the external calls with request and response, the duration per step, the final outcome. The trace supports debugging without guesswork.

Versioning, environments, and the test mode

Dev to stage to prod with versioned flows.

A production workflow has to evolve across quarters as the business learns. The author edits a flow; the edit might work or might break. Versioning lets the author roll back on breakage. Environment separation lets the author test in stage before promoting to prod. Test mode lets the author run the flow against cohorts without producing side effects. The elements below describe how versioning, environments, and test mode integrate.

Per-flow versioning

Git-like diffs on every save.

Every save of a flow creates a version with a git-like diff: nodes added, nodes removed, parameters changed, connections rewired. The author reviews the diff before publishing. The version history retains every version indefinitely.

One-click rollback

Any prior version restores in one click.

Rollback to any prior version is a one-click action. The rollback publishes the prior version as the current running version. The forward versions remain in history for subsequent re-publish. The posture lets the author experiment without fear of losing a working version.

Three environments

Dev, stage, prod per tenant.

Each tenant provisions three environments: dev (safe to break), stage (production-like for user testing), prod (live automation on live records). Flows build in dev, test in stage, promote to prod. A flow in dev cannot touch prod records.

Per-environment configuration

Credentials, endpoints, settings swap.

Each environment has its own connector credentials (dev Salesforce vs prod Salesforce), its own API endpoints, its own feature settings. The flow definition travels across environments; the configuration swaps per environment. No per-environment flow redevelopment.

Flow promotion

From dev to stage to prod.

The author promotes a flow from dev to stage with a one-click action. Stage tests complete; the author promotes stage to prod with approval. The promotion carries the flow definition; the configuration applies per environment.

Dry-run test mode

Run the flow without side effects.

Dry-run mode executes a flow end to end against test cohorts without producing side effects: reads happen, writes capture in the trace but do not persist, external calls go to mocks. The author sees exactly what the flow would do in production before publishing.

Test cohorts

Representative records for test runs.

Test cohorts (A through D by criticality) hold representative records: happy path, segment variety, edge cases, adversarial scenarios. The author runs the flow against the cohorts before publish. Cohort pass rates surface on the publish approval surface.

Mocked connectors

External systems do not fire in test mode.

Every native connector has a test-mode mock that returns realistic responses without hitting the real service. The flow executes against mocks in test mode. No real Stripe charges, no real DocuSign documents, no real Slack notifications fire during tests.

Test-gated publish

Failing tests block production publish.

The production publish approval surface shows the latest test results. A flow with failing tests cannot publish without an override. The gate enforces test discipline on every production change.

Observability, audit, and operational posture

What ran, when, with what outcome.

A production workflow surface earns its keep when operators can see what runs, when, and with what outcome. Observability dashboards, immutable audit logs, alerting on failure patterns, and executable-level tracing all compose into the operational posture. The elements below describe how operators monitor and troubleshoot production flows on Strkr.

Per-flow dashboard

Execution, success, duration, errors.

Each flow surfaces a dashboard: execution count (24h, 7d, 30d), success rate, average duration, 95th percentile duration, error rate, dead-letter count. The RevOps lead monitors every production flow on one surface. Alerts fire on success rate below configured thresholds.

Execution log

Every run searchable by any field.

Every flow execution logs with trigger payload, final outcome, duration, and step trace. The log is searchable by any field: triggered contact, triggered account, duration above a threshold, outcome type, specific error class. The RevOps lead debugs misfires in minutes.

Alert routing

Failures notify the responsible owner.

When a flow's error rate crosses a threshold or the dead-letter queue grows beyond a cap, alerts fire to the flow's owner. The alert links to the dashboard and the dead-letter queue. The owner acts without the end user having to escalate.

Immutable audit log

Every edit, publish, execution logged.

Every flow edit, publish, rollback, and execution lands in the immutable audit log with the actor, the timestamp, the before-state, the after-state, and the IP address. Compliance reviews read the log. SOC 2 attestation reviews log retention and tamper-evidence.

Replay capability

Re-run a failed execution with corrected data.

A failed execution in the dead-letter queue can replay with corrected input data. The replay runs on the current flow version with the fresh data. The posture lets operators recover failed runs without having to rebuild the trigger payload manually.

Floor-level dashboard

Platform health across every flow.

A floor-level dashboard rolls up platform health across every production flow: total executions, total failures, top error patterns, slowest flows, flows with recent regressions. The platform admin monitors the whole surface on one view.

SLO tracking

Service-level objectives per flow.

Each flow carries SLOs for success rate (99 percent default), duration (95th percentile below 5 seconds default), and dead-letter rate (under 0.1 percent default). The SLO dashboard surfaces compliance against targets. Breaches route to the flow owner for action.

Role-based observability

Who sees which flows.

Observability scopes by role: a RevOps analyst sees the flows they author; a RevOps lead sees the team's flows; an IT admin sees every production flow. The scoping protects sensitive flows from unnecessary visibility while giving operators the visibility they need.

Export and reporting

Metrics export to BI tools.

Flow metrics (execution count, success rate, duration, error patterns) export to BI tools (Looker, Tableau, PowerBI, Metabase) through the standard reporting API. The RevOps lead builds custom dashboards on top of the native metrics without having to export CSVs.

A low-code workflow builder with a canvas you can use on day one and a runtime that holds up under production.

180-plus node types, sub-second trigger-to-start, at-least-once delivery, idempotent actions, per-flow versioning with rollback, three environments per tenant, dry-run test mode with mocked connectors, immutable audit, and full-fidelity trace output on every execution.

Common questions

What buyers ask about this feature.

What is a low-code workflow builder and how is it different from a BPM tool or an iPaaS?

A low-code workflow builder is the visual canvas plus the execution engine that runs step-by-step automation sequences. A trigger fires (record change, time, inbound webhook, form submit, external event), the engine evaluates the matching flows, each flow executes its sequence of actions, and the flow completes. Workflow builders handle short-form automation that completes in seconds to minutes. A BPM (business process management) tool models longer-running processes with explicit states and approval chains that can run for days or weeks. An iPaaS specializes in moving data between systems. Strkr ships all three on one platform; a low-code workflow builder for short-form automation, business process management for long-running processes, and integration pipelines for system-to-system data flow; so the admin picks the right primitive for the shape of the problem rather than buying three separate tools.

What node types does the workflow builder ship, and does 180-plus cover real operational cases?

The 180-plus node count covers the real operational surface. Trigger nodes include record changes (create, update, delete, specific field change) on every CRM object, time triggers (cron, scheduled, delayed, recurring), inbound webhooks, email received, form submits, external events from native connectors (Stripe payment, DocuSign signed, Zoom ended), chat conversations, and manual triggers. Action nodes include record writes, HTTP calls to any URL with auth and retry, native connector actions (post to Slack, send DocuSign, create Stripe charge, etc.), data transforms (parse, format, join, split, lookup), approval gates, timer actions (wait N days), task creation, and alert emission. Logic nodes include branches (up to 10 conditions per branch, up to 20 branches per decision), loops over list fields with bulk-action limits, sub-flow calls, error handlers (retry, skip, abort, route, notify), and code-block actions (sandboxed JavaScript with typed input/output). For logic that resists canvas expression, the code-block and HTTP-action extensibility covers most remaining cases.

How fast does the workflow engine execute, and does it drop runs under load?

Trigger-to-start latency is sub-second on native triggers (record changes, external connector events, inbound webhooks). The engine evaluates matching flows on the write path within milliseconds and starts executions within sub-second. The user updating a record sees the automation effect before they pivot to the next task. The engine guarantees at-least-once delivery: every triggered flow executes at least once even under system restart, deploy, or temporary database connectivity blips. The guarantee holds through durable queues and transactional state writes. Actions that write to external systems carry idempotency keys so retries do not produce double charges, double documents, or double emails. The execution pool scales horizontally based on queue depth so peak-hour triggered flows (end-of-quarter close, campaign send, provisioning burst) run with no degradation to steady-state flows. Per-tenant fairness prevents one tenant's burst from starving another tenant's steady-state execution.

What happens when a step in a flow fails?

Transient failures (external API 500, rate limit hit, network blip) retry on exponential backoff: 1s, 5s, 30s, 2m, 10m, 1h. Persistent failures (invalid data, authentication expired, destination constraint violated) stop retrying and route to the dead-letter queue with the trigger payload, the state at failure, the error details, and the full step trace. The RevOps lead reviews the dead-letter queue, fixes the root cause (data correction, mapping adjustment, auth refresh), and replays the failed execution. Nothing drops silently. Error handlers attach to any step with configurable behavior: retry with backoff, skip and continue, abort the flow, route to a recovery branch, notify a user. The error handler is a first-class part of the canvas rather than an afterthought in a settings page. Each flow carries an execution timeout (default 15 minutes, configurable) so a runaway loop or hung external call does not consume engine capacity indefinitely.

How does Strkr handle flow versioning and rollback when a published flow has a bug?

Every save of a flow creates a version with a git-like diff showing nodes added, nodes removed, parameters changed, and connections rewired. The author reviews the diff on hover before publishing. Rollback to any prior version is a one-click action: the prior version publishes as the current running version while the forward versions remain in history for subsequent re-publish. The version history retains every version indefinitely. Combined with three environments per tenant (dev, stage, prod), the posture lets authors experiment freely in dev, test in stage against stage data, and promote to prod with approval. A flow in dev cannot touch prod records. Each environment has its own connector credentials and configuration; the flow definition travels across environments while the configuration swaps per environment, so no redevelopment is required per environment. Dry-run test mode runs flows against test cohorts (A through D by criticality) with mocked external connectors and no persistent writes before publish.

What observability does Strkr provide for production flows?

Each flow surfaces a dashboard with execution count (24h, 7d, 30d), success rate, average duration, 95th percentile duration, error rate, and dead-letter queue count. Alerts fire on success rate below configured thresholds. Every flow execution logs with the trigger payload, final outcome, duration, and full step trace; the trace captures each step's input and output, the branches taken, the external calls with request and response bodies, and the duration per step. The log is searchable by any field: triggered contact, triggered account, duration above a threshold, outcome type, specific error class. SLO tracking surfaces compliance against targets (99 percent success rate default, 95th percentile duration below 5 seconds default, dead-letter rate under 0.1 percent default); breaches route to the flow owner. A floor-level dashboard rolls up platform health across every production flow for platform admins. Flow metrics export to BI tools (Looker, Tableau, PowerBI, Metabase) through the standard reporting API so RevOps leads can build custom dashboards without CSV exports.

Try it free. Bring your team next week.

No sales call, no migration consultant, no four-month implementation. Enter your card, get 14 days of the full Pro tier, cancel any time before day 14 with zero charge. Spin up a workspace, import your CSV, and have something useful before lunch.