Skip to main content

Flows

A Flow is the Nukk platform's low-code integration and automation orchestrator: instead of writing an integration service from scratch, you build the process visually on a canvas, connecting blocks that represent each step of the automation — receiving an event, calling an external system, transforming data, deciding a path, sending a notification, and so on.

1. Overview​

The Flows listing screen is filterable by Squad, Environments, and Trigger, showing the columns Flow, Triggers, Total Artifact, Last Version, Last Update, Environments, and Actions. The New Flow button creates a new Flow from scratch, opening the editing canvas.

Inside the canvas, the top bar shows the Flow's name, the current version (e.g. 1.0), and three main actions: Test (runs a test/dry-run), Build, and Save. On the left are the Flow's tabs (main by default, with a + to create new ones), and on the right the Components panel, with search and components organized into categories (Triggers, Connectors, etc).

2. Canvas Concepts​

A Flow is made up of the following concepts:

Trigger​

The Trigger is what starts the integration or automation's execution. It's always the flow's first block. Available trigger examples: HTTP (exposes an endpoint that fires the flow when called), Event Consumer (reacts to an event published by another Flow), Scheduler (fires on scheduled times via cron), and WhatsApp Trigger (fires upon receiving a message). A Flow can also be started as a sub-routine through a Function component.

Connectors​

Connectors are the blocks that execute the flow's actions: calling an API, reading from or writing to a database, transforming a payload, sending a message, etc. They cover practically any system a company would need to integrate with:

  • Databases: SQL (relational, via JDBC), MongoDB, Qdrant (vector).
  • APIs and Web: HTTP (REST, as a trigger or as an outbound call), Jolt (JSON transformation), JSON Validator.
  • Google Workspace: Google Sheets, Google Calendar, Google Storage.
  • Messaging and events: WhatsApp, WhatsApp Upload Media, Event Producer/Event Consumer (publish/subscribe pattern between Flows), Email.
  • Files and documents: DOCX Reader, PDF Reader, TXT Reader, Excel Reader, File Writer, File to Base64, Markdown to DOCX, HTML to Text, OCR.
  • Security and data: JWT, Embedding (for AI/semantic search).
  • Automation and code: Script (custom code), RPA Connector (browser automation for systems without an API), Freemarker/Message Formatter (templates).
  • Flow logic: Choice (conditional), ForEach (loop), Add Variable, Local Storage, Function/Function Caller (sub-routines).

This catalog is the same integration engine that would handle communication with CRMs, ERPs, cloud providers (AWS and similar), and any other corporate system — via HTTP/REST when the system exposes an API, or via dedicated connectors when one exists for that specific service.

See the full catalog, with all fields for each connector, in Connectors.

Secrets and Config Maps​

Before using a credential or an environment setting inside a connector, you need to explicitly select the Secret or Config Map the Flow will use, on the Flow's corresponding tab. Only after that selection does the value become accessible inside the flow, through the expression {$.env.name.property}.

Error paths​

Each connector can have an alternative handling in case it fails (executionOnError), allowing you to notify, retry, or follow a fallback path — so a one-off failure doesn't bring down the entire automation.

3. AI Agents Inside the Flow​

The canvas is also where you create AI agents directly within the automation, through the AI Agent connector. It runs an agent capable of reasoning about one or more tasks, deciding what to do, and using other platform components as tools during execution — useful when the flow needs to interpret natural language, make more flexible decisions, or orchestrate multiple context-dependent sub-tasks (something a traditional Choice or ForEach wouldn't handle well).

The agent supports SEQUENTIAL, PARALLEL, LOOP, or DYNAMIC orchestration of the configured tasks, and any language model compatible with the configured URL. Typical use cases: interpreting a free-text request and deciding the next action, summarizing documents received in the flow, or dynamically orchestrating several sub-tasks (e.g. a support agent that decides, on its own, which tools to use to answer a customer). See all the details in AI Agent.

4. Why Low-Code​

Building the integration visually, dragging connectors onto the canvas instead of writing and maintaining integration code from scratch, drastically reduces the time between "we need to integrate with system X" and "it's in production": there's no need to write an HTTP client, handle authentication manually, deal with JSON serialization, or reimplement patterns like retry — the connector already handles that, leaving only the specific fields of that integration to configure. This also makes the flow easier for anyone on the team to understand and maintain, not just whoever originally wrote it.

5. Build, Deploy, and Exposing APIs​

After building and testing the Flow (Test), the Build button packages the current version for deployment. If the Flow exposes an API (HTTP trigger) and you want to make it available on the internet, the next step is configuring a Route in API Management, pointing to that Flow — without this step, the Flow runs, but isn't publicly accessible.

6. FlowSpec​

Every Flow can be viewed as its FlowSpec — the JSON representation of the flow's entire configuration (trigger, connectors, connections between them, error handling, etc). It's the "code" form of the same Flow built visually on the canvas, useful for reviewing the full configuration, comparing versions, or understanding exactly what will be executed.

7. Modules​

To organize more complex Flows, you can create modules, separating business logic from the API, Scheduler, and automation parts into distinct pieces within the same Flow (or across related Flows), instead of concentrating everything in a single monolithic flow. This makes it clearer what's the trigger/exposure (API, scheduling) and what's reusable business logic, making maintenance and reuse across different triggers easier.

8. Simple Example​

Flow: receive an order via HTTP, look up the customer in a SQL database, and send a confirmation email.

[Trigger: HTTP POST /orders]
        │
        ▼
[SQL Connector] → fetches customer data
        │
        ▼
[Message Formatter] → builds the email body
        │
        ▼
[Email] → sends confirmation to the customer
  • Trigger: receives { "orderId": 123, "customerId": 456 }
  • SQL Connector: SELECT name, email FROM customers WHERE id = :#customerId
  • Message Formatter: builds "Hi {{name}}, we received your order #{{orderId}}!"
  • Email: sends the formatted text to {{steps.fetchCustomer.output.email}}

9. FAQ​

Can a Flow call another Flow? Yes, Flows can be chained as reusable sub-routines, via Function/Function Caller or via Event Producer/Event Consumer.

How do I handle an error in the middle of the Flow? Every connector lets you configure an action for failure cases (retry, follow an alternative path, or stop and notify).

Where are execution logs? In Monitoring, filtering by Flow and by the desired execution — including full execution tracing and error alerts.