4.1 Understanding Dependencies
In Chapter 3, you saw dependencies in action—you watched how one column waited for another to finish before starting. Now let's explore what dependencies are, why they're essential, and how they make your automations reliable and efficient.
What Are Dependencies?
The Basic Idea
A dependency is a simple relationship that says: "Column B waits for Column A to finish before it starts."
Think of everyday examples:
- You can't frost a cake until it's baked
- You can't send an email until you've written it
- You can't calculate a total until you know the prices
Dependencies work the same way—they make sure everything happens in the right order.
Why This Matters
Without dependencies, chaos ensues. Imagine all your columns trying to run at once:
❌ Without Dependencies:
Everyone starts at the same time:
- Trying to look up company... but no email entered yet
- Trying to score the lead... but no company data yet
- Trying to send email... but no score calculated yet
Result: Everything fails✅ With Dependencies:
Step 1: User enters email
Step 2: System looks up company (waits for step 1)
Step 3: System scores the lead (waits for step 2)
Step 4: System sends email (waits for step 3)
Result: Everything works smoothlyThe Five Big Benefits
1. Correctness: Things happen in the right order
- No trying to use data before it exists
- No sending emails before they're ready
- No calculating before you have the numbers
2. Reliability: Predictable, repeatable results
- Same order every time
- Automatic retry when needed
- No race conditions or random failures
3. Speed: Automatic parallel processing
- Independent columns run at the same time
- No wasted waiting
- Maximum efficiency without extra work
4. Visibility: See what's happening
- Clear status for each step
- Understand why something is waiting
- Easy troubleshooting
5. Flexibility: Easy to change
- Add or remove steps without breaking things
- Modify the order visually
- No complex reconfiguration
How Dependencies Create Flow
The Dependency Chain
Dependencies form a chain or flowchart showing how data flows through your automation.
Example from Chapter 3:
┌─────────────┐
│ Email │ (You type it in)
│ [Ready] │
└──────┬──────┘
│ waits for this
↓
┌─────────────┐
│ Company │ (API looks it up)
│ [Ready] │
└──────┬──────┘
│ waits for this
↓
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Name │ │ Size │ │ Industry │
│ [Completed] │ │ [Completed] │ │ [Completed] │
└─────────────┘ └─────────────┘ └─────────────┘Reading this chain:
- Top to bottom: Time flows downward
- Arrows: Show "waits for" relationships
- Levels: Columns group by when they can run
Parallel Processing: The Speed Boost
Here's where dependencies get powerful—columns at the same level run simultaneously.
Parallel Processing Example
Parallel execution: Max(2s, 2s) = ~2 seconds
Result: 2× faster!
What happens:
- You enter an email and LinkedIn URL
- Both enrichment services run at the same time
- Lead score waits for both to finish
- Email sends when score is ready
Performance impact:
- Sequential (one at a time): 2 seconds + 2 seconds = 4 seconds
- Parallel (both at once): Max(2s, 2s) = ~2 seconds
- Result: 2× faster!
With more parallel operations, the speed boost is even bigger.
Common Dependency Patterns
Pattern 1: Simple Chain (A → B → C)
What it looks like:
Each step depends on the previous one.
When to use:
- Step-by-step transformations
- Each step needs the previous result
- Sequential processing is required
Example:
Email → Validation → Company Lookup → Lead Score → Send EmailCharacteristics:
- ✅ Simple to understand
- ✅ Easy to debug
- ⚠️ Slower (no parallelism)
Pattern 2: Parallel Split (A → [B, C, D])
What it looks like:
One column triggers multiple independent operations.
When to use:
- Multiple data sources
- Independent enrichments
- Gathering information from different places
Example:
Email → [Clearbit, Apollo, Hunter]All three services look up data at the same time.
Characteristics:
- ✅ Fast (parallel execution)
- ✅ Efficient use of time
- ✅ Independent operations
Pattern 3: Convergence ([A, B, C] → D)
What it looks like:
Multiple columns feed into one operation.
When to use:
- Combining data from multiple sources
- Comprehensive analysis
- Creating summary from parts
Example:
[Company Data, Social Profiles, Website Info] → AI AnalysisCharacteristics:
- ✅ Comprehensive (uses all data)
- ⚠️ Waits for slowest dependency
- ⚠️ One failure can block execution
Pattern 4: Diamond (A → [B, C] → D)
What it looks like:
Split then converge—the most common real-world pattern.
Example:
Email
↓
[Clearbit, Apollo] ← Parallel
↓
Combined Score ← Waits for bothWhy it's powerful:
- Fast parallel processing
- Then comprehensive analysis
- Best of both worlds
Understanding Column States
When you look at your automation, each cell shows a status. Here's what they mean:
States That Block Dependencies
Some states mean "not ready yet":
- Ready [Gray]: Waiting for dependencies
- Queued [Pulsing clock]: In line to run
- Running [Spinning gear]: Currently processing
Columns depending on these cells stay in "Ready" state until they're done.
States That Satisfy Dependencies
These states mean "you can proceed":
- Completed [Green checkmark]: Successfully done
- Skipped [Gray dash]: Condition wasn't met (optional dependencies only)
States That Indicate Problems
- Unsuccessful [Blue badge]: Something went wrong
- Rate Limited [Yellow pause]: Temporarily throttled
When a column fails, dependent columns stay in "Ready" state waiting for you to fix the problem.
Configuring Dependencies
Where Dependencies Come From
Dependencies are automatically detected from your column configuration:
When you reference a column, a dependency is created automatically.
For example, if you configure an API call that uses customer email, the system knows this column depends on the email column.
The Dependency Panel
When you edit a column's run configuration, you see all its dependencies:
Run Configuration
When you configure columns to use data from other columns, the system automatically detects these dependencies. You can then control exactly when and how this column should run based on those dependencies.
What you can control:
When to run:
- Always: Run every time dependencies change
- Once: Run once when dependencies first complete
- Regularly: Run on a schedule
- Manual: Only run when you click
Which columns trigger execution:
- Select specific columns that must be completed
- Or let all referenced columns trigger it
Conditions (optional):
- Only run if a condition is true
- Example: Only enrich if company size > 100 employees
Delays (optional):
- Wait a specific time after dependencies are satisfied
- Useful for rate limiting or batching
Optional vs Required Dependencies
Required (default): Column must be Completed
- If dependency fails, this column waits
- Ensures data is always available
Optional: Column can be Completed or Skipped
- If dependency is skipped, this column can still run
- Useful for optional enrichments
Avoiding Circular Dependencies
The Problem
A circular dependency happens when columns depend on each other in a loop:
❌ Invalid:
A depends on B
B depends on A
Result: Neither can ever run!How the System Protects You
The system prevents you from creating circular dependencies:
- When you try to save a column configuration
- System checks for circular dependencies
- If found, shows an error: "Circular dependency detected"
- You must fix it before saving
How to Fix
Strategy:
- Look at the error message (shows the loop)
- Identify which dependency can be removed
- Restructure your columns
Example Fix:
❌ Problem:
Full Address depends on Formatted City
Formatted City depends on Full Address✅ Solution:
City → Formatted City → Full AddressBreak the loop by using the original data directly.
Visual Indicators in the Interface
In Column Headers
Column headers show activity status:
- Green spinning icon: Columns is currently running for at least one row
- Amber clock with number: Rows queued (number shows count)
Click these icons to jump to the active row.
In Cells
Each cell shows its current status with color-coded badges:
- Completed with green checkmark
- Running with spinning gear icon
- Queued with pulsing clock icon
- Ready in gray (waiting for dependencies)
- Unsuccessful in blue (click for error details)
When You Click a Cell
If a cell is in "Ready" state (waiting), click it to see:
- Which columns it depends on
- Which are completed ✓
- Which are still processing ⏳
- Why it's blocked
Real-World Example: Lead Enrichment Pipeline
Let's see how dependencies work in a complete automation:
Level 0 (Manual Input):
└─ Email [You type it in]
Level 1 (Validation):
└─ Email Valid [Checks format]
Level 2 (Enrichment - All Parallel):
├─ Clearbit [Company data]
├─ Apollo [Contact info]
└─ Hunter [Verify email]
Level 3 (Merge):
└─ Combined Data [Merges all sources]
Level 4 (Analysis):
└─ Lead Score [AI scoring]
Level 5 (Action):
└─ Send Email [Only if score > 70]Dependency flow:
- You enter email → Email Valid runs
- Email Valid completes → All 3 enrichments start simultaneously
- All 3 complete → Combined Data runs
- Combined Data completes → Lead Score runs
- Lead Score completes and score > 70 → Send Email runs
Why this design works:
- ✅ Parallel enrichment (3× faster)
- ✅ No data used before ready
- ✅ Conditional execution (only high-quality leads)
- ✅ Clear, debuggable flow
Estimated timing:
- Email entry: 0s
- Validation: 0.1s
- Enrichments (parallel): 2s (not 6s!)
- Merge: 0.1s
- Scoring: 1s
- Email: 0.5s
- Total: ~4 seconds instead of 10+ sequential
Troubleshooting Dependencies
"My column is stuck in Ready"
Possible causes:
- Dependency not complete yet: Check if previous columns are still running
- Dependency failed: Check for Unsuccessful badges
- Condition not met: If column has a condition, it might be waiting for condition to be true
How to fix:
- Click the Ready cell
- See which dependencies are blocking it
- Check those columns' status
- Fix any errors or complete manual inputs
"My automation is slow"
Possible causes:
- Sequential when could be parallel: Too many unnecessary dependencies
- Missing dependencies: Columns running too early and failing
How to optimize:
- Review your dependency chain
- Identify independent operations
- Remove unnecessary dependencies
- Let parallel operations run simultaneously
"Columns are running in wrong order"
Possible causes:
- Missing dependency: Add the missing relationship
- Circular dependency: Break the loop
How to fix:
- Map out desired flow on paper
- Add needed dependencies
- Remove circular references
Summary: Dependencies Are the Foundation
Dependencies are what transform individual columns into a coordinated automation:
✅ Correctness: Right order, every time ✅ Reliability: Predictable, repeatable results ✅ Performance: Automatic parallel processing ✅ Visibility: Clear status and flow ✅ Maintainability: Easy to modify and debug
Key Takeaway: Dependencies aren't just technical plumbing—they're the invisible conductor ensuring your automation performs reliably and efficiently.
What's Next: Continue exploring the platform to build more complex automations with dependencies, or revisit the Getting Started tutorial to practice these concepts hands-on.