A visual builder that respects your time: drag-and-drop canvas, Dagre auto-layout, per-block metrics on hover, dry-run before publish, keyboard shortcuts, and no DSL to learn. The builder a RevOps generalist can run in an afternoon, not a Salesforce admin certification away.
The workflow surface decides who in the organization is actually allowed to build automations. A YAML-based config limits authoring to engineers. A JSON-based config limits it to developers. A visual canvas with a steep learning curve limits it to certified admins. A clean visual canvas with sane defaults, auto-layout, and dry-run opens authoring to the RevOps generalist. The UI is not surface polish; it is the gating decision for who runs the workflow program.
A workflow surface determines who can build. If the surface requires certification, only certified admins build. If the surface is approachable, team-level operators build. Strkr's UI is designed for the second case: a sales ops senior analyst can author a Flow without a week of training.
A new operator opens the canvas, drags a trigger, drags an action, connects them, dry-runs, publishes. First Flow live in under 30 minutes. The learning curve is a function of visual conventions a knowledge worker already knows (drag, drop, connect, test, publish), not a BPMN notation or a config DSL.
Scale is where visual builders usually break. A Flow with 40 blocks starts to spaghetti. Strkr's Dagre auto-layout fixes the shape on every save; the canvas stays legible even for complex workflows. Click Tidy, the engine re-arranges the layout to the current graph topology.
The action library is searchable. "Send email," "assign owner," "post Slack," "create project." The operator does not need to know the action naming convention; they type what they want to do and the matching actions surface. The pattern halves the time to find the right action.
Invalid connections (output type does not match input type), missing required fields, dangling branches, infinite loops: the canvas highlights the issue inline and refuses to publish until it is fixed. The pattern replaces the "test in production and watch what breaks" workflow with a validated-at-author-time surface.
An operator who runs 15 Flows reads logs, checks metrics, and makes small changes daily. The UI is designed for that daily use: fast load, keyboard shortcuts, cached views, bookmarkable deep links to specific Flows. The daily grind is not punished by a slow or clunky surface.
The core canvas is built on React Flow (open-source graph canvas) with Dagre auto-layout. The pattern is widely used, well-understood, and performant at scale. Below are the canvas behaviors that make daily use pleasant.
Drag a trigger, condition, or action block from the left-side palette onto the canvas. The block snaps to the grid; connections drag from port to port. The pattern is familiar from Figma, Lucidchart, and every other visual canvas; no new conventions to learn.
Dagre is a DAG auto-layout algorithm. Click the Tidy button and the engine re-flows the canvas to the current graph topology: triggers on the left, actions on the right, conditions in between with branches cleanly separated. The canvas stays legible even after many edits.
Scroll to zoom, drag to pan, double-click to center. Pinch-to-zoom on trackpads. The conventions are inherited from Figma and Google Maps; the operator does not learn Strkr-specific gestures.
The bottom-right minimap shows the full Flow layout with the current viewport highlighted. Click the minimap to jump. Useful for Flows with 20+ blocks where the full canvas does not fit on screen.
Hover a block, a small toolbar appears with duplicate, delete, open-detail. The pattern replaces the "right-click context menu nobody discovers" with an always-visible toolbar on hover. Three clicks faster per edit.
When a user drags a connection from an output port to an input port of an incompatible type (number to string, record to boolean), the connection refuses to form and shows a hint. The pattern catches the type-mismatch mistakes at author time instead of at run time.
Each block on the canvas is a compact unit with the information an operator needs at a glance: name, type, status, metrics. The design is dense (fits in a 240px wide card) without being busy (surfaces the three most useful signals, hides the rest behind hover).
Each block has an icon that signals its type (lightning for trigger, diamond for condition, square for action, pentagon for AI step) and a name. The icon-plus-name convention means an operator reads the Flow at the icon level and only reads the names when needed.
Each block shows a status chip: green for healthy (last 24h success rate above 95%), amber for warning (above 80%), red for failing (below 80% or last run failed). The chip is the primary signal when scanning a Flow; the operator sees the health without opening metrics.
Hover a block, a tooltip shows runs today, success rate over the last 24 hours, median latency, p95 latency. The specifics are one hover away without being always-visible. Daily users rely on the hover; new users ignore it.
The block card shows a one-line summary of its config: "Assign to AE where territory = EMEA" rather than "Assign owner." The pattern lets the operator read the Flow at the canvas level without clicking into each block.
Each block has a compact mode (icon, name, status) and an expanded mode (full config summary, metrics, recent runs). Toggle at the canvas level. The pattern lets operators scan a Flow quickly or dive into details on the same surface.
When a condition block branches into Yes and No paths, the connection lines are labeled and color-coded. When paths merge later, the merge is drawn explicitly. The pattern avoids the "which path leads where" confusion in complex Flows.
The dry-run surface is the single highest-impact UI feature for operator confidence. Before publishing a change, the operator picks a sample record, runs the Flow in dry mode, and sees exactly what would happen without side effects. The pattern replaces the "publish and watch what breaks" workflow.
The operator picks any contact, deal, or account as the sample input. The runtime executes the Flow against that record in dry mode: conditions evaluate, branches select, actions log what they would do. No records change, no emails send, no SMS leaves the system.
After a dry-run, the canvas highlights the path the record traversed: condition blocks show which branch evaluated true, action blocks show whether they would have fired, skipped blocks are dimmed. The operator sees the shape of the execution at a glance.
Click any block in the dry-run result and see its specific input (what the previous step passed it) and output (what it would have produced). The pattern turns debugging from "why did this fail" into "I see exactly what each block got."
Before publishing, the canvas runs a static validation: are there required fields missing, dangling branches, infinite loops, type mismatches that slipped through, unconfigured actions. The publish button stays disabled until the validation passes.
When editing a published Flow, the operator can view a side-by-side diff against the live version: added blocks, removed blocks, changed configurations. The diff is visual (highlighted blocks) and textual (configuration deltas). The pattern replaces "I think I changed the territory check" with a precise record.
The canvas shows the record that would trigger the Flow next (based on current conditions). The operator sees concrete data instead of abstract field names, which catches the "I meant to filter on commit stage not pipeline stage" mistakes before they ship.
A UI that is pleasant on day one is table stakes. A UI that gets faster the more an operator uses it is the real investment. Below are the keyboard shortcuts and power-user conventions that reward daily use.
Cmd-K opens a palette that searches Flows, blocks, actions, and records. Type a Flow name, jump directly. Type an action name, open the add-block modal. The palette means power users rarely use the mouse for navigation.
Shift-T triggers the Dagre auto-layout. Useful after a batch of edits where the manual positions have become messy. The muscle memory develops quickly for daily users.
Shift-R dry-runs the Flow against the last used sample record. The operator iterates on a block, hits Shift-R, sees the result, iterates again. The loop is tight; the keyboard shortcut keeps the hands on the keyboard.
Cmd-D duplicates the selected block with its configuration. Useful for building symmetric branches (e.g., similar actions for EMEA, NAMER, APAC with different parameters). The duplicate is placed on the canvas near the original and ready for connection.
The canvas supports deep undo and redo (up to 100 operations). The operator can experiment freely with edits knowing that reverting is one shortcut away. The pattern reduces the "I need to think carefully before I change anything" friction.
Cmd-S saves the current state as a new version and prompts for an optional change note. The pattern turns version history into a documented log instead of a sequence of unlabeled snapshots.
Authoring usually happens on a laptop. Observation (checking a Flow's status, reviewing a failed run) often happens on mobile or in a shared read-only context. The UI handles both without compromising either.
The Flows list, individual Flow summary, run history, and DLQ are usable on mobile. An ops lead at a dinner can check whether the Monday-digest Flow fired, inspect a failed run, or acknowledge a DLQ alert. Authoring is desktop-only; observation is multi-platform.
Every Flow has a shareable URL. The ops lead sends the link to a sponsor or team lead who gets a read-only view of the Flow with the current status, recent runs, and metrics. No login-and-navigate ritual; the link opens directly.
The Flow summary (name, owner, status, run count) embeds as a card in Strkr Docs. Internal documentation can reference the specific Flow instead of linking to a tab. The pattern keeps the docs and the Flow coherent.
Export a Flow as a one-page summary PDF: canvas screenshot, block-by-block description, configuration details. Useful for architecture reviews, compliance sign-offs, and handing a Flow spec to a new team member.
The canvas, the block palette, the audit log, and the metrics charts all have light and dark modes. The UI respects the operating system preference and remembers an explicit override per user.
The canvas supports keyboard-only navigation (tab through blocks, arrow keys to pan, enter to open). Block labels have ARIA attributes so screen readers announce the shape of the Flow. The accessibility work makes the UI usable for operators with assistive needs and raises overall UX quality.
An honest take on how the major workflow UIs compare. Each has specific strengths and specific friction points; the best fit depends on the role and the organization.
Salesforce Flow's builder is deep and capable. The friction is the learning curve: elements like Loops, Collection Filter, and Get Records require Salesforce-specific understanding. The debug log is comprehensive and hard to read. For certified admins, the depth is a feature; for RevOps generalists, it is a wall.
HubSpot Workflows is one of the most approachable visual builders. The friction is less about the UI (which is clean) and more about the paywall: the deeper features live in Operations Hub Enterprise. The UI itself is a reasonable comparison point for approachability.
Zapier's UI is a vertical step editor rather than a graph canvas. For simple linear workflows (trigger, 2-3 steps, done), it works. For branching workflows with multiple conditions, the vertical layout becomes confusing. Multi-step Zaps often get rebuilt in canvas-based tools once they grow past a certain complexity.
Workato's UI is a canvas-based builder designed for integration specialists. The depth is appropriate for enterprise iPaaS use cases; it is heavier than a RevOps generalist needs for revenue workflows. The learning curve is similar to Salesforce Flow.
Camunda's Modeler is a BPMN 2.0 canvas, which is the industry-standard notation for business process modeling. For teams with developer capacity and formal process modeling discipline, it is a strong tool. For RevOps generalists, BPMN is an added learning curve.
The Strkr UI is designed for the RevOps generalist. React Flow canvas with Dagre auto-layout, searchable action library, per-block metrics on hover, dry-run before publish, keyboard shortcuts for power users, and no BPMN or DSL to learn. The surface is a visible investment in the daily ergonomics of running a workflow program.
Visual canvas, auto-layout, dry-run, per-block metrics on hover, keyboard shortcuts for power users. Built for the RevOps generalist, pleasant for daily use.
The UI is designed for the RevOps generalist, not the certified admin. Visual canvas with Dagre auto-layout, searchable action library, per-block metrics on hover, dry-run before publish, keyboard shortcuts for power users, and no BPMN or DSL to learn. The surface is a visible investment in the daily ergonomics of running a workflow program instead of a feature-complete-but-painful admin tool.
No. The canvas uses familiar conventions (drag, drop, connect, test, publish) that a knowledge worker already knows from Figma, Lucidchart, and other visual tools. There is no BPMN notation to learn, no YAML or JSON to write, and no admin certification required. A RevOps analyst can author a Flow in under 30 minutes of first-time use.
Dagre auto-layout keeps the canvas legible even for Flows with 40+ blocks. Click Tidy, the engine re-arranges the layout to the current graph topology. A minimap in the bottom-right shows the full Flow with the current viewport highlighted. Click the minimap to jump to any section. Branches and merges are drawn explicitly so complex Flows read cleanly.
Cmd-K opens the global command palette (search Flows, blocks, actions, records). Shift-T triggers Tidy auto-layout. Shift-R dry-runs against the last sample record. Cmd-D duplicates a selected block. Cmd-Z and Cmd-Shift-Z are undo and redo with a 100-operation history. Cmd-S saves a version with an optional note. The shortcuts reward daily use.
Authoring is desktop-only (a 10-inch canvas is not practical on a phone). Observation (checking a Flow's status, reviewing a failed run, acknowledging an alert) is fully supported on mobile. The Flows list, individual Flow summary, run history, and DLQ render cleanly on phone screens. The split keeps the mobile surface focused on the operations use case.
Yes. The canvas supports keyboard-only navigation (tab through blocks, arrow keys to pan, enter to open). Block labels have ARIA attributes so screen readers announce the shape of the Flow. Dark mode respects the operating system preference. The accessibility work makes the UI usable for operators with assistive needs and raises overall UX quality.
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.
