Node-based editors: why nodes beat timelines for campaigns

Here is a campaign that looks tidy on a brief. Twelve markets. Nine languages. Two message versions. Four formats. The grid arithmetic says 864 videos, but nobody makes 864, because the grid is a lie. Languages pair with markets rather than multiplying against them. The second version only runs where the offer is live. The vertical cut exists for exactly two placements. The honest number is closer to 180, and the honest structure is not a grid at all. It is a sparse, paired, conditional web of relationships: this headline belongs to these markets, that footage belongs to this version, this format ships only there.

Marketing teams push that structure through two interfaces, and both fight it. A timeline serialises it: one output at a time, duplicated per variant, until nobody knows which of the 47 copies is true. A spreadsheet flattens it: the combinations survive as rows, but the logic that produced them lives in someone's head. The interface that actually fits was worked out decades ago, in visual effects suites and synthesiser racks: the node graph. Nubu's flow editor is built on it, and this piece explains why. Partly to document our own model, mostly to argue that node-based creative automation is the right shape for campaign production, whoever builds it.

Where node editors come from#

Ask a film compositor what a shot is and they will not describe a timeline. In Nuke, the standard compositing tool of the film industry, a shot is a graph: footage flows into colour corrections, into keys, into merges, into the final output, and every relationship between those operations is a visible wire. Houdini pushed the idea further into 3D: the network of operators is the artefact itself, a procedure the artist edits and the software runs. Blender brought the same model to materials and geometry with its shader and geometry nodes. Audio got there even earlier. A modular synthesiser is a node graph made of hardware: oscillators patched into filters patched into amplifiers, with the cable as the signal path. Software followed with environments like Max/MSP and Pure Data.

The pattern across all of them is consistent. First, the substance of the work is many-to-many relationships: one source feeding several operations, several operations feeding one result. Second, the work is non-destructive: the graph is a recipe, and you edit the recipe rather than the output. Third, the recipe re-executes: run it again and the same graph produces the same result.

Node editors did not win everywhere. Nobody cuts a feature film in one, and nobody should. They won in exactly the places where the relationships between operations, not the operations themselves, are the real complexity. Which brings us to campaigns.

Campaign versioning is a graph problem in disguise#

Look at what a multi-market campaign actually is. There are dimensions: markets, languages, versions, formats. There is content: headlines, offers, footage, colours, calls to action, legal lines. And there is a web of pairings and conditions connecting them. French copy serves France and Belgium but the Belgian end frame differs. The Sale version runs in five markets and only until Thursday. German headlines break the character limit that English fits comfortably. None of this is exotic. It is every international campaign ever briefed.

A timeline cannot hold that web, because a timeline is the recipe for one output. Version a campaign with timelines and you duplicate the timeline per variant, in After Effects compositions or Premiere sequences, and every duplicate is a fork that starts drifting the moment it exists. A copy change late in the project fans out into dozens of manual edits, each one a chance to miss. The craft tool is superb at making the film. It is hopeless at holding the structure of 180 of them.

A spreadsheet holds the combinations but not the logic. A row says UK, English, V2, 9:16, and the headline. It does not say why that combination exists, which other rows must change with it, or which combinations must never exist. The co-occurrence rules live in the operator's head, enforced by care and column discipline. Nothing stops an impossible row. And the sheet is inert: it describes work for someone to go and do elsewhere, which means the tracker and the truth diverge the moment production starts. This is the versioning trap at the heart of manual campaign production, the same one we described in our overview of creative advertising automation.

A sparse many-to-many structure that must stay editable, checkable and re-executable. That is not a timeline problem or a table problem. That is precisely the problem node editors were invented for.

The model: dimensions gate, content flows#

In Nubu, a campaign automation is a flow: a graph you wire on a canvas, read left to right, from inputs to rendered outputs. The editor ships nineteen node types across four palette groups (flow, data, integration and AI; the full catalogue is in the docs), but the heart of the model is a division of labour between two families.

Dimension nodes (Market, Language, Version) do not hold content. They gate it. Each row on a dimension node is a value the campaign varies by: UK and France on a Market node, English and French on a Language node, V1 and V2 on a Version node. Content nodes (Text, Value, Colour, Dropdown, Tags, Image, Video, Audio) hold the things that vary: headlines, prices, brand colours, footage. Wire content downstream of dimension rows and every pipe accumulates the gates it passes through. A headline wired after the UK row and the English row belongs to the UK and English combination, and nowhere else.

At the end of the graph sit a Template node and an Output node. The Template node reads a video template and exposes its fields as typed inputs. The Output node defines a destination: platform, placement, ad copy fields, naming. The build walks every gated path and produces one creative per combination. A creative, in Nubu's vocabulary, is one finished deliverable: a specific market, language, version and format of one ad.

Connections are typed, and the typing is visible. A text field on a template accepts a text source. A footage slot accepts an image or a video. A colour field accepts a colour. Every input handle wears the colour of the node type that fits it, so matching connector colours mean it fits, and the editor refuses a genuinely impossible pipe at drag time. You learn the wiring rules by looking at them, which is the point: the connection model is the user interface, not documentation behind it.

This is the compositing insight transplanted. The campaign's structure, which the spreadsheet kept in your head and the timeline kept nowhere, is now the thing on screen (the flows overview walks it end to end).

Chain order is scope: the two or four example#

Here is the part of the model with real depth, and it is worth teaching properly because it is exactly the logic a spreadsheet cannot express.

In a flow, a row is fed by every upstream chain that reaches it. So where a dimension sits in the chain decides the scope of its split. Take two markets (UK and France), two languages (English and French), and a single shared Version row, V1.

Chain them Market, then Language, then Version: UK feeds English, France feeds French, and both language rows feed the one V1 row. The V1 row sits downstream of two distinct chains, UK to English and France to French, so a template wired after it builds exactly two creatives: UK English V1, and France French V1. The pairing you wired upstream survives the shared row.

Now reorder the same three nodes: Market, then the shared V1 row, then Language. UK and France both feed V1, and V1 feeds English and French. Each language row is now fed by every chain that reaches it, which means both markets. Four combinations come out: UK English, UK French, France English, France French, all at V1. Same three nodes, same values, four creatives instead of two.

Nothing about this is a quirk. A shared row is a junction: everything upstream of it funnels together, and its own split applies to everything downstream. Put the junction before the pairing and the pairing is gone. The graph makes the difference visible, because you can see the funnel. Write the same campaign as three spreadsheet columns and the two structures are literally indistinguishable, which is how a tracker quietly promises four films when the plan was two.

The working rule that falls out: share upstream, split downstream. Dimensions whose values span the whole campaign, like a phase (Always On, Sale), belong early in the chain. Dimensions that pair tightly, like market and language, belong adjacent, wired in the pairing you intend. And because Version in Nubu is an ordered path rather than a single value, a phase node and a creative version node can both live in one flow, with a shared phase lane serving everything beneath it.

Spreadsheets welcome: CSV rows become nodes#

None of this argues against spreadsheets as a place where campaign data is born. Briefs arrive as sheets. Translations come back as sheets. So the graph meets them halfway: a CSV node takes a file (uploaded directly, or picked from your asset library) and exposes its columns as pipeable outputs.

Pipe a column into a dimension or content node and every unique value in that column generates a row, locked and visible on the node, behaving exactly like a row you typed by hand: it gates downstream content, it pipes out to templates. Pipe the market column into a Market node and the language column into a Language node and auto-pairing draws the wires between generated rows from co-occurrence in the data: French connects to France because they appear on the same CSV rows, and never to the UK, because they do not.

Row logic gets a node of its own. An If/Else node tests columns (status equals Live, budget above a threshold), conditions combine with AND, and the True and False outputs route rows onwards or filter them out of everything downstream. Anything unevaluable deliberately routes False, so a malformed cell can only ever remove a creative, never invent one.

The crucial move happens at build time. Every generated value remembers which CSV rows it came from, and the build prunes any combination no actual row satisfies. Two headlines can share the same version hub, one English and one French, without colliding, because the build knows no row pairs the French headline with the English chain. Five source rows can honestly produce three creatives: one filtered by the If/Else, one an exact duplicate that deduplicates. And because generated rows are derived from the file rather than copied out of it, replacing the CSV updates the graph instead of orphaning it. Working with data covers the details, and we have written a full walkthrough of turning a CSV into finished video ads.

The spreadsheet keeps the job it is good at, holding records, and hands the job it was failing at, holding logic, to the graph.

The canvas argues back: live diagnostics#

A structure this expressive needs an editor that pushes back, and this is where the discipline of the model pays off. Nubu's canvas and its build apply one set of checks to one graph, so what the editor flags and what the build enforces can never disagree.

Diagnostics are live and they are precise. Problems do not appear in a log after you press Build; they ring the exact offending control as you wire. Pipe a 60-character headline at a placement whose headline field caps at 30 and three things light up at once: the field on the Output node, the pipe carrying the value, and the source row on the Text node that produced it. A pipe carries the field's limitation backwards through the graph, so you fix the problem at its origin, not at its symptom.

The severity rule is strict and worth stealing for any tool. An error means the build will refuse: an Output that nothing feeds, two sources feeding one field for the same combination, a delivery platform mismatch. A warning means the build will run but you should know: an unused node, a language your copy does not fully cover. Errors block, warnings inform, and nothing silently skips.

Notice what the editor does not do: it does not hard-block every questionable connection. Wire an Output configured for Meta into a Google Ads node and the pipe connects, wears a label saying exactly what is wrong, and rings both ends. You might be mid-rework; the graph lets you be, while making the unfinished state impossible to miss and impossible to build. A tool that forbids ambiguity pushes the mess into your head; one that renders it visibly gets it resolved.

Preview and determinism: trust before render#

The final objection to automation is trust. If a machine fans one graph out into 180 videos, how do you know what you are about to get?

You look at it. A Preview node takes any Output and tables the exact creatives a build would produce: every combination, with its market, language, version, resolved copy and footage, before anything renders. It is a dry run by the same engine as the real build, not a separate estimate, so the table and the build cannot drift apart. Each row can also render a single preview through the real pipeline when you want to see one with your eyes before committing to all of them, and a later build that matches its content reuses that render rather than paying for it twice.

Underneath sits a property borrowed straight from the compositing world: determinism. A creative's identity is derived from everything that makes it that creative, its flow, output, placement, market, language, version path and composition, so the same graph produces the same identities every time. Even the deliberately randomised parts obey: a footage pick set to random is fixed per creative, so a rebuild reproduces the same picks byte for byte rather than reshuffling your campaign behind your back. Creatives that are already queued, rendering or rendered are protected: change their content and the build produces a versioned revision instead of overwriting history.

Same graph in, same campaign out. That single sentence is the difference between automation you audit once and automation you re-check every Friday.

What a team gets that a timeline cannot give#

Everything so far would matter to a single operator. The sharpest advantages appear when the campaign belongs to a team.

The logic is reviewable. The canvas is a faithful drawing of the campaign itself, not a diagram kept beside it. A colleague reviewing your campaign reads the actual mechanism: which markets exist, what gates what, where the copy comes from, what reaches which placement. Compare that to reviewing 47 timeline duplicates, or a spreadsheet whose conventions you were not there for. The graph is the documentation, and it cannot go stale, because it is also the thing that executes.

Editing is genuinely multiplayer. Flows support live collaboration with presence, and what you hold while editing is a single field, the smallest editable element, not the file and not even the node. While you hold a headline row, a colleague edits the row beneath it. A dead tab frees its fields within moments, and two people can never silently overwrite each other's work.

Conversation attaches to the work. Comment threads with @mentions live on the flow itself and on every creative it produces, down to timecoded comments on a video render. And because creative identities are deterministic, a thread survives a rebuild of the same creative: feedback stays attached to the thing it was about, rather than evaporating with an export.

Output traces back to intent. Every rendered ad traces to the exact nodes and values that produced it: who built it, from which template and version, with which inputs, gated by which rows. When a stakeholder asks why the Belgian French V2 says what it says, the answer is in the graph, not in an archaeology of exported files. Finished renders land back in the same workspace for review and approval, with the thread attached.

On the Business+ plan, the same fabric extends to AI and delivery. Organisations connect their own AI provider keys (Nubu sells no AI credits), and AI becomes another node in the graph rather than a bolt-on: pipe headlines through a translate task and the node grows a lane per market and language pairing, each riding its own chain's gates, with per-market brand glossaries applying tone rules, do-not-translate terms and approved translations as binding constraints. Before a build spends anything, it counts every distinct AI request and asks first, and rebuilding an unchanged graph re-spends nothing. Using AI nodes covers the mechanics.

Delivery follows the same philosophy: Meta Ads and Google Ads nodes (also Business+) take an Output and upload finished creatives as paused ads, for a human to review and switch on. The graph automates the assembly line, never the judgement.

The honest limits of node UIs#

If node editors were free of cost, every tool would be one. They are not, and the costs are worth stating plainly.

There is a learning curve. Gating, chain order and scope are a real mental model, and the two or four example above takes most people a beat to internalise. Your first hour in a flow editor is slower than your first hour in a spreadsheet, because the sheet defers the structural thinking the graph makes you do up front. The payback is real, not instant.

Small jobs feel heavier. Three ads for one market do not need a graph. Wiring Market, Language, Template and Output to produce a handful of creatives is ceremony; the model's fixed cost only pays back as combinations multiply. Nodes are leverage, and leverage is overhead at low volume.

Big graphs demand discipline. A graph can rot exactly the way a workbook rots. Fifty unnamed nodes in a tangle are as opaque as fifty cryptic columns. Naming nodes, flowing left to right, and keeping shared lanes deliberate are the graph equivalent of spreadsheet hygiene, and no editor can fully impose them for you.

Bulk text editing is worse on a canvas. Editing forty headlines cell by cell is faster in a table than in forty node rows. That one is honest and structural, and it is precisely why the CSV node exists: edit in the sheet, pipe into the graph, keep each tool on its best surface.

When a timeline or a spreadsheet is still the right tool#

The argument here is not that nodes replace everything. It is that each interface has a shape, and you should match the shape to the problem.

A timeline is the right tool for making the film. Crafting the master creative, the cut, the motion, the sound, is temporal, singular work, and timeline tools are unbeatable at it. Nubu's own templates are built in After Effects, on a timeline, by motion designers doing exactly that craft; the graph then takes over where the craft ends and the combinatorics begin, as we set out in our guide to After Effects automation. One artefact, deep judgement: timeline.

A spreadsheet is the right tool for records. Data capture, budgets, reporting, status: flat facts belong in flat tables, and the CSV node means the sheet can stay the source of record while the graph consumes it. And if your campaign genuinely is flat, ten unrelated assets with no shared structure, a list beats a graph honestly.

The graph earns its place at a specific moment: when many outputs share structure, and the structure keeps changing. That is what campaign versioning is. Markets multiply, pairings constrain, conditions route, and one late copy change must propagate correctly through the lot. Timelines serialise that problem. Spreadsheets hide it. A node graph is the only mainstream interface that shows it, checks it and re-executes it.

That is the case for node-based creative automation: not novelty, but fit. VFX and audio proved the model wherever relationships are the complexity. Campaigns are exactly that, and they have been waiting for their version of it. If you want to see the model in the flesh, the feature tour shows real flows end to end, and a free workspace lets you wire one yourself in an afternoon.