Connect and Arrange Workflow Steps

Connect and Arrange Workflow Steps

A workflow becomes useful when its blocks are connected in the correct order.

In Feluda Studio, connections show how information moves from one block to the next.

A clear canvas also makes the workflow easier to understand, test, and improve.

This guide explains how to:

• connect blocks;
• check connection direction;
• arrange a readable canvas;
• organise different paths;
• avoid confusing layouts; and
• review the complete flow before testing.

How connections work

Each block has connection points.

An output connection sends information from the current block.

An input connection receives information in the next block.

To connect two steps, drag from the output handle of the first block to the input handle of the next block.

For example:

Input → LLM → Output

The Input block sends the source text to the LLM block.

The LLM block sends its result to the Output block.

Connection direction matters

A workflow should follow the order in which the task happens.

In a left-to-right layout:

Start → Process → Result

In a top-to-bottom layout:

Start
  ↓
Process
  ↓
Result

The visual direction should match the actual path.

Avoid placing the result before the starting block or drawing connections that appear to move backward without a clear reason.

Add blocks before connecting them

It is often easier to place the main blocks first.

For a simple workflow:

1. add the Input block;
2. add the LLM block;
3. add the Output block;
4. arrange them in order; and
5. create the connections.

This helps you see the intended flow before drawing any lines.

Connect a simple workflow

To create:

Input → LLM → Output

Follow these steps:

1. Drag from the Input block's output handle.
2. Drop the connection on the LLM block's input handle.
3. Drag from the LLM block's output handle.
4. Drop the connection on the Output block's input handle.
5. Review the complete path.

Every main step should be reachable from the starting block.

Check for unconnected blocks

A block may appear on the canvas without being part of the workflow.

Before testing, look for:

• blocks with no incoming connection;
• blocks with no outgoing connection;
• branches that do not reach an output;
• error paths that end without a result; and
• old blocks left behind after editing.

Remove unused blocks or connect them to the correct path.

Studio may show visual indicators when part of the flow is not connected correctly.

Arrange the main path clearly

Choose one direction for the main workflow.

Left to right is often easiest for wider screens.

Top to bottom can be useful for narrow flows or long sequences.

Keep the main path in a straight or gently curved line.

For example:

Input → Classify → Extract → Summarise → Output

A clear main path lets readers understand the flow without opening every block.

Keep related steps together

Place blocks that belong to the same part of the task near each other.

For example:

• input and preparation steps;
• classification and routing steps;
• extraction and analysis steps;
• output and saving steps; or
• error and review steps.

This creates visual groups even when the workflow does not use formal sections.

Use spacing to improve readability

Leave enough space between blocks for:

• connection lines;
• decision paths;
• error routes;
• block names; and
• future changes.

Blocks placed too close together can make connections difficult to follow.

Blocks placed too far apart can make the workflow feel disconnected.

Use consistent spacing where possible.

Avoid crossing connections

Crossing lines make a workflow harder to read.

When two connections cross:

• move the blocks;
• place related branches above or below the main path;
• create more space;
• shorten unnecessary routes; or
• change the overall direction of the flow.

A workflow should be understandable from the canvas before you inspect each connection closely.

Arrange decision paths

Classification and decision blocks can create several routes.

Place the decision block on the main path, then arrange each outcome in a separate direction.

For example:

Input → LLM Label
             ├→ Question → Answer Draft → Output
             ├→ Complaint → Apology Draft → Output
             └→ Other → Human Review → Output

Keep labels and paths visually separate.

Use a consistent order, such as:

• normal path in the centre;
• alternative paths above or below;
• error or review paths at the bottom.

Give every branch an ending

Each decision path should lead to:

• another processing step;
• a clear Output block;
• a review path;
• a retry path; or
• another intentional endpoint.

Avoid branches that stop without explanation.

A user should be able to understand what happens for every possible route.

Arrange error paths separately

Some blocks can return different error outcomes.

Keep error routes visible but separate from the main success path.

For example:

LLM
├→ Success → Output
├→ Timeout → Retry
└→ Error → Review Output

Place error blocks below the main path or in another consistent area.

This makes the normal process easy to follow while keeping failures reviewable.

Name blocks before arranging a large flow

Clear names make layout decisions easier.

Instead of:

• LLM 1;
• LLM 2;
• Output 1; and
• Expression 3;

use:

• Classify Request;
• Extract Customer Details;
• Draft Response;
• Check Required Fields; and
• Return Review Message.

When names describe outcomes, the canvas reads like a process.

Use one purpose per block

A block with one clear task is easier to place and connect.

For example:

Input
→ Classify Message
→ Extract Details
→ Draft Reply
→ Output

This is easier to understand than one large AI block that performs every task at once.

Focused blocks also make errors easier to locate.

Place Input at the beginning

The Input block should normally appear at the start of the flow.

Place it on the left or at the top.

Give it a name that explains what the workflow expects, such as:

• Customer Message;
• Meeting Notes;
• Contract Text; or
• Product Brief.

This helps the user understand where the process begins.

Place Output at the end

Output blocks should appear at clear endpoints.

Place them on the right or at the bottom of their path.

Use names such as:

• Final Summary;
• Extracted Details;
• Draft Reply;
• Review Required; or
• Error Message.

When a workflow has several outputs, arrange them near the branch they belong to.

Place shared steps before branches

When several paths need the same preparation, complete that work before the decision.

For example:

Input
→ Clean Text
→ Extract Basic Details
→ Classify
→ Different Paths

This avoids repeating the same step inside every branch.

Use shared steps only when every path truly needs the same result.

Place shared steps after branches carefully

Different paths may return to one shared final step.

For example:

Question Path ─┐
Complaint Path ├→ Format Final Result → Output
Other Path ────┘

This can keep the workflow smaller.

Confirm that every branch returns information in a form the shared step can use.

If the branches produce very different results, separate final steps may be clearer.

Use Emit for visible progress

An Emit block can show an intermediate result while the workflow continues.

Place it after a meaningful stage.

For example:

Input
→ Extract Details
→ Emit Extracted Details
→ Prepare Report
→ Output

Keep progress updates on the main path and label them clearly.

Do not add so many Emit blocks that the flow becomes difficult to follow.

Keep tools near the step that uses them

When an LLM or Expression step uses a tool, arrange the workflow so the purpose is easy to understand.

Name the relevant block by the action it performs, such as:

• Search Approved Source;
• Create Journal Entry;
• Retrieve Customer Record; or
• Save Final Report.

The canvas should show where the external action occurs.

Rearrange without changing the logic

Moving a block on the canvas changes its visual position.

It does not change the workflow order as long as the connections remain the same.

You can rearrange blocks to improve readability without rebuilding the process.

After moving several blocks, review every connection to confirm that none were removed or connected incorrectly.

Add blocks where they are needed

Studio allows you to add blocks from the block palette.

You may also be able to right-click the canvas and add a block at the cursor position.

Adding the block near the intended location can make the layout easier to organise.

After adding it:

1. give it a clear name;
2. place it on the correct path;
3. connect the incoming step;
4. connect the outgoing step; and
5. configure the block.

Insert a block between two steps

Imagine the workflow currently contains:

Input → LLM → Output

You want to add an extraction step before the summary.

The new flow should become:

Input → LLM Extract → LLM → Output

To make the change:

1. add the LLM Extract block;
2. place it between Input and LLM;
3. remove or replace the old direct connection;
4. connect Input to LLM Extract;
5. connect LLM Extract to LLM; and
6. test the complete path.

Check that no unwanted connection still skips the new block.

Remove a block safely

Before removing a block, identify:

• which block sends information into it;
• which block receives its result;
• whether another branch depends on it; and
• whether it performs an important tool or error action.

After removal, reconnect the remaining path where appropriate.

Test the workflow again.

Removing a block without repairing the path can leave later steps unreachable.

Use undo after an accidental change

Studio supports undo for recent canvas changes.

Use Ctrl+Z on Windows or Linux, or Cmd+Z on macOS, when you accidentally move, add, remove, or change something.

After undoing, inspect the canvas to confirm that the intended layout and connections have returned.

Save after important corrections.

Review visual validation

Studio can show visual indicators when the flow has a connection or validation problem.

Review any warning before running the workflow.

Common causes include:

• a missing input;
• an unconnected block;
• a branch without an endpoint;
• an incomplete block configuration; or
• a connection that does not match the block's expected input.

Correct the earliest visible issue first.

Trace the workflow from start to finish

Before testing, follow every path with your eyes.

For each path, ask:

1. Where does the information enter?
2. Which step receives it next?
3. What result does that step produce?
4. Where is that result sent?
5. What happens if the step fails?
6. Where does the path end?

If you cannot answer these questions from the canvas, improve the names, spacing, or layout.

Review what each connection carries

A connection does not only show order. It also passes information.

Check whether the next block receives the right result.

For example:

Input → Extract Details → Draft Reply

The Draft Reply step may receive only the extracted fields rather than the complete original message.

Decide whether that is enough.

If the next step needs additional context, change the flow or instruction so the required information remains available.

Keep output formats consistent

When several branches join one later step, make sure they return compatible information.

For example, if a shared formatting step expects:

• Summary;
• Category; and
• Recommended Action;

every incoming branch should provide those fields.

Inconsistent branch output can make the shared step unreliable.

Use a layout pattern

Consistent layout patterns make larger workflows easier to read.

A useful pattern is:

• input and preparation on the left;
• main processing in the centre;
• decisions branching vertically;
• final outputs on the right; and
• error paths below.

Another useful pattern is:

• start at the top;
• move downward through the main process;
• place alternatives to the side; and
• place outputs at the bottom.

Choose one pattern and use it throughout the flow.

Avoid very long connection lines

Long lines can make it difficult to see which blocks belong together.

Move related blocks closer when possible.

If a connection must cross a large part of the canvas, consider whether:

• the block is in the wrong place;
• a shared step should be moved;
• the workflow should use separate branches; or
• the process has become too large for one clear flow.

Know when a workflow is becoming too large

A workflow may be too large when:

• the main path is hard to find;
• many lines cross;
• one change affects several unrelated areas;
• block names no longer explain the process;
• testing every path becomes difficult; or
• different tasks have been combined into one flow.

Simplify the workflow by:

• removing unnecessary steps;
• combining truly identical paths;
• separating unrelated tasks;
• using clearer labels; and
• rebuilding the layout around the main purpose.

Test after changing connections

Every connection change can affect the result.

Test the workflow after:

• adding a block;
• removing a block;
• changing a branch;
• joining paths;
• adding an error route; or
• moving a step to another part of the process.

Use a small example first.

Then test every affected path.

A clear beginner layout

For a first workflow, use:

[Input] → [LLM] → [Output]

Place the blocks in one straight line.

Use clear names:

[Source Text] → [Create Summary] → [Summary]

This layout is simple, readable, and easy to test.

A clear branching layout

For a classification workflow, use:

[Customer Message]
        ↓
[Classify Request]
  ↙      ↓       ↘

[Question] [Complaint] [Other] ↓ ↓ ↓ [Output] [Output] [Review Output]

Keep each route separate and give every path a clear ending.

Final canvas checklist

Before saving or running the workflow, confirm that:

• the Input block is easy to find;
• the main path follows one visual direction;
• every required block is connected;
• unused blocks have been removed;
• decision paths are clearly separated;
• error routes are visible;
• crossing lines have been reduced;
• block names explain their purpose;
• every path reaches an intentional endpoint; and
• the complete workflow can be understood from the canvas.

A clear layout does not only look better.

It makes the workflow easier to test, maintain, and trust.