Documentation

Customata — Visual Automation Builder for Jira

Contents

Quick Start
Template Syntax
Node Reference
Error Handling
Secrets
Execution Logs
Keyboard & Interaction

Quick Start

Install Customata from Atlassian Marketplace
Go to Jira Settings → Apps → Customata
Click "+ New Playbook" to create your first playbook
Drag nodes from the left palette onto the canvas
Connect nodes by dragging from output handles to input handles
Configure each node by clicking on it (settings appear in the right panel)
Save and publish your playbook
In Jira Automation, add the action "Run Custom Playbook" and select your playbook

Template Syntax

All node fields support the {{...}} template syntax. Templates are resolved at execution time using data from the trigger issue, user-defined variables, and encrypted secrets.

Template	Description
`{{issue.key}}`	Issue key (e.g. PROJ-123)
`{{issue.summary}}`	Issue summary
`{{issue.status.name}}`	Current status name
`{{issue.priority.name}}`	Priority name
`{{issue.assignee.displayName}}`	Assignee display name
`{{issue.fields.customfield_10001}}`	Custom field value by ID
`{{vars.myVariable}}`	User-defined variable
`{{secrets.API_TOKEN}}`	Encrypted secret
`{{vars._current}}`	Current item in a For Each loop
`{{vars._index}}`	Current index in a For Each loop (0-based)
`{{vars._error.message}}`	Error message (in error branches)
`{{vars._error.statusCode}}`	HTTP status code of the failed request
`{{vars._error.body}}`	Response body of the failed request

Node Reference

Jira Nodes

Create Issue

ok / error

Creates a new Jira issue in the specified project.

Project — dropdown selector
Issue Type — dropdown, depends on the selected project
Summary — issue title (supports templates)
Description — issue description (supports templates)
Additional Fields — key-value pairs via the + button
Save Result To Variable — optional; stores { key, id, self }

Error path provides: {{vars._error.message}}, {{vars._error.statusCode}}, {{vars._error.body}}

Update Fields

ok / error

Updates fields on a Jira issue.

Issue Key — optional, defaults to the trigger issue
Fields — JSON object of fields to update
Save Result To Variable — optional; stores { status: "ok" }

Transition Issue

ok / error

Moves a Jira issue to a new workflow status.

Issue Key — optional, defaults to the trigger issue
Transition Name — case-insensitive (e.g. "In Progress", "Done")
Save Result To Variable — optional; stores { status: "ok", transitionName }

If the transition name is not found, the error message lists all available transitions for the issue.

Add Comment

ok / error

Adds a comment to a Jira issue.

Issue Key — optional, defaults to the trigger issue
Comment Body — comment text (supports templates)
Visibility — toggle between External and Internal (Internal for JSM service desks)
Save Result To Variable — optional; stores { id, self }

Logic Nodes

Branch

Conditional branching (if/else). Evaluates a condition and routes the flow accordingly.

Left Operand — value or template
Operator — ==, !=, >, <, contains, matches regex
Right Operand — value or template

Two outputs: yes (condition is true) and no (condition is false). All operands support template syntax.

For Each

Iterates over a collection, executing the "cycle" branch for each item.

Source — Subtasks, Linked Issues, JQL Query, Variable array, or Custom List
Issue Key — optional, required for Subtasks and Linked Issues sources

Two outputs: cycle (executed per item) and done (after all items are processed).

Inside the loop, use {{vars._current}} for the current item and {{vars._index}} for the zero-based index.

Tips: A dead end (no outgoing connection) inside the cycle branch acts as "continue to next item." Use a Branch node inside the cycle for conditional skipping. Use Break Loop to exit early and jump to the "done" branch.

Data Nodes

Set Variables

Sets one or more user-defined variables that can be referenced later in the flow.

Variables — list of name-value pairs (use the + button to add more)

Variable names may only contain A-Z, a-z, 0-9, and underscores. Values support template syntax.

Web Request

Makes an HTTP request to an external URL.

URL — request URL (supports templates)
Method — GET, POST, PUT, PATCH, or DELETE
Headers — JSON object of headers
Body — request body (supports templates)
Save Response To Variable — variable name for the response

The response variable contains:

{{vars.name.body}} — parsed JSON or raw text
{{vars.name.statusCode}} — HTTP status code
{{vars.name.statusText}} — HTTP status text
{{vars.name.status}} — "ok" or "error"
{{vars.name.headers}} — response headers

Debug Nodes

Log Message

Writes a message to the execution log without stopping the flow. Useful for debugging.

Message — text to log (supports templates)

The message appears in the execution log with per-node trace and timestamp.

Control Nodes

Return

terminal

Stops playbook execution and optionally returns a value to Jira Automation.

Return Value — optional (supports templates)

Terminal node — no outgoing connections. The return value is accessible via smart values in Jira Automation.

Stop with Error

terminal

Stops playbook execution with an error message. Logs as "controlled stop" (distinct from unexpected errors).

Error Message — error text (supports templates)

Terminal node — no outgoing connections. The message appears in the Jira Automation audit log.

Break Loop

terminal

Breaks out of the current For Each loop. Execution continues with the "done" branch of the For Each node.

Terminal node — no outgoing connections. Has no effect if used outside of a loop.

Error Handling

All Jira API nodes (Create Issue, Update Fields, Transition Issue, Add Comment) have two output handles:

ok (green) — the API call succeeded
error (red) — the API call failed

How it works:

If the API call succeeds, the flow continues through the ok branch
If the API call fails and an error branch is connected, the flow continues through the error branch
If the API call fails and no error branch is connected, the playbook stops with an error (default behavior)

Inside an error branch, the following variables are available:

{{vars._error.message}} — human-readable error message
{{vars._error.statusCode}} — HTTP status code (e.g. 404, 400)
{{vars._error.body}} — raw response body from the Jira API

The _error variable is automatically cleared after the next successful Jira node execution.

Secrets

Secrets are stored encrypted in Forge Storage and are never exposed in the UI or execution logs after saving.

Manage via Secrets Vault (main screen → Secrets button)
Reference in any node field: {{secrets.SECRET_NAME}}
Secret names may contain A-Z, a-z, 0-9, underscores, and dashes

Scopes:

Global — available to all playbooks
Project — available to playbooks in a specific project
Playbook — available only to a specific playbook

Secret values are never displayed after saving (shown as •••••). Values are automatically masked in execution logs.

Execution Logs

Every playbook run is logged with a full per-node trace. Access logs from the main screen by clicking the Logs button on any playbook.

Each log entry includes:

Status — success, error, or controlled stop (from Stop with Error node)
Inputs — trigger data and configuration
Final variables — variable state at the end of execution
Result — return value or error message
Per-node log — each node's execution result with timestamps

The last 20 executions are stored per playbook.

Keyboard & Interaction

Add a node — click a node in the left palette, or drag it onto the canvas
Configure a node — click the node on the canvas; settings appear in the right panel
Deselect — click an empty area on the canvas
Connect nodes — drag from an output handle to an input handle

Connection rules: Each output handle can have at most one outgoing edge. Terminal nodes (Return, Stop with Error, Break Loop) cannot have outgoing connections.