Workflow Builder
Designing Cascades workflows—node types, edges, routing, retries, timeouts, execution states—with practical DAG sketches.
The Workflow Catalog ships opinionated compositions (incidents, billing guardrails, proof-first remediation). Treat this page as the operational appendix: how authoring choices become runtime behavior—not just feature blurbs.
Node types
| Concept | What it captures | Runtime notes |
|---|---|---|
| Task node | A unit dispatched by workers (integrations, adapters, scripted transforms). | Mapped to adapters with typed inputs + outputs surfaced to downstream nodes. |
| Router / conditional (product-specific naming may vary) | Branching keyed by outputs or predicates. | Only one outbound path should win per evaluation—ambiguous fan-out must be modeled explicitly (DAG execution). |
| Join / barrier (where supported) | Synchronize concurrent branches before continuing. | Prevents dependents from starting until prerequisites finish or policies allow partial completion. |
Authoring surfaces usually expose schemas + policy knobs (timeouts, backoff classes). Prefer narrow task boundaries (“call Jira REST + parse JSON”) versus mega-nodes—which keeps retries targeted.
Use catalog rows as authoritative examples when aligning production graphs.
Edges & dependencies
Edges convey ordering and sometimes implicit data flow:
- Hard deps — downstream waits for upstream terminal success (
completed). - Soft / conditional deps — route evaluation may skip successors when predicates fail (core concepts).
- Data edges (where modeled) — output handles feed downstream templating contexts without additional HTTP hops.
Validation rejects cycles—see Workflow lifecycle.
Conditional routing
Typical pattern: emit a router node after normalization that inspects structured fields (severity, region, spend tier). Downstream tasks should be idempotent per attempt so replays do not double-charge external systems.
If your integration returns nested JSON, keep router predicates versioned with the workflow definition—the snapshot captures them for drift reviews.
Retries & timeouts
Builder-time fields feed the same knobs detailed in retries & timeouts:
- timeouts defend against poison vendors—pair with backoff tuned to SLA (fast fail vs tolerant).
- retries should remain bounded; infinite loops belong in DLQ tooling (failure recovery).
Document semantic idempotency next to integrations so operators know retry safety.
Execution states (mental map)
Interpret dashboards through this progression:
Parallel branches may coexist—aggregate success requires DAG completion semantics referenced in DAG execution.
Snapshot & immutable execution
Validated definitions enqueue as immutable snapshots; runtime observes enqueue-time fingerprints, not live canvas edits—for determinism and audit (immutable snapshots). When editing in UI, promotion flows should require explicit saves + validation before next production trigger.
Sample DAG — change control excerpt
Mirrors integrations such as github + slack escalation paths enumerated in Integrations overview.
Operational checklist
Before triggering production:
- Structural validation passes (DAG acyclic).
- Timeouts sensible vs vendor SLAs; retries capped.
- Integration secrets rotated & scoped minimally (access control).
- Proof capture expectations spelled out (execution proofs).