5.3 Practical Condition Examples

You understand how conditions work and how to add them in the UI. Now let's see how to apply this knowledge to real business scenarios. This section shows complete, production-ready examples you can adapt to your own workflows.

Understanding Cell States

Before diving into examples, let's review the different states your cells can display:

State	Color	Icon	Meaning
Ready	Gray	—	Not processed yet
Queued	Blue	⏱	Waiting to execute
Running	Blue (pulse)	⟳	Currently executing
Completed	Green	✓	Success with data
Error	Red	✗	Execution failed
Rate Limited	Yellow	⏸️	Throttled by rate limit
Skipped	Gray	⊘	Intentionally skipped

In the troubleshooting sections below, we mainly focus on Skipped (Condition failed) since that's related to your condition logic. If you see Unsuccessful instead, the condition passed but an error occurred during execution—check the error message for details.

Example 1: Smart Lead Enrichment

Business Goal: Enrich leads intelligently to minimize API costs while maximizing data quality

The Challenge

Premium enrichment API costs $5 per call
Processing 10,000 leads per month
Without optimization: $50,000/month
Need to reduce costs without losing quality leads

The Solution: Tiered Conditional Processing

Let's build a taible that filters leads through multiple quality gates before spending money on premium enrichment.

Taible Structure:

Columns:
1. email (Manual)
2. email_validation (Calculated - Free)
3. basic_info (Calculated - Free tier API)
4. lead_score (Calculated - Custom logic)
5. premium_enrichment (Calculated - $5/call)
6. company_name (Calculated - Extract)

Column 1: email (Manual)

Type: Manual Text Column

This is where you or your forms add email addresses.

Configuration:

Click + Add Column
Select Manual Text
Column Name: email
Display Label: "Email Address"
Description: "Contact email address"

No condition needed - manual columns always run

Column 2: email_validation (Calculated)

Type: Email Validator Node (Free)

What it does: Checks if the email address is valid before spending money on enrichment

How to set it up:

Click + Add Column
Select Email Validator from the list
Configure the column:
- Column Name: email_validation
- Display Label: "Email Valid?"
Go to Run Configuration tab
Run Configuration
Run Mode
Once
Run once when email is added
Add Condition:
- Click Add Condition
- Field: email
- Operator: Is not empty
- Click Save

Why this condition?

Only validates if email exists
Prevents errors on empty rows
Fast and free - no cost to run

Column 3: basic_info (Calculated)

Type: Clearbit Free Tier or Similar

What it does: Gets basic company information for valid emails (free API)

How to set it up:

Add Clearbit column (or similar enrichment)
Configure Run Settings:
- Run Mode: Once
- Dependencies: Select email_validation
Add Condition:
- Field: email_validation → is_valid
- Operator: Equals
- Value: true

Why this condition?

Only enriches emails that passed validation
Saves API calls on invalid emails
Free tier, but still want to avoid waste

Column 4: lead_score (Calculated)

Type: Custom Code Node

What it does: Scores leads based on company size, industry, and domain quality

How to set it up:

Add Custom Code column
Configure Run Settings:
- Run Mode: Once
- Dependencies: Select basic_info
Add Condition:
- Field: basic_info
- Operator: Is not empty

Paste this scoring code:

javascript

let score = 0;
const company = basic_info;

if (!company) return 0;

// Company size scoring
if (company.employees > 1000) score += 30;
else if (company.employees > 100) score += 20;
else if (company.employees > 10) score += 10;

// Industry scoring
const targetIndustries = ['Technology', 'Finance', 'Healthcare'];
if (targetIndustries.includes(company.industry)) score += 25;

// Domain quality
if (company.domain && !company.domain.includes('gmail.com')) score += 15;

return score;

Why this condition?

Only scores leads where we got basic info
No point scoring if enrichment failed

Column 5: premium_enrichment (Calculated)

Type: ZoomInfo or Similar ($5/call)

What it does: Deep enrichment for high-quality leads only

✨ This is Where the Magic Happens

This condition is the key to saving $40,000 per month. By only enriching leads with scores above 70, we ensure premium API calls are only made for leads that are:

At a good-sized company (scored for size)
In our target industries (scored for industry)
Using a business domain (scored for domain quality)

How to set it up:

Add ZoomInfo column (or similar premium service)
Configure Run Settings:
- Run Mode: Once
- Dependencies: Select lead_score
Add Condition (the critical filter):
- Field: lead_score
- Operator: Greater than
- Value: 70
Rate Limiting (optional but recommended):
- Enable rate limiting
- Set to: 100 calls per hour

Why this condition?

Only spend $5 on high-quality leads
70+ score means good company, right industry, decent size
Low-score leads are skipped automatically

Lead Enrichment Pipeline Flow

Email Validation

Free • Always runs

8,000 valid 2,000 invalid

Basic Info (Free API)

Condition: email_valid = true

7,000 enriched 1,000 failed

Lead Scoring

Custom logic • Free

Score > 70: 2,000Score < 70: 5,000

💰 Quality Gate

Premium Enrichment

$5/call

Condition: lead_score > 70

Only 2,000 calls

80% of leads skipped

$10,000

$50,000

Monthly Cost Savings

$40,000

80% reduction by using conditions

Column 6: company_name (Calculated)

Type: Transform Data Node

What it does: Uses premium data if available, falls back to basic data

How to set it up:

Add Transform Data column
Configure Run Settings:
- Run Mode: Once
- Dependencies: Select both premium_enrichment AND basic_info
Add Condition (use OR logic):
- Click Add Condition
- Field: premium_enrichment
- Operator: Is not empty
- Click Add Another Condition
- Toggle to OR (not AND)
- Field: basic_info
- Operator: Is not empty

Set the extraction logic:

javascript

if (premium_enrichment && premium_enrichment.company_name) {
  return premium_enrichment.company_name;
}
if (basic_info && basic_info.name) {
  return basic_info.name;
}
return "Unknown";

Why this condition?

Use premium data if available
Fall back to basic data if no premium enrichment
Always have some company name

The Cost Savings

Processing 10,000 leads:

Scenario	Count	Cost
Invalid emails (skipped at validation)	2,000	$0
Valid but no basic info (skipped at scoring)	1,000	$0
Valid, basic info, but score < 70	5,000	$0
High-quality leads (score > 70)	2,000	$10,000

Total cost: $10,000 Without conditions: $50,000 Savings: $40,000 per month (80% reduction!)

📊 Monitor Your Skip Rates

After setting this up, click any column header to see execution statistics. You should see about 80% of cells showing "Skipped" status. If your skip rate is too low, increase the threshold (try 75 or 80 instead of 70).

Example 2: Customer Segmentation with Different Actions

Business Goal: Send different email campaigns based on customer value and status

The Challenge

Different customer tiers need different communication
Can't send enterprise emails to free-tier customers
Want to automate but maintain personalization

The Solution: Status-Based Conditional Routing

Build a taible that automatically routes customers to the right email campaign based on their status and value.

Taible Structure:

Columns:
1. customer_email (Manual)
2. customer_status (Manual) - Values: "new", "active", "expiring", "churned"
3. customer_value (Calculated)
4. email_welcome (Calculated - Condition: new customers)
5. email_renewal (Calculated - Condition: expiring customers)
6. email_winback (Calculated - Condition: churned high-value)
7. email_basic (Calculated - Condition: active low-value)

Column 1-2: Manual Input Columns

Create two manual columns:

customer_email (Manual Text)
customer_status (Manual Dropdown with options: new, active, expiring, churned)

Column 3: customer_value (Calculated)

Type: Custom Code - Calculate Lifetime Value

This column calculates how much the customer has spent.

Configuration:

Run Mode: Once
Dependencies: customer_email
No condition (always calculate)

Code:

javascript

// Query your database or CRM
const orders = getOrdersByCustomer(customer_email);
const total = orders.reduce((sum, order) => sum + order.total, 0);
return total;

Column 4: email_welcome (Send to New Customers)

Type: Send Email Node

How to set it up:

Add Send Email column
Configure the email template with welcome message
Run Configuration:
- Run Mode: Once
- Dependencies: customer_status, customer_email
Add Conditions (both must be true):
- Field: customer_status
- Operator: Equals
- Value: new
- Click Add Another Condition
- Keep as AND
- Field: customer_email
- Operator: Is not empty

Why this condition?

Only send welcome email to new customers
Not to active, expiring, or churned
Verify email exists before trying to send

Column 5: email_renewal (Send to Expiring Customers)

Type: Send Email Node

How to set it up:

Add Send Email column
Configure renewal email template
Run Configuration:
- Run Mode: Once
- Dependencies: customer_status, customer_value
Add Conditions:
- Field: customer_status
- Operator: Equals
- Value: expiring
- Click Add Another Condition
- Field: customer_value
- Operator: Greater than
- Value: 100

Why this condition?

Only expiring subscriptions
Only if they've spent at least $100
Don't bother free/trial users with renewal emails

Column 6: email_winback (Send to Churned High-Value)

Type: Send Email Node

How to set it up:

Add Send Email column
Configure winback email with special offer
Run Configuration:
- Run Mode: Once
- Dependencies: customer_status, customer_value
Add Conditions:
- Field: customer_status
- Operator: Equals
- Value: churned
- Click Add Another Condition
- Field: customer_value
- Operator: Greater than
- Value: 5000

Why this condition?

Only churned customers
Only high-value (> $5,000 lifetime spend)
Worth the effort to win back

Column 7: email_basic (Send to Active Customers)

Type: Send Email Node

How to set it up:

Add Send Email column
Configure basic newsletter template
Run Configuration:
- Run Mode: Once
- Dependencies: customer_status, customer_value
Add Conditions:
- Field: customer_status
- Operator: Equals
- Value: active
- Click Add Another Condition
- Field: customer_value
- Operator: Less than
- Value: 1000

Why this condition?

Active customers only
Low-value (< $1,000) get basic newsletter
High-value customers get personal rep (not automated email)

Visual Flow

Status-Based Routing Example

Different actions triggered based on customer status - each column has its own condition:

🎯

Customer Row

Status determines path

👋 Status: new

Column:

Send Welcome Email

Condition:

status == "new" && email_valid == true

What it does:

Welcome new customers with onboarding email

Email Subject:

"Welcome to Acme! Let's get started"

Runs when: When customer status is "new" and email is valid

⏰ Status: expiring

Column:

Send Renewal Email

Condition:

status == "expiring" && days_until_expiry <= 30

What it does:

Remind customers to renew their subscription

Email Subject:

"Your subscription expires in 30 days"

Runs when: When subscription is expiring within 30 days

💔 Status: churned

Column:

Send Win-Back Email

Condition:

status == "churned" && lifetime_value > 5000

What it does:

Win back high-value churned customers

Email Subject:

"We miss you! Special offer inside"

Runs when: When customer churned with lifetime value > $5,000

📋 Example Scenarios:

Scenario 1

New customer joins

Status = "new" → Welcome Email column runs → Other columns skip

Scenario 2

Subscription expiring soon

Status = "expiring" → Renewal Email column runs → Other columns skip

Scenario 3

High-value customer churns

Status = "churned" + LTV > $5k → Win-Back Email column runs → Other columns skip

✨

Right Message, Right Customer, Right Time

Each customer gets exactly the email they need based on their status - no manual sorting required!

Key benefit: Right message to right customer, automatically

⚠️ Test Before Going Live

Before activating these email columns on all rows:

Create a test row with each status
Check that only the correct email column executes
Verify others show "Skipped (Condition failed)"
Review email content before sending to real customers

Example 3: Data Quality Gates

Business Goal: Prevent bad data from flowing downstream and breaking integrations

The Challenge

Third-party data sources are unreliable
Bad data causes CRM sync failures
Manual cleanup is time-consuming
Need automated quality control

The Solution: Validation Gates with Conditional Processing

Build a taible that validates data and only syncs clean records.

Taible Structure:

Columns:
1. raw_data (Webhook trigger)
2. data_validation (Calculated - Custom validation)
3. enrichment (Calculated - Condition: only if valid)
4. crm_sync (Calculated - Condition: only if enriched)
5. needs_review (Calculated - Condition: only if invalid)
6. reviewed_manually (Manual - Human reviews invalid data)

Column 1: raw_data (Webhook Trigger)

Set up a webhook trigger that creates new rows when data arrives.

How to set up:

Go to Triggers tab
Click + Add Trigger
Select Webhook
Copy the webhook URL
Configure your data source to send to this URL

Column 2: data_validation (Quality Check)

Type: Custom Code Node

What it does: Checks all required fields and data formats

How to set it up:

Add Custom Code column
Run Configuration:
- Run Mode: Once
- Dependencies: raw_data
- No condition (always validate)

Validation Code:

javascript

const errors = [];

// Check required fields
if (!raw_data.email || !raw_data.email.includes('@')) {
  errors.push('Invalid or missing email');
}

if (!raw_data.first_name || raw_data.first_name.length < 2) {
  errors.push('Invalid or missing first name');
}

if (!raw_data.company) {
  errors.push('Missing company name');
}

// Check phone format (if provided)
if (raw_data.phone && !/^[+]?[0-9\s\-()]+$/.test(raw_data.phone)) {
  errors.push('Invalid phone format');
}

// Return validation result
return {
  is_valid: errors.length === 0,
  errors: errors,
  validated_at: new Date()
};

Column 3: enrichment (Only Enrich Valid Data)

Type: Clearbit or Similar

How to set it up:

Add enrichment column
Run Configuration:
- Run Mode: Once
- Dependencies: data_validation
Add Condition (the quality gate):
- Field: data_validation → is_valid
- Operator: Equals
- Value: true

Why this condition?

Don't waste API calls on invalid data
Enrichment would fail anyway
Save costs and time

Column 4: crm_sync (Only Sync Clean Data)

Type: Salesforce/HubSpot Create/Update

How to set it up:

Add CRM integration column
Run Configuration:
- Run Mode: Once
- Dependencies: enrichment, data_validation
Add Conditions (double protection):
- Field: enrichment
- Operator: Is not empty
- Click Add Another Condition
- Field: data_validation → is_valid
- Operator: Equals
- Value: true

Why this condition?

Only sync if data passed validation
Only sync if enrichment succeeded
Double protection against bad data reaching your CRM

Data Quality Gate Workflow

Raw Data

From webhook or import

Data Validation

Checks email, name, company, phone format

70% Pass30% Fail

Valid Path

Invalid Path

Enrichment

Condition: is_valid = true

✓ Executes

CRM Sync

Condition: is_valid = true AND enrichment exists

✓ Clean data synced

✓ Success

Data in production

Enrichment

Condition: is_valid = true

✗ Skipped

CRM Sync

Condition: is_valid = true

✗ Skipped

⚠ Needs Review

Human review queue

Bad data never reaches your CRM

Invalid records are caught early and routed to human review

Column 5: needs_review (Flag Invalid Data)

Type: Transform Data Node

What it does: Creates a flag for human review

🔄 Opposite Condition Pattern

This column uses the **OPPOSITE** condition from column 4. This creates two processing paths:

Valid data → Automated sync
Invalid data → Human review queue

This pattern is very powerful for routing data based on quality checks.

How to set it up:

Add Transform Data column
Run Configuration:
- Run Mode: Once
- Dependencies: data_validation
Add Condition (opposite of column 4):
- Field: data_validation → is_valid
- Operator: Equals
- Value: false

Output the errors:

javascript

return "Review needed: " + data_validation.errors.join(", ");

Column 6: reviewed_manually (Manual)

Type: Manual Checkbox Column

Purpose: Human marks as reviewed after fixing issues

How to use it:

Filter taible to show rows where needs_review is not empty
Review the data errors
Fix issues directly in the row
Check the reviewed_manually checkbox
(Optional) Add a re-validation column that runs after manual review

Visual Flow

raw_data
    ↓
data_validation
    ↓
    ├─ Valid    → enrichment → crm_sync (automated)
    └─ Invalid  → needs_review → reviewed_manually (human)

Key benefit: Bad data never reaches production systems

Example 4: Time-Based Follow-Up Sequence

Business Goal: Automated follow-up emails at specific intervals after initial contact

The Challenge

Need to follow up with leads at 3 days, 7 days, 14 days
Don't want to spam leads who already responded
Must track engagement at each stage

The Solution: Time and Status-Based Conditions

Build a taible that automatically follows up at the right times.

Taible Structure:

Columns:
1. lead_email (Manual)
2. initial_email_sent (Manual Boolean - marked when first email sent)
3. days_since_initial (Calculated - Daily update)
4. has_responded (Calculated - Check for replies)
5. followup_day_3 (Calculated - Condition: 3 days + no response)
6. followup_day_7 (Calculated - Condition: 7 days + no response)
7. followup_day_14 (Calculated - Condition: 14 days + no response)
8. mark_as_cold (Calculated - Condition: 30 days + no response)

Column 1-2: Manual Input

Create two manual columns:

lead_email (Manual Text)
initial_email_sent (Manual Checkbox) - Check this after sending first email

Column 3: days_since_initial (Calculate Days)

Type: Custom Code Node

What it does: Calculates how many days since initial contact

How to set it up:

Add Custom Code column
Run Configuration:
- Run Mode: Always (recalculate daily)
- Dependencies: initial_email_sent
Add Condition:
- Field: initial_email_sent
- Operator: Equals
- Value: true

Day Calculation Code:

javascript

const today = new Date();
const sentDate = new Date(initial_email_sent_date); // Adjust field name
const daysDiff = Math.floor((today - sentDate) / (1000 * 60 * 60 * 24));
return daysDiff;

Column 4: has_responded (Check Email Replies)

Type: Custom Code or IMAP Check

What it does: Checks if the lead replied to any emails

Configuration:

Run Mode: Always (check daily)
Dependencies: lead_email
Condition: initial_email_sent equals true

This column should integrate with your email system to detect replies.

Column 5: followup_day_3 (First Follow-Up)

Type: Send Email Node

How to set it up:

Add Send Email column
Configure first follow-up email template
Run Configuration:
- Run Mode: Once
- Dependencies: days_since_initial, has_responded
Add Conditions (both must be true):
- Field: days_since_initial
- Operator: Equals
- Value: 3
- Click Add Another Condition
- Field: has_responded
- Operator: Equals
- Value: false

Why this condition?

Exactly 3 days (not 2, not 4)
Only if lead hasn't responded
Prevents duplicate sends

Column 6: followup_day_7 (Second Follow-Up)

Type: Send Email Node

How to set it up:

Add Send Email column
Configure second follow-up (different message)
Run Configuration:
- Run Mode: Once
- Dependencies: days_since_initial, has_responded
Add Conditions:
- Field: days_since_initial
- Operator: Equals
- Value: 7
- Click Add Another Condition
- Field: has_responded
- Operator: Equals
- Value: false

Why this condition?

Week has passed
Still no response
Different, more direct message

Column 7: followup_day_14 (Third Follow-Up)

Type: Send Email Node

How to set it up:

Add Send Email column
Configure final follow-up (breakup email)
Run Configuration:
- Run Mode: Once
- Dependencies: days_since_initial, has_responded
Add Conditions:
- Field: days_since_initial
- Operator: Equals
- Value: 14
- Click Add Another Condition
- Field: has_responded
- Operator: Equals
- Value: false

Why this condition?

Two weeks of silence
Last attempt before going cold
More direct "should I close your file?" message

Column 8: mark_as_cold (Give Up)

Type: Transform Data Node

How to set it up:

Add Transform Data column
Run Configuration:
- Run Mode: Once
- Dependencies: days_since_initial, has_responded
Add Conditions:
- Field: days_since_initial
- Operator: Greater than or equal
- Value: 30
- Click Add Another Condition
- Field: has_responded
- Operator: Equals
- Value: false
Mark Status:
javascript
```
return "cold";
```

Timeline Visualization

Automated Follow-Up Timeline

Day 0

Initial Email Sent

Manual: You send the first outreach email

Manual action

Day 3

First Follow-Up

Condition: days_since_initial = 3 AND has_responded = false

Automated

✓ Sends if no response

Day 7

Second Follow-Up

Condition: days_since_initial = 7 AND has_responded = false

Automated

✓ Sends if still no response

Day 14

Final Follow-Up

Condition: days_since_initial = 14 AND has_responded = false

Automated

✓ "Should I close your file?"

Day 30

Mark as Cold

Condition: days_since_initial ≥ 30 AND has_responded = false

Automated

✓ Lead marked inactive

Response Received?

All future follow-ups automatically skip!

Key benefit: Automated persistence without being annoying

✅ Response Stops Everything

The magic of this workflow: As soon as `has_responded` becomes `true`, ALL future follow-ups are automatically skipped because their conditions fail. You never spam someone who replied!

Troubleshooting Real-World Conditions

Issue 1: Condition Working on Some Rows, Not Others

Scenario: Your condition works for some rows but skips others unexpectedly.

How to diagnose:

Click a cell that executed (shows data, not "Skipped")
Look at the data - note the values
Click a cell that was skipped (shows "Skipped (Condition failed)")
Look at the data - what's different?

Inspecting Skipped Cells

Cell that Executed:

premium_enrichmentCompleted

{company_name: "Acme Corp", ...}

Data used:

company_size: 250

lead_score: 85

Click to view details

Cell that Skipped:

premium_enrichment

Skipped (Condition failed)

No data

Data used:

company_size: null

lead_score: null

Click to see why it skipped

The Problem: Missing Data

The condition checks if company_size > 100, but company_size is null. You can't compare null to a number, so the condition fails.

Solution:

Add a check for missing data first:

Add condition: company_size is not empty
Add condition: company_size greater than 100

Common problem: Missing data

Example:

Condition: company_size greater than 100
Some rows: company_size is null or empty
Result: Condition fails because you can't compare null to 100

Solution: Add a null check

Change condition to check if field is not empty first
Or use two conditions: company_size is not empty AND company_size greater than 100

Issue 2: All Cells Skipping (Nothing Executes)

Scenario: Added condition, now ALL cells show "Skipped", even ones that should execute.

How to diagnose:

Click any skipped cell
Look at the condition result in cell details
Check the actual values being compared

Common problem: Data type mismatch

Example:

Condition: lead_score greater than 50
Your lead_score column returns text: "75"
Result: Text "75" is not greater than number 50 (comparison fails)

Solution: Fix the data type

Click the gear icon on lead_score column
Check the column configuration
Ensure the output is set to Number type, not Text
Save and recalculate

🔢 Numbers vs Text

When comparing numbers in conditions, make sure your columns are configured to return numbers, not text. Click the column gear icon → Check output type settings.

Issue 3: Condition Too Complex (Confusing Behavior)

Scenario: Complex condition with many parts, hard to understand which part is failing.

Bad approach: One massive condition

email is valid AND company_size > 50 OR priority is "high"
AND source is "referral" AND industry is "Technology"

Better approach: Break into multiple columns

How to simplify:

Create helper columns for complex checks
- Column: is_qualified (Custom Code that returns true/false)
- Code handles all the complex logic
- Returns simple true or false
Use simple conditions
- Column: premium_enrichment
- Condition: is_qualified equals true

Benefits:

Easier to test each part
Easier to debug when something fails
Easier to see which check failed
Can reuse qualification logic

Issue 4: Cost Not Decreasing as Expected

Scenario: Added conditions to save money, but costs are still high.

How to diagnose:

Column Execution Statistics

Before: Condition Too Lenient

Premium Enrichment

Calculated Column

Completed:8,500

Skipped:1,500

Skip Rate:15%

Monthly Cost:$42,500

⚠️ Too many executions!

Current Condition:

lead_score > 30

Problem: Threshold too low, too many leads qualify

After: Condition Optimized

Premium Enrichment

Calculated Column

Completed:2,000

Skipped:8,000

Skip Rate:80%

Monthly Cost:$10,000

✓ Optimized spending!

Updated Condition:

lead_score > 70

✓ Threshold increased, only high-quality leads enriched

Monthly Savings

$32,500

76% cost reduction by adjusting condition threshold

Check the column header - it shows execution statistics
Look at the numbers:
- How many cells executed?
- How many were skipped?
Calculate skip rate: Skipped ÷ Total

Example Problem:

Expected: 70% skip rate (7,000 skipped, 3,000 executed)
Actual: 15% skip rate (1,500 skipped, 8,500 executed)
Result: Spending 85% of budget instead of 30%

Solution: Make condition more strict

Current threshold: lead_score greater than 30 (too lenient)
New threshold: lead_score greater than 70 (more selective)
Result: More cells skipped, less money spent

Monitor the change:

Update the condition
Wait a day or two
Check column header statistics again
Adjust threshold up or down based on results

Issue 5: Getting "Skipped (Dependencies not present)" Instead

Scenario: Added a condition but cells show "Skipped (Dependencies not present)" instead of running or being skipped by condition.

What this means: The columns your condition depends on haven't executed yet.

How to diagnose:

Open the column configuration (gear icon)
Go to Run Configuration tab
Check Dependencies section - which columns are listed?
Look at those dependency columns - do they have data?
Check if dependency columns have their own conditions that might have failed

Dependencies Not Present vs Condition Failed

Understanding the difference between two types of skipped cells

Column: lead_score

Skipped (Condition failed)

Condition: basic_info is not empty

❌ basic_info is null

→

Column: premium_enrichment

Skipped (Dependencies not present)

Dependencies: lead_score

Condition: lead_score > 70

⚠️ Can't check condition - lead_score didn't run!

What Happened?

lead_score has a condition that failed (basic_info is empty)
Because lead_score didn't execute, it has no data
premium_enrichment depends on lead_score
Since lead_score never ran, premium_enrichment can't run either
Result: premium_enrichment shows "Skipped (Dependencies not present)"

How to Fix This:

Option 1: Fix the upstream condition

Make sure lead_score has the right conditions so it executes when it should

Option 2: Check run mode

Ensure lead_score run mode is set to "Once" or "Always", not "Manual"

Option 3: Remove unnecessary dependency

If premium_enrichment doesn't actually need lead_score data, remove it from dependencies

Quick Reference:

Skipped (Condition failed)

Column's own condition returned false

Skipped (Dependencies not present)

Required dependency columns didn't execute

Example Problem:

Column: premium_enrichment
Dependencies: lead_score
Condition: lead_score > 70

Problem: lead_score column itself has a condition that failed,
so lead_score shows "Skipped (Condition failed)"

Result: premium_enrichment shows "Skipped (Dependencies not present)"
because lead_score never ran

Solutions:

Check Run Mode: Ensure dependency columns are set to run automatically (not Manual)
Check dependency conditions: Make sure upstream columns don't have failing conditions
Remove unnecessary dependencies:
- Click gear icon → Run Configuration
- Review dependencies list
- Remove dependencies that aren't actually needed
- Save
Fix upstream conditions: If a dependency column has a condition that's failing, fix that condition first

Best Practices from Real Implementations

Practice 1: Start Conservative, Loosen Later

Don't do this:

First attempt: lead_score > 20  (too permissive)
Result: 90% of leads qualify, no cost savings

Do this instead:

Week 1: lead_score > 80  (very strict)
Monitor: Check results, conversion rates
Week 2: lead_score > 75  (slightly looser)
Week 3: lead_score > 70  (found the sweet spot)

Why: Easier to loosen restrictions than explain why you overspent

Practice 2: Layer Conditions (Multiple Gates)

Don't do this:

One column with massive condition checking everything

Do this instead:

Column 1: Check email is valid
Column 2: Check company size > 50
Column 3: Check lead_score > 70
Column 4: Do expensive enrichment

Benefits:

Can see exactly which gate failed
Each gate has clear purpose
Easier to adjust individual thresholds
Better cost tracking per stage

Layered Quality Gates

10,000 Leads

Raw input data

Gate 1: Email Validation

8,000

Valid emails

2,000

Invalid • Stopped here

Condition: email is not empty

Gate 2: Company Size Check

7,000

Size > 50

1,000

Too small • Stopped

Condition: basic_info.company_size > 50

Gate 3: Lead Quality Score

2,000

High quality (score > 70)

5,000

Low score • Stopped

Condition: lead_score > 70

💎 Premium Enrichment

2,000

Only high-quality leads enriched

Cost per lead

Total cost

$10,000

Gate 1

20%

Filtered out

Gate 2

12.5%

Additional filtered

Gate 3

62.5%

Additional filtered

Benefits of Layered Gates

✓ Easy to Debug

See which gate failed

✓ Adjustable

Tweak each threshold independently

✓ Cost Tracking

Know where savings come from

Practice 3: Document Cost Thresholds

Add to column description:

Premium Enrichment ($5/call)

Condition: lead_score > 70

Expected execution rate: 20-25% of rows
Monthly cost projection: $10,000 (2,000 calls)

⚠️ Alert: If execution rate > 30%, review threshold

Why: Future you (or your teammate) will thank you

How to add:

Click column gear icon
Find "Description" field
Add notes about costs and expected rates
Save

Practice 4: Monitor and Adjust Weekly

Weekly checklist:

☐ Check skip rates for expensive columns
☐ Review total costs vs. projections
☐ Look at sample of skipped rows - were they correctly skipped?
☐ Look at sample of executed rows - were they worth the cost?
☐ Adjust conditions if needed
☐ Document any changes

How to check:

Look at column header statistics (execution counts)
Click some "Skipped" cells - review why they were skipped
Click some executed cells - review the data quality
Adjust thresholds based on your findings

Practice 5: Use Conditions for Progressive Enhancement

Pattern: Basic → Good → Better → Best

Implementation:

Column: basic_info (Free API)
Condition: email is not empty

Column: standard_info ($1/call)
Condition: lead_score > 50

Column: premium_info ($5/call)
Condition: lead_score > 80

Result: Appropriate investment per lead quality

Visual representation:

Progressive Enhancement: Basic → Good → Better → Best

Basic Info

Free API

FREE

Condition:

email is not empty

Provides:

Company name
Basic size
Industry

Coverage:

100%

All valid emails

Standard Info

Paid API - Tier 1

$1/call

Condition:

lead_score > 50

Adds:

Detailed financials
Contact info
Tech stack

Coverage:

50%

Medium+ quality

Premium Info

Paid API - Tier 2

$5/call

Condition:

lead_score > 80

Adds:

Decision makers
Intent signals
Org charts

Coverage:

20%

High quality only

Tier 1: Basic

10,000 calls

Tier 2: Standard

5,000 calls

$5,000

Tier 3: Premium

2,000 calls

$10,000

Total Monthly Cost

$15,000

vs $50,000 if all leads got premium enrichment

70% Savings

💡 The Power of Progressive Enhancement

Every lead gets some enrichment • High-quality leads get premium data • Investment scales with opportunity

Cost Savings: Real Numbers

Case Study 1: B2B Lead Enrichment

Before conditions:

10,000 leads/month
All enriched with premium API
Cost: $50,000/month

After implementing tiered conditions:

Email validation condition: 2,000 invalid → Save $10,000
Basic info failed condition: 1,000 no data → Save $5,000
Lead score condition: 5,000 low quality → Save $25,000
2,000 high-quality leads enriched → Cost $10,000

Savings: $40,000/month (80% reduction) Annual savings: $480,000

Case Study 2: Customer Communication

Before conditions:

50,000 customers
Weekly email to all
Low engagement (2% open rate)
High unsubscribe rate

After implementing status-based conditions:

Only email relevant segments
5,000 new customers → Welcome sequence
3,000 expiring → Renewal campaign
2,000 churned high-value → Win-back
40,000 others → Skip (no irrelevant emails)

Results:

80% fewer emails sent
15% open rate (up from 2%)
50% lower unsubscribe rate
Better customer satisfaction

Case Study 3: Data Quality

Before conditions:

All webhook data synced to CRM
30% sync failures (bad data)
Manual cleanup: 10 hours/week
Support tickets from bad data

After implementing validation gates:

Validation gate catches bad data
Only 95%+ valid data synced
2% sync failures (down from 30%)
Manual cleanup: 1 hour/week
Near-zero support tickets

Time savings: 9 hours/week (468 hours/year)

Quick Reference: Common Condition Patterns

Pattern 1: Only Process Valid Data

Field: email_valid
Operator: Equals
Value: true

Pattern 2: Tiered by Score

Basic tier:  (no condition - always run)
Premium tier: lead_score > 50
Enterprise tier: lead_score > 80

Pattern 3: Status-Based Routing

Welcome:  status equals "new"
Renewal:  status equals "expiring"
Winback:  status equals "churned" AND lifetime_value > 5000

Pattern 4: Data Quality Gate

email is not empty
AND first_name is not empty
AND company is not empty

Pattern 5: Time-Based

days_since_contact equals 3
AND has_responded equals false

Pattern 6: Range Check

order_total >= 100
AND order_total <= 1000

Pattern 7: Exclude Test Data

is_test equals false
AND is_spam equals false

Summary: Practical Conditional Execution

You now have real-world examples of:

✅ Smart Lead Enrichment

Tiered processing with multiple quality gates
80% cost reduction example
Quality-based gating

✅ Customer Segmentation

Status-based email routing
Different messages for different tiers
Automated personalization

✅ Data Quality Gates

Validation before processing
Human review queue for invalid data
Protect downstream systems

✅ Time-Based Follow-Ups

Automated sequences
Response detection
No spam guarantee

✅ Troubleshooting

Common real-world issues
How to diagnose problems
Practical solutions

✅ Best Practices

Start conservative
Layer conditions
Document thresholds
Monitor and adjust

✅ Cost Savings

Real case study numbers
80%+ cost reductions
Time savings examples

The Power of Conditions in Production

Conditions transform workflows from "process everything the same way" to intelligent, cost-effective, adaptive systems.

Before conditions:

Process everything
High costs
Low efficiency
No flexibility

After conditions:

Process smartly
Optimized costs
High efficiency
Flexible routing

The difference: Thousands of dollars per month, better data quality, and happier customers.

Next Steps

You've completed Section 5: Conditional Execution and Logic!

Continue Learning:

Section 6: Triggers - Automatically create rows based on events
Section 7: Sub-Taibles - Handle complex one-to-many relationships
Section 9: Custom Code - Write complex logic for unique requirements

Practice Challenges:

Build a lead enrichment pipeline with cost-saving conditions
Create a customer segmentation workflow with status-based routing
Implement a validation gate that catches bad data
Set up a time-based follow-up sequence

🎉 Congratulations! You've mastered conditional execution—one of the most powerful optimization techniques in Taibles. You can now build intelligent workflows that:

Save significant costs by skipping unnecessary operations
Route data down different paths based on business logic
Implement quality gates without complex coding
Create sophisticated automations that adapt to your data

You're ready for production-grade automation! 🚀

5.3 Practical Condition Examples ​

Understanding Cell States ​

Example 1: Smart Lead Enrichment ​

The Challenge ​

The Solution: Tiered Conditional Processing ​

Column 1: email (Manual) ​

Column 2: email_validation (Calculated) ​

Run Configuration

Column 3: basic_info (Calculated) ​

Column 4: lead_score (Calculated) ​

Column 5: premium_enrichment (Calculated) ​

✨ This is Where the Magic Happens

Lead Enrichment Pipeline Flow

Column 6: company_name (Calculated) ​

The Cost Savings ​

📊 Monitor Your Skip Rates

Example 2: Customer Segmentation with Different Actions ​

The Challenge ​

The Solution: Status-Based Conditional Routing ​

Column 1-2: Manual Input Columns ​

Column 3: customer_value (Calculated) ​

Column 4: email_welcome (Send to New Customers) ​

Column 5: email_renewal (Send to Expiring Customers) ​

Column 6: email_winback (Send to Churned High-Value) ​

Column 7: email_basic (Send to Active Customers) ​

Visual Flow ​

Status-Based Routing Example

⚠️ Test Before Going Live

Example 3: Data Quality Gates ​

The Challenge ​

The Solution: Validation Gates with Conditional Processing ​

Column 1: raw_data (Webhook Trigger) ​

Column 2: data_validation (Quality Check) ​

Column 3: enrichment (Only Enrich Valid Data) ​

Column 4: crm_sync (Only Sync Clean Data) ​

Data Quality Gate Workflow

Column 5: needs_review (Flag Invalid Data) ​

🔄 Opposite Condition Pattern

Column 6: reviewed_manually (Manual) ​

Visual Flow ​

Example 4: Time-Based Follow-Up Sequence ​

The Challenge ​

The Solution: Time and Status-Based Conditions ​

Column 1-2: Manual Input ​

Column 3: days_since_initial (Calculate Days) ​

Column 4: has_responded (Check Email Replies) ​

Column 5: followup_day_3 (First Follow-Up) ​

Column 6: followup_day_7 (Second Follow-Up) ​

Column 7: followup_day_14 (Third Follow-Up) ​

Column 8: mark_as_cold (Give Up) ​

Timeline Visualization ​

Automated Follow-Up Timeline

✅ Response Stops Everything

Troubleshooting Real-World Conditions ​

Issue 1: Condition Working on Some Rows, Not Others ​

Inspecting Skipped Cells

Issue 2: All Cells Skipping (Nothing Executes) ​

🔢 Numbers vs Text

Issue 3: Condition Too Complex (Confusing Behavior) ​

Issue 4: Cost Not Decreasing as Expected ​

Column Execution Statistics

Issue 5: Getting "Skipped (Dependencies not present)" Instead ​

Dependencies Not Present vs Condition Failed

Best Practices from Real Implementations ​

Practice 1: Start Conservative, Loosen Later ​

Practice 2: Layer Conditions (Multiple Gates) ​

Layered Quality Gates

Practice 3: Document Cost Thresholds ​

Practice 4: Monitor and Adjust Weekly ​

Practice 5: Use Conditions for Progressive Enhancement ​

Progressive Enhancement: Basic → Good → Better → Best

Cost Savings: Real Numbers ​

Case Study 1: B2B Lead Enrichment ​

Case Study 2: Customer Communication ​

Case Study 3: Data Quality ​

Quick Reference: Common Condition Patterns ​

Pattern 1: Only Process Valid Data ​

Pattern 2: Tiered by Score ​

Pattern 3: Status-Based Routing ​

Pattern 4: Data Quality Gate ​

5.3 Practical Condition Examples

Understanding Cell States

Example 1: Smart Lead Enrichment

The Challenge

The Solution: Tiered Conditional Processing

Column 1: email (Manual)

Column 2: email_validation (Calculated)

Column 3: basic_info (Calculated)

Column 4: lead_score (Calculated)

Column 5: premium_enrichment (Calculated)

Column 6: company_name (Calculated)

The Cost Savings

Example 2: Customer Segmentation with Different Actions

The Challenge

The Solution: Status-Based Conditional Routing

Column 1-2: Manual Input Columns

Column 3: customer_value (Calculated)

Column 4: email_welcome (Send to New Customers)

Column 5: email_renewal (Send to Expiring Customers)

Column 6: email_winback (Send to Churned High-Value)

Column 7: email_basic (Send to Active Customers)

Visual Flow

Example 3: Data Quality Gates

The Challenge

The Solution: Validation Gates with Conditional Processing

Column 1: raw_data (Webhook Trigger)

Column 2: data_validation (Quality Check)

Column 3: enrichment (Only Enrich Valid Data)

Column 4: crm_sync (Only Sync Clean Data)

Column 5: needs_review (Flag Invalid Data)

Column 6: reviewed_manually (Manual)

Visual Flow

Example 4: Time-Based Follow-Up Sequence

The Challenge

The Solution: Time and Status-Based Conditions

Column 1-2: Manual Input

Column 3: days_since_initial (Calculate Days)

Column 4: has_responded (Check Email Replies)

Column 5: followup_day_3 (First Follow-Up)

Column 6: followup_day_7 (Second Follow-Up)

Column 7: followup_day_14 (Third Follow-Up)

Column 8: mark_as_cold (Give Up)

Timeline Visualization

Troubleshooting Real-World Conditions

Issue 1: Condition Working on Some Rows, Not Others

Issue 2: All Cells Skipping (Nothing Executes)

Issue 3: Condition Too Complex (Confusing Behavior)

Issue 4: Cost Not Decreasing as Expected

Issue 5: Getting "Skipped (Dependencies not present)" Instead

Best Practices from Real Implementations

Practice 1: Start Conservative, Loosen Later

Practice 2: Layer Conditions (Multiple Gates)

Practice 3: Document Cost Thresholds

Practice 4: Monitor and Adjust Weekly

Practice 5: Use Conditions for Progressive Enhancement

Cost Savings: Real Numbers

Case Study 1: B2B Lead Enrichment

Case Study 2: Customer Communication

Case Study 3: Data Quality

Quick Reference: Common Condition Patterns

Pattern 1: Only Process Valid Data

Pattern 2: Tiered by Score

Pattern 3: Status-Based Routing

Pattern 4: Data Quality Gate

Pattern 5: Time-Based

Pattern 6: Range Check

Pattern 7: Exclude Test Data

Summary: Practical Conditional Execution

The Power of Conditions in Production

Next Steps