The canvas

Adding nodes

Three ways, all equivalent:

• Drag an item from the palette onto the canvas.
• Click a palette item — the node lands after the last one, laid out for you.
• Double-click empty canvas for a quick-add search box; type, press Enter.

Press / anywhere to focus the palette search.

Node kinds

Node	Compiles to	Inputs
Source	input, or a join/union with	none
Transformation	an entry of transformations	one (two for join and union)
Validation rule	one entry of validations.rules — one box per rule	one
Quality destination	validations.report or validations.outputs.valid/.invalid	none — it is a declaration
Destination	an entry of outputs	one
Note	nothing	none

A node shows its most meaningful parameter under the title — the condition of a filter, the expression of a computed column, the join type and key — so a Job is readable without opening anything.

Quality destinations

The validations block writes up to three datasets of its own, and each is a box you add from the palette’s Quality section — not something you wire up:

Palette item	Compiles to
Quality report	validations.report — one row per rule
Quarantine — valid rows	validations.outputs.valid
Quarantine — invalid rows	validations.outputs.invalid

They take no connections: the validations block is one per Job, so these belong to the Job, not to any single rule. Drop one anywhere on the canvas and it compiles. A Job may hold one of each; a second is an error, as is a quality destination with no validation rule to fill it.

Quarantine audits — `filter` routes

Quarantine is a copy, not a split. The framework writes the quarantine sinks and then writes the Job’s own destinations from the same, complete DataFrame — invalid rows included. So a Job with quarantine writes the bad rows twice: once to the quarantine sink, once to the main destination.

Use it to audit: “which rows broke a rule, and how many?” — without touching the flow.

To route — only the good rows reach the curated table — use the pipeline itself: a filter node before the destination, and a second branch for the rejects. The cost is that you restate the condition in SQL, so keep it in step with the rules; the gain is that the main destination carries exactly what you meant.

on_failure is not a destination and stays in Job settings: it decides whether a violation aborts the run.

Connecting

Drag from a node’s right handle to the next node’s left handle. Connections are validated as you draw: Studio refuses a link into a source, a self-link, and anything that would create a cycle.

Each input handle takes one connection. Dropping a second one replaces the first, which is the quickest way to splice a node out of a chain.

From the keyboard: focus a node, press C, Tab to the target, then C again. Escape cancels. The node toolbar has the same actions under Connect to….

Branching to several destinations

Connect the same node to two destinations and the graph forks. Everything before the fork stays in the main transformations; everything after it belongs to that destination.

source → filter → cast ─┬─→ group_by → delta        ← group_by is the delta output's own
                        └─→ parquet                  ← filter and cast are shared

Checkpoint before a fork

Each destination re-reads the same DataFrame, so put a checkpoint as the last shared transformation. Without it Spark recomputes the entire lineage once per destination.

Joins and unions

These nodes have two inputs. The left one continues the main chain; the right one takes the second source.

                 ┌── delta(customers) → filter → select ──┐   ← with + with_transformations
source → filter ─┴──────────────────────────────────────→ join → destination

Everything between the side source and the join becomes with_transformations, applied to the right side before the join runs.

Caution

union has no with_transformations in the framework, so Studio flags a non-empty side chain as an error instead of compiling something that would be silently ignored at run time.

Muting and deleting

Mute a transformation (the toolbar’s eye, or the inspector menu) to keep it on the canvas while excluding it from the compiled JSON — the quickest way to test whether a step is the problem, without losing its configuration.

Delete removes the node and its connections in a single undo step.

Layout

Shift+Ctrl/⌘+L re-runs the automatic layout: left to right, side chains stacked under the node they feed. Positions are saved with the Job, so a tidied graph stays tidy.

Keyboard

Shortcut	Action
Ctrl/⌘+K	Command palette
Ctrl/⌘+S	Save now (edits autosave anyway)
Ctrl/⌘+Z / Shift+Ctrl/⌘+Z	Undo / redo
Ctrl/⌘+D	Duplicate selection
Delete	Remove selection
Ctrl/⌘+Enter	Run panel
Ctrl/⌘+J	JSON panel
Ctrl/⌘+/	AI assistant
Ctrl/⌘+E	Issues panel
Shift+Ctrl/⌘+L	Auto-layout
C	Start / complete a connection from the focused node
/	Focus the palette search

The issues panel

Linting runs while you type. It reports what is statically decidable and stays quiet about the rest — a false positive costs more than a missing warning.

Severity	Examples
Error	no destination; an orphan node; a required field empty; merge without merge_keys; a binary destination (read-only format); two main inputs into one node
Warning	a collect with no upstream checkpoint; a {{variable}} nothing publishes; a {param} never declared; two destinations writing the same path; a positional union
Info	a debug node left in the Job; no validations block

Click any issue to select the node and jump to the offending field.

Saving

Edits autosave a moment after you stop typing; the status bar shows Saved or Unsaved. Ctrl/⌘+S forces it. Closing a Job flushes anything pending, so navigating away never loses the last keystrokes.

Undo history covers structural changes and field edits, coalescing rapid typing into one step so a single undo steps back over a word rather than a character.