Logica condizionale avanzata e router

You've already learned about basic filters to stop a workflow or direct it down a single 'if/then' path. But what if you need more complex decision-making?

This lesson dives into advanced conditional logic, allowing your automations to handle many different scenarios dynamically.

Many real-world processes aren't simple 'yes' or 'no' decisions. They have multiple potential outcomes. Think about:

• New customer signups: Are they premium, standard, or trial? Each needs a different onboarding.
• Support tickets: Is it a bug, a feature request, or a general inquiry? Different teams handle each.
• Lead qualification: Is it a hot, warm, or cold lead? Each requires a unique follow-up.

We need a way to build one automation that intelligently handles all these possibilities.

In no-code platforms, a 'Router' (sometimes called 'Paths' or 'Filters' within a single module) is your solution for multi-branch workflows. It's a powerful module that lets your automation split into several distinct paths.

• A single trigger starts the workflow.
• The router evaluates conditions for each path.
• Data flows down the first matching path.

Think of it like a railway switchyard, directing different trains (data) to different tracks (workflow branches).

A router takes incoming data and acts as a decision point. Each 'path' or 'branch' coming out of the router has its own specific filter conditions.

If the incoming data meets a path's conditions, it's directed down that particular path, and the actions configured for that path will execute. This enables highly dynamic and intelligent workflows.

When you add a router to your workflow, you'll configure multiple paths emanating from it. For each path, you define a set of conditions, much like you would for a standalone filter.

• Path 1: Condition A (e.g., 'Order Total' is greater than 1000)
• Path 2: Condition B (e.g., 'Order Total' is between 100 and 999)
• Path 3: Condition C (e.g., 'Order Total' is less than 100)

Each path can then have its own unique sequence of actions.

This is crucial! Routers evaluate their paths in a specific order, usually from top to bottom (or left to right, depending on the platform's UI).

The first path whose conditions are fully met will execute. Even if subsequent paths also match the data, they will be ignored. This is known as 'first match wins'.

Therefore, always place your most specific or exclusive conditions at the top, and more general conditions further down. The order of your paths matters greatly!

What happens if your incoming data doesn't match the conditions of any of your defined paths?

Many router modules offer a 'Fallback Path' or 'Default Route'. This special path will execute if no other primary paths' conditions are met. It acts as a safety net.

A fallback path is excellent for handling unexpected data, logging unclassified items, or ensuring *something* always happens, preventing your workflow from simply stopping.

Let's consider a practical use case: qualifying new leads from a web form. We want to categorize leads and trigger different actions based on their 'Lead Score' and 'Industry'.

• Hot Lead: Score > 90 AND Industry = 'Tech'
• Warm Lead: Score > 70
• Cold Lead: All other leads

This scenario perfectly demonstrates the power of a router to direct leads to the appropriate sales funnel.

Here's how you'd configure the paths for our lead qualification example:

• Path 1 (Hot Lead):
  Conditions: Lead Score is greater than 90 AND Industry is 'Tech'.
  Actions: Send 'Hot Lead' email, assign to Senior Sales.
• Path 2 (Warm Lead):
  Conditions: Lead Score is greater than 70.
  Actions: Send 'Warm Lead' email, assign to Junior Sales.
• Path 3 (Cold Lead / Fallback):
  Conditions: None (this acts as the fallback).
  Actions: Send 'Cold Lead' email, add to nurturing sequence.

Remember, Path 1 must be evaluated first!

Congratulations! You've learned how 'Routers' (or 'Paths') enable advanced conditional logic in your no-code automations. They are essential for building dynamic workflows that can handle diverse scenarios by splitting into multiple, distinct branches.

Remember these key takeaways:

• Routers create multi-branch workflows.
• Define specific conditions for each path.
• Path order is critical ('first match wins').
• Use a 'Fallback Path' for unhandled scenarios.

This skill is vital for building robust, intelligent, and truly automated processes!