Should functions call each other in sequence, or should one function coordinate them?

For a pipeline of separate steps, I'd use a coordinating function. It makes the order visible in one place, and each step can focus on its own job rather than knowing what comes next.

Make sure you actually assign each return value before passing it on. In Python, calling func1(x) by itself does not create a value1 variable in the caller. You'd assign value1 = func1(x), then pass value1 to func2, and so on.

That also makes it straightforward to inspect intermediate values while debugging or test a step on its own.

Think about what belongs at the same level of detail. If reading input, transforming it, and producing output are the main stages, showing them together tells the reader how the process works.

But a function can absolutely call helpers that are part of its own job. A connection cleanup function, for example, might call smaller helpers without the caller needing to know every cleanup detail. Nesting isn't inherently bad. The question is whether the extra calls explain the function's purpose or sneak unrelated next steps into it.

There's also a shorter way to express a pipeline: pass the result of one call directly into the next. That's fine when the steps are simple, but named intermediate values can be easier to read and inspect. Use whichever makes the flow clearer.

One detail about your second version: returning a value from the last function doesn't automatically return it all the way to the caller. Each function in the chain would need to return the result of the call it makes.

Also, nested calls keep the earlier calls on the stack until the later ones finish. For a short chain that's usually not the reason to choose one style over the other. Clarity and how the responsibilities fit together matter more.