Open Workflows to create and manage connected flows. A flow can combine explicit record actions with AI steps, branches, approvals, waits, and reusable published workflows. The studio keeps the visual canvas, step configuration, versions, and run history together.

Start and connect a flow#

  • Start blank or choose a pattern: an approval, record brief, scheduled report, project kickoff, or weekly digest.
  • Choose a manual, scheduled, record-created, record-changed, incoming-email, or incoming-webhook trigger. Choose its permitted source, then use Find records or Condition steps to narrow the work.
  • Add steps and connect their outcome paths on the canvas. Use Arrange to tidy the layout or Steps and path controls to work without dragging.
  • Select a step to configure it. Use a value from an earlier step when a later action needs its output.

Choose what each step does#

PurposeSteps
Work with recordsFind, create, update, or archive records in the configured scope.
Make decisionsConditions, assigned approvals, and clear finish steps.
Control timing and pathsWait, parallel branches, joins, reusable published flows, and bounded for-each loops.
Use AIInstructions, selected context, and a defined output that later steps can use.
Prepare outputsDocument drafts, saved report versions, private email drafts, and team notifications.
Connect a serviceSupported connected-integration tools and approved HTTPS webhooks, with credentials held on the server.

Ask Ralti to help build it#

Use Ask Ralti in the studio to describe a new flow or revise the current one. Inspect the proposal and accept it into the draft only when it fits. AI authoring does not publish, enable, or run the workflow. Live AI steps use the configured provider and the authorized context you select.

Preview before publishing#

Preview evaluates the draft using permitted data and shows the paths and proposed changes without committing business effects. It does not call AI, send webhooks, or send notifications. Simulated and skipped steps are identified so a preview does not imply that an external action succeeded.

Resolve validation issues and save the draft. Publishing creates a version and activates its configured trigger, including schedules and events. Republishing also activates a paused flow. For a manual trigger, start with Run. Pause the flow to stop future automatic starts. Each live run uses its published version even if the draft changes later. Publication history lets you inspect a prior version and restore it into a draft for review. Incoming webhooks also have their own Turn on webhook control: publishing alone does not turn on a paused endpoint.

Follow every run#

  • Open run history to inspect the outcome, timing, and each step’s input and output.
  • Assigned approvals pause the run until an authorized person decides. Wait steps preserve progress and resume when their deadline arrives.
  • Use the available retry action for an eligible failed step. Completed steps are retained rather than replayed indiscriminately. An uncertain webhook delivery needs review instead of a blind retry.
  • Cancelling stops further work; it does not undo actions that already completed. Pausing a trigger stops future automatic starts.

Keep access explicit#

Step details and available review or recovery actions respect current source access. Private results are hidden if permission to the underlying email or records is revoked. Publishing and editing also check workspace permissions and archived workbook scopes.

Run beyond the browser#

Live runs execute through the background worker, with saved progress across approvals, waits, and process restarts. Keep the server and workflow worker available. If a flow does not start, check its publication, enabled trigger, source scope, conditions, required provider, and worker health.

Keep existing helpers available#

Existing helpers retains earlier automations and agents with their original settings and history. They continue to use ordered actions and their configured Review first or Automatic changes mode. Importing one into a visual workflow creates a draft; it does not publish or run it.

Existing helper history still shows results, source references, proposed operations, and audit details. Apply requires current source access; Dismiss leaves records unchanged. Helper-produced changes do not recursively trigger other helpers. New legacy helpers start paused, and their scheduler dispatches one overdue interval after a restart rather than replaying every missed interval.

Schedule actual calendar work#

Start supports minute intervals and daily, weekly, or monthly calendar schedules with local time and an IANA zone. Choose Last day for true month-end. Date steps calculate execution-day or bound dates plus calendar-day offsets; Find records can pin a specific product; Document steps can use a template or a row’s Document column. See Calendar workflows for a one-line invoice example and the six-hour missed-occurrence window.

Start a Flow from another app#

Choose Start → Another app sends an event → Set up webhook. Ralti gives this saved Flow its own secure endpoint. The same record, condition, integration, document, and approval steps handle what happens next. The flow owner manages the endpoint and its credential.

  • Connect: save the draft, then choose Signed events (recommended) or Bearer token. Create the endpoint and copy its URL and one-time credential into your sender. New endpoints start paused. Ralti does not place the credential in the Flow graph.
  • Preview payload: paste a sample JSON object to inspect a redacted preview. Discovered fields appear under Incoming webhook in the value picker for later steps. This only checks the sample; it does not call the sender, verify authentication, or run Flow actions.
  • Test the actual connection: use Sender instructions to send an authenticated event with an event ID beginning test_ and the x-ralti-webhook-test: 1 header. Both are required. A Test received delivery confirms authentication, even while paused or before publication, without starting a run.
  • Activate: publish the webhook version, review its steps and approvals, then choose Turn on webhook. For live deliveries, remove the test header and use an event ID without the test_ prefix. New verified events start the published Flow through the existing background worker.
  • Follow delivery: open Deliveries to see test receipts, queued or completed runs, failures, and duplicates. Preview a delivery’s redacted payload or choose View run to follow its steps.

Your sender must POST a JSON object of at most 240 KB and include webhook-id. Use a stable, unique ID for each event; resend the same ID for a retry. Matching retries do not create another run, and the same ID with different data is rejected. A successful delivery acceptance is not proof that every later Flow step completed—check View run. The worker checks the queue every two seconds, and a visible open sheet checks for updates every three seconds. Provider delivery, queued work and load can add delay; these are polling intervals, not an instant-delivery guarantee.

Signed events use Standard Webhooks headers: webhook-id, webhook-timestamp in Unix seconds, and webhook-signature. Sign the exact bytes of the JSON body with the decoded whsec_ secret and HMAC-SHA256; timestamps must be within five minutes. The setup includes a copyable example. Bearer senders use Authorization: Bearer with their token. Never put credentials in the URL.

Use a connected tool#

Use an integration selects a permitted account, real provider action, pinned version, and its inputs. Review before running is the default; automatic execution requires explicit selection and publication. Bind selected outputs into later steps. Provider pagination stays explicit, and a catalog app is not an automatic two-way sync. Account and workspace availability restrictions still apply.

Make the workflow a guided app#

An App page is a durable Flow step that waits for a participant. Published app bindings constrain record actions, and approved reviewers decide assigned review tasks. Use Apps → Journey to connect pages, conditions, approvals, and permitted connected actions without creating a separate workflow engine.