what is node-based color grading?

if you have watched a colourist work in davinci resolve, you have seen a row of small thumbnails connected by lines, each with a number under it. that is the node graph, and it is how most professional grading is organised.

this post explains what nodes are, why the workflow exists, and what changes when you grade that way.

a node is one step in the grade

every grade is a sequence of operations. white balance the shot, lift the exposure, add contrast, warm the shadows, isolate the skin tones, apply a look, add grain.

in a slider-based editor those steps all happen, but they happen invisibly and in a fixed order decided by whoever built the software. a node graph makes each one a separate box, connected in a chain, with the image flowing left to right through them.

the first node receives the original image. it does its work and passes the result to the next node. that node works on the already-corrected image, not the original. and so on, to the output.

that is the entire idea. everything else follows from it.

what nodes give you that sliders don't

you can see where each correction sits. the chain is the order of operations, drawn. there is no hidden pipeline to reason about.

you can move a correction. contrast before the look or after it. a qualifier before a hue shift or after. these produce genuinely different images, and with nodes you can try both in a couple of seconds rather than rebuilding the grade.

you can switch one off. bypassing a node leaves its settings intact and takes it out of the chain, so you can see exactly what it was contributing. this is the fastest way to answer "is this actually helping?" — and it is the single most useful habit to pick up from the workflow.

you can see the image at each stage. each node shows a thumbnail of what the picture looks like as it leaves that node, so you can read the grade being built up rather than only seeing the end result.

serial, parallel and layer

resolve offers three ways to connect nodes, and the distinction matters:

serial nodes run one after another, each receiving the previous result. this is the default and covers most work. corrections compound — contrast applied after a saturation boost operates on the already-saturated image.

parallel nodes each receive the same input and are blended together afterwards. this is what you want when two corrections should not affect each other — isolating skin tones and isolating a sky, for instance, where routing them serially means the second qualifier is selecting from an image the first one already changed.

layer nodes work like layers in a compositing app, with the later node stacked over the earlier one and a blend mode controlling how they combine.

most grades are mostly serial, with parallel branches where corrections need to stay independent.

the trap worth knowing about

the most common mistake in node grading is putting a qualifier — an hsl selection, a skin tone key — after a correction that changes the colours it is selecting.

qualifiers pick pixels by colour. if a node earlier in the chain has shifted the hue of your skin tones, the qualifier downstream is now selecting a different set of pixels than you set it up to select. the mask drifts, usually without any obvious sign that it has.

the fix is either to qualify before the correction that moves those colours, or to branch the chain so the qualifier sees the original image.

do you need nodes?

honestly, not always. if your work is "make this shot look good and hand over the file", a well-designed set of sliders gets you there faster, and the fixed order they run in is a reasonable one.

nodes earn their place when you need to know why something looks the way it does — when a grade has enough steps that the interactions between them stop being obvious, or when you need to hand the grade to someone else and have them understand it.

trying it without installing anything

resolve is the usual answer here, and it is free, but it is also a large install and a steep first hour.

luttie runs a node view in the browser. turning on advanced mode shows your grading chain as a connected graph — ten stages, each with a live thumbnail of the image as it leaves that stage. you can drag a stage earlier or later, switch one off to see what it was doing, and watch the previews update as you go.

it runs on your own gpu, so nothing is uploaded, and the grade exports as a .cube lut you can load into resolve, premiere or final cut.

it is a chain rather than a full branching graph — there are no parallel or layer nodes yet — so it covers the serial workflow rather than replacing resolve. for learning how order affects a grade, and for building a look you can carry elsewhere, that is most of the value.