A canvas that weaves your systems into one governed flow
On the canvas you sketch the process the way you'd explain it to a colleague: this trigger, this agent, and here: the manager's approval. Every node carries its permission, and every step leaves its mark in the audit trail: before you write a single line of code, if you ever do.
Governance, drawn into the flow
The human approval node and the permission badges aren't settings buried in menus: you see them on the canvas exactly as you see the systems themselves.
Illustrative diagram: before the flow touches the ERP, it passes through a read-only agent, then a human approval.
Describe the process, watch it run
The distance between "we have an automation idea" and "we have a working flow" is usually measured in backlogged development tickets. The canvas collapses it: the process owner sketches it directly, connects the systems, and previews the impact before anything touches production data.
A genuinely right-to-left interface: triggers, agents and actions are components you drag and connect: not translated forms.
Connectors for common systems: from ERP to WhatsApp: enter the canvas with permissions you define, never open access.
Whatever is built on the canvas stays open to technical teams through the API: the canvas is a starting point, not a ceiling.
Illustrative figures showing how the preview looks inside the canvas: your real impact is measured from your own runs, not our promises.
Experiment boldly, release with discipline
The canvas invites experimentation; governance contains its blast radius: edit freely in the development environment, run step by step on sample data, and no change reaches production before it passes its review.
Development and production are isolated: test however you like: live operational data stays safe from your experiments.
Run the flow on a sample and watch every node: what it read, what it decided, where it stopped: before release, not after.
Every release lands in the audit trail with its time and owner: so you always know which version is running now, and who signed it off.
Draft on the canvasDevelopment environment · full freedom
Test run on sample dataStep by step · a log for every node
Permissions & approvals reviewSigned off by the governance lead
Release to productionRecorded in the audit trail
Permission gates inside the flow itself
When you connect a node to a system holding sensitive data, the canvas asks before the auditor does: who may access it? Up to what limit? And who approves what exceeds it? The answers become part of the flow's definition: they travel with it from development to production, and they're visible to whoever reviews it.
No open access: permissions are granted explicitly at the action and data level: every node declares what it reads and what it executes.
Drag it anywhere in the flow: nothing after it executes until the decision-maker you designate signs off.
Every run documents who decided, what was executed, and under which permission: supporting your audit readiness from day one.
| Validation agent | Support agent | Ops analyst | |
|---|---|---|---|
| ERP | Allowed | Denied | With approval |
| CRM | Denied | Allowed | Allowed |
| Payroll DB | Denied | Denied | With approval |
| Reporting sheets | Allowed | Denied | Allowed |
From idea to an operating flow
Five steps on the canvas: with governance present in each of them, not postponed as a sixth phase.
SketchThe canvas
Start with the trigger: a message, a schedule, an event in a system: and add the nodes that follow it by drag and drop.
ConnectIntegrations
Pick the connectors for your systems and grant each node its permission: what it reads, what it executes.
GovernGovernance
Place the human approval node wherever a decision is required, and define who approves what.
TestDevelopment environment
Run on sample data in the development environment and watch every step before anything touches production.
Release & monitorOperations
Ship to production and follow the runs from the operations view: every run adds its line to the audit trail.
Questions from first-flow builders
No. The canvas is a visual board where flows are built by drag and drop: a trigger, then system and agent nodes, then actions. Technical teams get their depth too: a full API and separate development and production environments: but getting started requires no code.
On the canvas itself: every node carries its permission badge: what it reads and what it executes: and the human approval node is drawn into the diagram like any other step. Whoever reads the flow reads its governance with it, without opening a separate settings screen.
Yes. Every flow has a development environment separate from production: run it on sample data step by step, review what each node read and decided, then release when you're confident: and the release itself is recorded in the audit trail.
It doesn't execute it. The step stops and escalates to the decision-maker defined in the approval node, and the flow waits for sign-off. NOVA has one rule: whatever exceeds a permission never runs automatically: it is approved by a human and recorded.
The canvas is the start: here’s the rest of the layer
The intelligence engine
The agents you drag onto the canvas: they understand Arabic and its dialects, and decide within explicit permissions.
Explore the engineWorkflows & operations
What happens after release: scheduling, live monitoring, and an operations view of everything that runs.
Explore operationsAI workflow automation
How the canvas turns into results for operations teams: the full use case, from problem to impact.
Explore the solutionYour first governed flow: in a single session.
Book a live demo where we sketch one of your own processes on the canvas: with its permissions and approvals: or explore the governance center first.