4.3 Templates & Data Flow

You've learned about dependencies and how to configure them. Now let's master how columns access data from each other and explore common data flow patterns for building reliable automations.

How Columns Access Data

When you configure a column, you often need to use data from other columns in the same row. The system provides an intuitive way to do this.

The Basic Concept

Think of it like filling in a form where you can reference answers from previous questions. When configuring a column, you can insert data from other columns by typing the column name.

How it works:

Press CTRL + SPACE or start typing a column name
A dropdown appears showing available columns
Select the column you want to use
The system displays it as a green badge

Example: Accessing Column Data

Try typing a column name or press CTRL + SPACE to see available columns

💡 Selected columns appear as green badges. Click a column from the dropdown to add it.

What you see:

As you type, matching columns appear in a dropdown
Selected columns show as green badges with the column label
Nested data (like company information) shows as arrows: Company → Name

Accessing Data Step by Step

Step 1: Basic Column Access

The simplest case: use data from a single column.

Example: Email Column

When you need to use an email address in another column:

Click in the input field
Press CTRL + SPACE
Type "email" or scroll to find it
Click to select
You see a green badge: Email

The system automatically inserts the email value when the column runs.

How to Access a Column

Click in the input field👆

Press CTRL + SPACE⌨️

Type "email" or scroll to find it🔍

Click to select✅

What you see:

Selected: Email

💡 Tip: The system automatically inserts the actual email value when the column runs for each row.

Step 2: Accessing Nested Properties

Some columns contain complex data with multiple pieces of information. You can access specific parts.

Example: Company Enrichment Data

If a column called "Company Data" contains:

Company name
Location (city, state)
Employee count
Revenue

You can access specific pieces:

To get the company name:

Type "Company Data"
Select it
Type a period (.)
Dropdown shows: Name, Location, Employees, Revenue
Select "Name"
Badge shows: Company Data → Name

Accessing Nested Properties

Example: Company Data Column Contains:

Company Name: Acme Corp
Location:
  - City: Seattle
  - State: WA
Employees: 2500
Revenue: $500M

How to access specific parts:

Company Data → Name

→

"Acme Corp"

Company Data → Location → City

→

"Seattle"

Company Data → Employees

→

"2500"

💡 Autocomplete Helps You

1. Type "Company Data."

2. Dropdown shows: Name, Location, Employees, Revenue

3. Select "Location"

4. Type another period "."

5. Dropdown shows: City, State

6. Select what you need

Common patterns:

Company Data → Name - Get company name
Company Data → Location → City - Get city from nested location
Company Data → Employees - Get employee count

Step 3: Using Multiple Columns

You can combine data from multiple columns in a single field.

Example: Personalized Email

Create a message using first name, company name, and job title:

Hi [First Name],

I see you're the [Job Title] at [Company Name].
I'd love to schedule a quick call to discuss...

How to build this:

Type "Hi "
Press CTRL + SPACE, select First Name
Type ", I see you're the "
Select Job Title
Type " at "
Select Company Name
Continue with your message

Combining Multiple Columns

Building your message:

Hi First Name ,

I see you're the Job Title at Company Name .

I'd love to schedule a quick call to discuss...

For this row:

First Name:John

Job Title:VP of Sales

Company Name:Acme Corp

The result will be:

Hi John,

I see you're the VP of Sales at Acme Corp.
I'd love to schedule a quick call to discuss...

✨ Magic: The system automatically fills in the actual values for each row!

The result automatically fills in the actual values for each row.

Understanding Data Flow Patterns

Now that you know how to access data, let's explore common patterns for organizing your automations.

Pattern 1: Linear Pipeline

What it is: Columns execute one after another in a chain.

Visual representation:

Linear Pipeline Pattern

Columns execute one after another in a chain

Validate

Find Company

Extract Name

Update CRM

✅ Advantages

• Simple to understand
• Easy to debug
• Clear cause-and-effect

⚠️ Considerations

• Slower (runs sequentially)
• One failure stops the chain
• No parallel processing

When to use:

Each step needs the result from the previous step
Simple, sequential operations
Easy to understand and debug

Example: Lead Enrichment

Email → Validate Email → Find Company → Extract Company Name → Update CRM

Characteristics:

✅ Simple and clear
✅ Easy to follow and debug
⚠️ Slower (runs one at a time)
⚠️ If one step fails, chain stops

Pattern 2: Parallel Enrichment

What it is: Multiple columns run at the same time, then results combine.

Visual representation:

email_valid completes

Done

↙↘

basic_info starts

Processing

Uses email

company_details starts

Processing

Uses company_name

↓

Both complete independently

⚡ Faster! Parallel processing saves time

When to use:

Gathering data from multiple sources
Maximize speed
Want backup data sources

Example: Multi-Source Company Research

               ┌→ Clearbit API ─┐
Email Address ─┼→ Apollo API ───┼→ Combined Results
               └→ Hunter API ───┘
   (all run simultaneously)

Characteristics:

✅ Fast (runs in parallel)
✅ If one source fails, others still work
✅ More complete data
⚠️ More API calls = higher costs

Pattern 3: Branching Logic

What it is: Different paths based on conditions.

Visual representation:

Branching Logic Pattern

Different paths based on conditions

Basic Research

Lead Score

Score > 80

Premium Research

$5/call

Score 50-80

Standard Research

$1/call

Score < 50

Skip (save money)

💰 Save money by only running expensive operations on high-value leads

✅ Advantages

• Cost-effective
• Flexible paths
• Optimized processing

⚠️ Considerations

• More complex logic
• Need to define conditions
• Testing multiple paths

When to use:

Different actions for different data
Save costs by skipping unnecessary operations
Tiered processing (basic vs. premium)

Example: Lead Qualification

Email → Basic Research → Lead Score
                            ↓
                    ┌───────┴────────┐
              Score > 80        Score 50-80        Score < 50
                    ↓               ↓                  ↓
           Premium Research   Standard Research    Skip (save money)

Characteristics:

✅ Cost-effective (skip what's not needed)
✅ Flexible paths
✅ Optimized processing
⚠️ More complex setup

Pattern 4: Human-in-the-Loop

What it is: Automation stops for human review before continuing.

Visual representation:

Human-in-the-Loop Pattern

Automation stops for human review before continuing

Research

Auto

Automatic

→

Draft Email

Auto

Automatic

→

Human Review

Manual

→

Send Email

Manual

How it works:

1. System automatically generates email draft
2. You review the draft and make any edits
3. You check an "Approved" checkbox when ready
4. Send Email column only runs if approved
5. You manually click "Send" button for final safety

✅ Advantages

• Safe (human oversight)
• Can edit before sending
• Accountability tracked
• Prevents mistakes

⚠️ Considerations

• Slower (waits for human)
• Requires attention
• Need review process
• Not fully automated

🛡️ Best for: Sending emails, making purchases, or any action that can't be undone

When to use:

Sending emails or messages
Making purchases or commitments
AI-generated content that needs review
Actions that can't be undone

Example: AI Email Campaign

Research → Draft Email → [HUMAN REVIEWS] → Send Email
         (automatic)    (automatic)  (manual check)  (manual trigger)

How it works:

System automatically generates email draft
You review the draft and make edits
You check an "Approved" checkbox
Final column only runs if approved
You manually click "Send" button

Characteristics:

✅ Safe (human oversight)
✅ Can edit before sending
✅ Accountability
⚠️ Slower (waits for human)
⚠️ Requires attention and process

Understanding Cell States

As your automation runs, cells change states to show progress. Here's what you actually see:

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

State Meanings

Ready (gray)

Column hasn't run yet
Waiting for dependencies

Queued (gray with clock icon, pulsing)

Column is in line to run
Will start soon

Running (gray with spinning gear)

Column is currently executing
Processing data

Rate Limited (yellow with pause icon)

Column is waiting due to rate limits
Protecting API from too many requests

Completed (green badge)

Column finished successfully
Data is available

Error (blue badge with lightning bolt)

Column failed
Click to see error details

Skipped (Condition failed) (gray with option icon)

Column didn't run because condition was false
Intentional skip

Skipped (Dependencies not present) (gray with slash icon)

Required dependency data is missing
Column can't run without it

Troubleshooting Guide

When things don't work as expected, here's how to diagnose and fix common issues.

Issue 1: "Column Never Executes"

Symptom: Cells stay gray (Ready), never change

Issue

Column Never Executes

Symptom:

Cells stay gray (Ready), never change state

Possible Causes & Fixes:

Dependencies Not Satisfied

•Click the gray cell

•Look at the detail panel on the right

•Check which dependencies are not complete

Fix: Wait for or fix the blocking dependencies

Condition Failed

•Cell shows "Skipped (Condition failed)"

•Review the condition logic

•Check if skip is intentional

Fix: Modify condition if needed, or accept the skip

Run Mode is Manual

•Open column configuration

•Check the "Run Mode" setting

•See if it's set to "Manual"

Fix: Change to "Once" or "Always", or click Run button

Diagnosis A: Dependencies Not Satisfied

Click the gray cell
Look at the detail panel on the right
Check which dependencies are not complete

Fix: Wait for or fix the blocking dependencies

Diagnosis B: Condition Failed

The column shows "Skipped (Condition failed)"

Fix:

Check if the skip is intentional
Review the condition to ensure it's correct
Modify the condition if needed

Diagnosis C: Run Mode is Manual

The column is set to only run when you click it.

Fix:

If it should run automatically: Change to "Once" or "Always"
If it should stay manual: Click the Run button

Issue 2: "Column Executes But Fails"

Symptom: Cell turns from gray to blue (Running) to blue (Error)

Issue

Column Executes But Fails

Symptom:

Cell changes from gray to Running, then shows Error badge (blue with lightning)

Common Causes & Fixes:

Column Name Typo

Error: Column "emaail" not found

Cause: Typo in column selection

Fix: Open column configuration, fix spelling, use CTRL + SPACE for autocomplete

Missing Data

Error: Cannot access property "name" on null

Cause: A previous column returned no data

Fix: Add condition to check data exists, or handle missing data in custom code

Authentication Failed

Error: 401 Unauthorized

Cause: API key expired or invalid

Fix: Go to Settings → Accounts, find integration, click Reconnect, re-authenticate

💡 Tip: Click the Error badge to see the full error message and details

Diagnosis A: Column Name Typo

Error says: "Column 'emaail' not found"

Fix:

Open column configuration
Find the typo (emaail → email)
Use CTRL + SPACE to select correctly
Save and re-run

Diagnosis B: Missing Data

Error says: "Cannot access property 'name' on null"

Cause: A previous column returned no data

Fix Option 1 - Add Condition: Only run this column if the data exists

Fix Option 2 - Use Custom Code: Handle missing data gracefully (covered in advanced sections)

Diagnosis C: Authentication Failed

Error says: "401 Unauthorized"

Fix:

Go to Settings → Accounts
Find the integration (e.g., "Clearbit")
Click "Reconnect"
Re-authenticate
Re-run failed cells

Issue 3: "Wrong Data in Cell"

Symptom: Cell shows "Completed" but data is incorrect

Diagnosis: Wrong Selection

Example problem:

Column should show: "John Smith"
Actually shows: "John"

Cause: Selected only First Name instead of both First Name and Last Name

Fix:

Open column configuration
Review what's selected
Correct the selection
Re-run the column

Issue 4: "Too Slow"

Symptom: Cells stay "Queued" for a long time

Issue

Too Slow / Long Wait Times

Symptom:

Cells stay "Queued" or "Running" for a long time

Possible Causes:

Rate Limiting Normal

Symptom: Cells show "Rate Limited" (yellow with pause icon)

This is usually intentional to protect external APIs and prevent hitting usage limits

Options:

• Wait (usually the right choice)
• Increase rate limit carefully if you know it's safe

Slow External Service

Symptom: Cells stay "Running" for minutes

External API is slow to respond or processing complex data

Options:

• Accept the wait time
• Use a faster API if available
• Contact API provider about performance

Too Many Dependencies

Symptom: Column depends on many other columns (e.g., 15+)

Must wait for all dependencies to complete first

Options:

• Only add dependencies you actually need
• Remove unnecessary dependencies
• Consider parallel processing

✅ Remember: Rate limiting is usually intentional and correct - it protects your API connections and prevents overages

Diagnosis A: Rate Limiting

Cells show "Rate Limited" (yellow)

This is usually intentional:

Protects external APIs
Prevents hitting usage limits
Follows service provider rules

Options:

Wait (usually the right choice)
Increase rate limit carefully (if you know it's safe)

Diagnosis B: Slow External Service

Cells stay "Running" for minutes

Cause: External API is slow to respond

Options:

Accept the wait time
Use a faster API if available
Contact API provider about performance

Diagnosis C: Too Many Dependencies

Column depends on 15 other columns

Problem: Must wait for all 15 to complete first

Fix: Only add dependencies you actually need

Debugging Checklist

When something doesn't work, follow these steps:

Debugging Checklist

When something doesn't work, follow these steps in order:

1. Check cell state: What does it show? Ready, Running, Error, Skipped?

2. Click the cell: View details in the right panel

3. Check dependencies: Are they all completed?

4. Check condition: Is it evaluated correctly?

5. Check selections: Any typos or wrong columns?

6. Check run mode: Is it set correctly?

7. Check column header: Do all cells in this column have the same issue?

8. Try manual re-run: Click Run button to test

9. Simplify: Remove complexity until it works

10. Check error details: Click error badge to see full message

Progress 0 / 10

💡 Tip: Click each item as you complete it. Most issues can be found by following this checklist!

Check cell state: What does it show? Ready, Running, Error, Skipped?
Click the cell: View details in the right panel
Check dependencies: Are they all completed?
Check condition: Is it evaluated correctly?
Check selections: Any typos or wrong columns?
Check run mode: Is it set correctly?
Check column header: Do all cells in this column have the same issue?
Try manual re-run: Click Run button to test
Simplify: Remove complexity until it works
Check error details: Click error badge to see full message

Best Practices

Design Principles

1. Only Depend on What You Use

✅ Good: Column depends only on "Company Data"

❌ Bad: Column depends on "Company Data", "Email", "Validation", "Social Profiles" but only uses Company Data

Why: Fewer dependencies = faster execution

2. Maximize Parallelism

✅ Good: Run independent operations at the same time

         ┌→ Clearbit ─┐
Email ──┼→ Apollo ────┼→ Merge
         └→ Hunter ───┘

❌ Bad: Run everything in sequence when it could be parallel

Email → Clearbit → Apollo → Hunter → Merge

Why: Parallel = faster

3. Handle Missing Data

Always consider what happens if data is missing.

Use conditions to skip when data is absent:

Add condition: "Only run if Company Data exists"

Or handle gracefully in custom code:

Provide default values
Show helpful messages

4. Use Appropriate Run Modes

Once: For expensive operations (API calls with costs)
Always: For calculations that should update
Manual: For actions requiring approval
Regularly: For scheduled checks

5. Add Conditions to Save Costs

Skip unnecessary operations:

Example: Only enrich high-value leads

Condition: "Lead Score > 50"
Saves money by skipping low-value leads

6. Rate Limit Wisely

Protect external APIs and control costs:

Follow API provider's rate limits
Start conservative, increase if needed
Monitor usage

Common Data Flow Structures

Most automations follow these proven patterns:

The Fundamental Pattern

Input → Process → Extract → Analyze → Act

Example: Lead Qualification

Email → Find Company → Extract Name → Calculate Score → Send to CRM
(input)    (process)      (extract)      (analyze)         (act)

Multi-Source Enrichment

         ┌→ Source 1 ─┐
Input ──┼→ Source 2 ──┼→ Combine → Process
         └→ Source 3 ─┘

Example: Comprehensive Research

         ┌→ LinkedIn ──┐
Email ──┼→ Twitter ────┼→ Profile → Analysis
         └→ GitHub ────┘

Conditional Processing

Input → Check → High: Premium Process
                 ↓
              Low: Basic Process

Example: Tiered Service

Customer → Check Plan → Pro: Full Analysis ($5)
                         ↓
                    Free: Basic Info ($0)

Testing Strategy

Test with One Row First

Add a single test row
Watch the entire pipeline execute
Verify each column produces correct data
Check that conditions work as expected

Check Edge Cases

Test unusual situations:

What if email is invalid?
What if company not found?
What if API returns no data?

Verify Conditions

Test both scenarios:

Rows that meet the condition (should run)
Rows that don't meet it (should skip)

Monitor Performance

Check how long each column takes
Identify slow columns
Optimize where needed

Review Costs

Track API call counts
Monitor rate limit usage
Optimize expensive operations

Summary: What You've Mastered

In this chapter, you've learned:

✅ Data Access: How columns reference each other

Using column names
Accessing nested properties
Combining multiple columns

✅ Data Flow Patterns: Five essential patterns

Linear pipeline (sequential)
Parallel enrichment (simultaneous)
Branching logic (conditional)
Aggregation (combining)
Human-in-the-loop (approval)

✅ Cell States: What each state means

Ready, Queued, Running, Rate Limited
Completed, Error
Skipped (condition failed or missing dependencies)

✅ Troubleshooting: How to diagnose and fix issues

Columns not executing
Execution failures
Wrong data
Performance issues

✅ Best Practices: Design principles for reliable automations

Minimize dependencies
Maximize parallelism
Handle missing data
Use appropriate run modes
Add conditions to save costs

Next Steps

You now have complete mastery of dependencies and data flow. Ready to level up?

Immediate Practice:

Review your previous automations - can you optimize them?
Try a parallel pattern - use multiple data sources
Add conditions - skip operations to save costs
Build a complete pipeline - use multiple patterns

Continue Learning:

Chapter 5: Advanced Execution Control - Rate limiting and scheduling
Chapter 6: Triggers - Automate row creation
Chapter 9: Custom Code - Handle complex scenarios

🎉 Congratulations! You now understand how data flows through your automations. With this knowledge, you can design sophisticated, reliable workflows that handle real business processes.

You're equipped to:

Design complex data flow patterns
Access data between columns intuitively
Troubleshoot any issue quickly
Optimize for performance and cost
Build production-ready automations

Happy building! 🚀

4.3 Templates & Data Flow ​

How Columns Access Data ​

The Basic Concept ​

Accessing Data Step by Step ​

Step 1: Basic Column Access ​

Step 2: Accessing Nested Properties ​

Step 3: Using Multiple Columns ​

Understanding Data Flow Patterns ​

Pattern 1: Linear Pipeline ​

Pattern 2: Parallel Enrichment ​

Pattern 3: Branching Logic ​

Pattern 4: Human-in-the-Loop ​

Understanding Cell States ​

State Meanings ​

Troubleshooting Guide ​

Issue 1: "Column Never Executes" ​

Issue 2: "Column Executes But Fails" ​

Issue 3: "Wrong Data in Cell" ​

Issue 4: "Too Slow" ​

Debugging Checklist ​

Best Practices ​

Design Principles ​

Common Data Flow Structures ​

The Fundamental Pattern ​

Multi-Source Enrichment ​

Conditional Processing ​

Testing Strategy ​

Test with One Row First ​

Check Edge Cases ​

Verify Conditions ​

Monitor Performance ​

Review Costs ​

Summary: What You've Mastered ​

Next Steps ​

4.3 Templates & Data Flow

How Columns Access Data

The Basic Concept

Accessing Data Step by Step

Step 1: Basic Column Access

Step 2: Accessing Nested Properties

Step 3: Using Multiple Columns

Understanding Data Flow Patterns

Pattern 1: Linear Pipeline

Pattern 2: Parallel Enrichment

Pattern 3: Branching Logic

Pattern 4: Human-in-the-Loop

Understanding Cell States

State Meanings

Troubleshooting Guide

Issue 1: "Column Never Executes"

Issue 2: "Column Executes But Fails"

Issue 3: "Wrong Data in Cell"

Issue 4: "Too Slow"

Debugging Checklist

Best Practices

Design Principles

Common Data Flow Structures

The Fundamental Pattern

Multi-Source Enrichment

Conditional Processing

Testing Strategy

Test with One Row First

Check Edge Cases

Verify Conditions

Monitor Performance

Review Costs

Summary: What You've Mastered

Next Steps