4.2 Configuring Dependencies

In Section 4.1, you learned what dependencies are and why they matter. Now let's dive into the practical aspects: how to configure dependencies in the interface, which run modes to use, and how to build reliable automation workflows.

This section is all about hands-on configuration—where to click, what to enter, and how to set up your automation for success.

The Run Configuration Panel

When you add or edit a calculated column, you configure its execution behavior in the Run Configuration section. This is the control center for dependencies.

Run Configuration

When should this column be triggered?

Columns needed to trigger a refresh:

Company Data

Rate limit the calculation of rows.

Do you want this column only to run when a condition matches?

// Enter condition expression here...

press CTRL + SPACE or start typing the column name

Accessing Run Configuration

Where: Column configuration sidebar → "Run Configuration" section

How to get there:

For new columns:
- Click "+ Add Column" button
- Select column type
- Configuration sidebar opens
- Scroll to "Run Configuration" section (usually near bottom)
For existing columns:
- Click gear icon (⚙️) in column header
- Or right-click column header → "Edit Configuration"
- Sidebar opens with current settings
- Scroll to "Run Configuration" section

The Four Configuration Elements

1. Run Mode: When to execute 2. Dependencies: What to wait for 3. Conditions: Whether to skip execution 4. Rate Limiting: How to throttle

Let's explore each in detail.

Run Modes: When Columns Execute

The Run Mode is the most fundamental setting—it determines when and how often a column executes.

Overview of the Four Run Modes

Run Mode	When It Runs	Use Case
Once	Once when dependencies satisfied	API calls, one-time transformations
Always	Every time dependencies change	Calculated fields, status indicators
Manual	Only when user clicks "Run"	Approval gates, expensive operations
Regularly	On a schedule	Polling, periodic updates

Let's dive deep into each mode.

Mode 1: Once (Most Common)

Use when: Calculate once when dependencies are satisfied, then done

The Concept

This is the default mode for most calculated columns. The column runs once after its dependencies complete, then stays completed unless manually re-run.

Value provided:

Efficiency: Runs only once per row
Cost control: One API call per row
Stability: Results don't change unexpectedly
Performance: No redundant executions

Perfect for:

API enrichment (company data, contact info, validation)
One-time transformations
Expensive AI operations
Any operation that doesn't need updates

Behavior Details

ReadyQueuedRunningCompleted

✓ Cell stays Completed forever (unless manually re-run)

Even if dependencies update later, this cell will not re-execute. Perfect for API calls and expensive operations.

State flow:

Cell starts as Ready
When dependencies complete → Queued
System picks up cell → Running
On completion → Completed
Cell stays Completed even if dependencies update later

Re-execution:

You can manually click "Re-run" to recalculate
Useful for refreshing stale data
Resets cell to Ready, then follows normal flow

Configuring "Once" Mode

When should this column be triggered?

Selected: Run once the dependencies change

Step-by-step:

In Run Configuration section, find the "When should this column be triggered?" dropdown
Select "Once" (full label: "Run once the dependencies change")
The dropdown closes
Mode is set ✓

Example Scenarios

Scenario 1: Company Enrichment

Column: Company Data
Run Mode: Once
Dependencies: Email column
Why: Enrichment costs money and data doesn't change often
Result: Calls API once per email, stores result, done

Scenario 2: AI Classification

Column: Email Category
Run Mode: Once
Dependencies: Email Body column
Why: AI classification is expensive and text doesn't change
Result: Classifies once, stores category, done

Scenario 3: Data Transformation

Column: Formatted Address
Run Mode: Once
Dependencies: Street, City, State, Zip columns
Why: We want to format once and keep that formatting
Result: Formats address once, even if source changes later

When NOT to Use "Once"

Avoid "Once" For:

Calculated fields that should always reflect current data
Status indicators that need real-time updates
Values derived from frequently changing sources

Example of wrong usage:

Column: Full Name
Run Mode: Once ❌ Wrong!
Dependencies: First Name, Last Name
Problem: If you change First Name, Full Name doesn't update
Solution: Use "Always" mode instead

Mode 2: Always (Calculated Fields)

Use when: Recalculate whenever dependencies change

The Concept

This mode creates reactive, always-current values. Whenever any dependency updates, the column automatically re-executes to stay synchronized.

Value provided:

Accuracy: Always reflects latest data
Reactivity: Updates automatically
Synchronization: Never stale
Real-time: Changes propagate immediately

Perfect for:

Calculated fields (full name, full address)
Status indicators (order status, lead status)
Derived metrics (days since contact)
Any value that must stay current

Behavior Details

ReadyQueuedRunningCompleted

When dependencies change, restart from Queued

⟳ Cell automatically re-runs whenever dependencies change

This creates reactive, always-current values. Perfect for calculated fields that must stay synchronized with their source data.

State flow:

Cell starts as Ready
When dependencies complete → executes
Cell becomes Completed
System watches dependencies for changes
If any dependency updates → cell resets to Queued
Re-executes with new data
Becomes Completed again
Cycle continues forever

Important: This can create cascading updates

Example cascade:

You change: First Name
    ↓
Full Name (Always mode) re-runs
    ↓
Email Greeting (depends on Full Name, Always mode) re-runs
    ↓
Email Template (depends on Email Greeting, Always mode) re-runs

Configuring "Always" Mode

When should this column be triggered?

Warning

This column will re-run every time dependencies change. This may increase API costs if used with external services.

Step-by-step:

In Run Configuration section, find the "When should this column be triggered?" dropdown
Select "Always" (full label: "Run every time the dependencies change")
The dropdown closes
Mode is set ✓

Cost Warning

This column will re-run every time dependencies change. This may increase API costs if used with external services.

Example Scenarios

Scenario 1: Full Name

Column: Full Name
Run Mode: Always
Dependencies: First Name, Last Name
Formula: Combines First Name and Last Name
Why: Name should always reflect current first/last values
Result: Updates immediately when either name changes

Scenario 2: Order Status

Column: Order Status
Run Mode: Always
Dependencies: Payment Status, Shipping Status
Logic:
  If payment paid and shipping shipped → "Complete"
  Else if payment paid → "Paid"
  Else → "Pending"
Why: Status should always reflect current payment/shipping
Result: Updates automatically as payment/shipping change

Scenario 3: Days Since Contact

Column: Days Since Last Contact
Run Mode: Always
Dependencies: Last Contact Date
Calculation: Current date minus last contact date
Why: This value changes every day as time passes
Result: Always shows current day count

When NOT to Use "Always"

NEVER Use "Always" For:

API calls (expensive, will call repeatedly)
Email sending (will send multiple times!)
Database writes (creates duplicates)
AI operations (expensive and slow)

Example of dangerous usage:

Column: Send Welcome Email
Run Mode: Always ❌ DANGEROUS!
Dependencies: Email, Full Name
Problem: Every time name changes, email sends again!
Solution: Use "Once" or "Manual" mode instead

Best Practices for "Always"

✅ Good uses:

String concatenation: Combining First and Last names
Math calculations: Quantity times Price
Status determination: Based on other columns
Formatting: Combining Date and Time

❌ Bad uses:

External API calls
Sending communications
Creating records
Anything with side effects

Mode 3: Manual (User-Triggered)

Use when: Only execute when you explicitly click "Run"

The Concept

This mode gives complete control to you. The column never auto-executes—you must manually trigger each run.

Value provided:

Safety: No accidental execution
Control: You decide when to run
Review: Chance to verify before running
Approval gate: Human-in-the-loop workflow

Perfect for:

Sending emails or SMS
Creating tickets or records in external systems
Expensive operations you want to control
Approval/review steps
Testing and development

Behavior Details

Ready(stays here forever...)

← You must click this

QueuedRunningCompleted

👆 Cell NEVER auto-executes - complete user control

Perfect for sending emails, creating records, or any action you want explicit approval for. Prevents accidental execution.

State flow:

Cell stays as Ready forever
Never auto-executes (even if dependencies satisfied)
You see "Run" button in cell or column header
You click "Run"
Cell moves to Queued → Running → Completed
Cell stays Completed until you run again

UI indicators:

Play icon (▶) appears in cell
Tooltip: "Click to run"
Column header shows "Run All" option

Configuring "Manual" Mode

When should this column be triggered?

Manual Mode

This column will not execute automatically. You must click "Run" to execute each cell.

Step-by-step:

In Run Configuration section, find the "When should this column be triggered?" dropdown
Select "Manual" (full label: "Run only when clicked")
The dropdown closes
Mode is set ✓

Manual Mode

This column will not execute automatically. You must click "Run" to execute each cell.

Running Manual Columns

Running a Single Cell

Ready to run

← Click to execute this cell

Running All Cells in Column

1. Click column header menu (⋮)

2. Select "Run All Cells"

3. Confirm in dialog

All Ready cells will execute. Already completed cells are skipped.

Running Selected Cells

1. Check rows you want to run

2. Right-click selection

3. Choose "Run [Column Name]"

To run a single cell:

Click the cell with ▶ icon
Click "Run" button in detail panel
Cell executes

To run all cells in column:

Click column header three-dot menu (⋮)
Select "Run All Cells"
Confirmation dialog appears
Click "Confirm"
All Ready cells in column execute

To run selected cells:

Check checkboxes on rows you want
Right-click selection
Choose "Run [Column Name]"
Selected cells execute

Example Scenarios

Scenario 1: Email Approval Workflow

Auto Draft (Once mode)
    ↓
Review Approved (manual checkbox - you check it)
    ↓
Send Email (Manual mode) - you must click Run
    Dependencies: Auto Draft, Review Approved
    Condition: Review Approved must be true

Why: Prevents accidental email sending, requires explicit action

Scenario 2: Expensive Research Operation

Column: Deep Web Research
Run Mode: Manual
Dependencies: Company Name
Why: Costs $5 per run, you decide if worth it
Result: You review company, click Run if you want research

Scenario 3: CRM Record Creation

Column: Create Salesforce Lead
Run Mode: Manual
Dependencies: Lead Score, Qualification Status
Condition: Lead Score must be greater than 70
Why: You want to review before creating CRM records
Result: You verify data, then click Run to create record

Pattern: Human-in-the-Loop

Common pattern:

1. AI/automation generates draft (Once mode)
2. You review and approve (manual column)
3. Action executes (Manual mode, depends on approval)

Implementation:

Column: Email Draft
  Run Mode: Once
  Action: AI generates personalized email

Column: Approved for Send
  Type: Checkbox (manual column)
  You: Review draft, check box if approved

Column: Send Email
  Run Mode: Manual
  Dependencies: Email Draft, Approved for Send
  Condition: Approved for Send must be checked
  Note: You must still click Run even after approval

Why double-check?

Approval checkbox = "this content is good"
Manual Run = "send it now"
Prevents accidental bulk sending

Mode 4: Regularly (Scheduled)

Use when: Execute on a time-based schedule

The Concept

This mode runs columns based on time, not dependencies. Perfect for polling external systems, periodic checks, or scheduled reports.

Value provided:

Automation: No manual trigger needed
Scheduling: Runs at predictable times
Polling: Can fetch latest data periodically
Monitoring: Regular health checks

Perfect for:

Polling APIs for updates
Checking stock prices hourly
Daily report generation
Periodic data refresh
Monitoring external systems

Behavior Details

Scheduled Waiting for 9:00 AM...

QueuedRunningCompleted

Returns to Scheduled, waits for next time

🕐 Cell executes on time-based schedule (e.g., every hour, daily at 9 AM)

Perfect for polling APIs, checking stock prices, or generating periodic reports. Runs automatically at specified times.

State flow:

Cell starts as Ready (or Completed if already run)
System checks schedule
When schedule time arrives → cell moves to Queued
Executes
Becomes Completed
Cell shows as Scheduled while waiting for next time
Waits for next scheduled time
Repeats indefinitely

Multiple executions: Yes, runs every schedule occurrence

Configuring "Regularly" Mode

When should this column be triggered?

Specify a cron expression when this should run

Example: 0 9 * * * = Every day at 9:00 AM

Preview: Runs daily at 9:00 AM

Next execution: Tomorrow at 9:00 AM

Step-by-step:

In Run Configuration section, find the "When should this column be triggered?" dropdown
Select "Regularly" (full label: "Run regularly at intervals")
Cron expression field appears
Enter cron expression manually
Optional: Select timezone

Cron Expression Syntax

Format: minute hour day month dayOfWeek (5 fields)

Common examples:

0 9 * * * - Every day at 9:00 AM
*/30 * * * * - Every 30 minutes
0 9-17 * * MON-FRI - Hourly during business hours, weekdays only
0 0 1 * * - First day of each month at midnight
0 * * * * - Every hour
* * * * * - Every minute

Common Cron Expressions

0 9 * * *

Every day at 9:00 AM

*/30 * * * *

Every 30 minutes

0 9-17 * * MON-FRI

Every hour, 9 AM-5 PM, weekdays

0 0 1 * *

First day of each month

0 * * * *

Every hour

* * * * *

Every minute

Format:

minute (0-59) | hour (0-23) | day (1-31) | month (1-12) | dayOfWeek (0-7)

Field meanings:

minute: 0-59
hour: 0-23
day: 1-31 (day of month)
month: 1-12 (or JAN-DEC)
dayOfWeek: 0-7 (0 and 7 are Sunday, or MON-SUN)

Special characters:

*: Any value
*/N: Every N units (e.g., */15 = every 15 minutes)
N-M: Range (e.g., 9-17 = 9 AM to 5 PM)
N,M: List (e.g., MON,WED,FRI)

Pro tip: Start with simple expressions like 0 * * * * (every hour) and test before using complex patterns.

Example Scenarios

Scenario 1: Stock Price Monitor

Column: Current Stock Price
Run Mode: Regularly
Schedule: 0 9-17 * * MON-FRI  (hourly, business hours)
Dependencies: Stock Symbol
Why: Check stock price every hour during trading
Result: Makes API call every hour, updates price

Scenario 2: Daily Report

Column: Generate Daily Metrics
Run Mode: Regularly
Schedule: 0 0 * * *  (daily at midnight)
Why: Generate and cache daily metrics
Result: Runs every night, fresh metrics every morning

Scenario 3: Periodic Sync

Column: Sync from Salesforce
Run Mode: Regularly
Schedule: */15 * * * *  (every 15 minutes)
Why: Keep data synchronized with external system
Result: Pulls latest data every 15 minutes

Combining Schedule with Dependencies

You can have both scheduled execution AND dependencies:

Column: Scheduled Enrichment
Run Mode: Regularly
Schedule: 0 9 * * *  (daily at 9 AM)
Dependencies: Email
Condition: Email must not be empty

Behavior:
- Runs daily at 9 AM
- But only for rows where email is present
- Skips rows with null email

Use case: Re-enrich data daily to keep it fresh, but only for valid rows.

Note on Scheduled state: When using Regularly mode, cells will show as Scheduled (with hourglass icon) while waiting for their next scheduled execution time. This is different from Ready—it indicates the cell is actively scheduled and will execute at the specified time.

Cost Considerations

Warning: Regular Mode Can Be Expensive!

Example cost calculation:

Column: API Enrichment (costs $0.10 per call)
Run Mode: Regularly
Schedule: Every hour (24 times per day)
Rows: 100

Daily cost: 100 rows × 24 hours × $0.10 = $240/day
Monthly cost: $240 × 30 = $7,200/month

Best practices:

Use longer intervals when possible
Add conditions to skip unnecessary rows
Consider using triggers instead of polling
Monitor costs in dashboard

Configuring Dependencies: Step by Step

Now let's walk through the practical process of adding dependencies to a column.

The Dependency Selector

Location: Run Configuration → Dependencies section

Columns needed to trigger a refresh:

Email Company Data

Disable all to run every time a referenced column changes. Beware: Columns that are not done will provide null as value

Adding Your First Dependency

Scenario: Creating a lead scoring column that needs company data

Step 1: Open Column Configuration

Create or edit the column (Lead Score)
Go to "Run Configuration" section

Step 2: Find the Dependencies Section

Look for "Columns needed to trigger a refresh:" label
Below it is a multi-select dropdown

Step 3: Select Dependencies

Click the dependencies dropdown

Select columns... ▼

List of columns appears

Company Data

Social Profiles

Email Valid

✓

Dependency added!

Company Data

Click the dependencies dropdown
List of available columns appears
Check "Company Data" from the list
Column is added as a dependency
Appears as a chip with × to remove if needed

Adding Multiple Dependencies

Continuing the example: Lead score needs both company data and social profiles

Columns needed to trigger a refresh:

Select columns... ▼

Company Data Social Profiles

Both dependencies selected: Column will wait for BOTH Company Data AND Social Profiles to complete before running.

Step 1: Same Dropdown, More Selections

First dependency already exists: Company Data
Click the dependencies dropdown again
List of columns appears

Step 2: Select Additional Dependencies

Check "Social Profiles" from the list
Both dependencies now appear as chips
Verify both are selected

All dependencies are AND logic: Column waits for ALL to be completed.

Editing Dependencies

To remove a dependency:

Click the × on the dependency chip
Chip disappears
Dependency removed

To change dependencies:

Simply check/uncheck columns in the dropdown
Changes apply immediately

Understanding Dependency Behavior

Important Note

From the help text: "Disable all to run every time a referenced column changes. Beware: Columns that are not done will provide null as value"

This means:

If you select specific dependencies, the column waits for those to complete
If you don't select any dependencies, the column runs whenever ANY referenced data changes
Columns that haven't completed yet will provide empty/null values

Configuring Conditions

Location: Run Configuration → Condition expression section

The Concept

Conditions let you skip execution for rows that don't need processing. This saves time, money, and API calls.

When evaluated: After dependencies satisfied, before execution

Outcome:

Condition true: Execute normally
Condition false: Skip, cell shows as Skipped (with condition failed indicator)

Adding a Condition

Do you want this column only to run when a condition matches?

press CTRL + SPACE or start typing the column name

Condition: Only run if Company Size is greater than 100

Step 1: Find the Section

Look for the text: "Do you want this column only to run when a condition matches?"

Below it is a code editor field for entering your condition.

Step 2: Enter Condition Expression

Type an expression that evaluates to true/false. Use the placeholder format to reference other columns:

Example 1: Only enrich large companies

[Company Size] > 100

Example 2: Only send if qualified and valid email

[Lead Qualified] == true AND [Email Valid] == true

Example 3: Skip if already processed

[Processed Timestamp] == null

Step 3: Use Auto-Complete

Company Data

Company Name

Company Size

Type column name to see suggestions. Use arrow keys to navigate, Enter to select.

Start typing a column name in brackets: [Comp
Auto-complete suggestions appear
Select the column you want to reference
Build your expression

Help Text

The editor shows: "press CTRL + SPACE or start typing the column name" to trigger auto-complete

Condition Syntax

Operators:

== Equal
!= Not equal
> Greater than
< Less than
>= Greater than or equal
<= Less than or equal
AND Logical AND
OR Logical OR
NOT Logical NOT

Examples:

javascript

// Null check
[Email] != null

// Numeric comparison
[Company Size] > 50

// String comparison
[Status] == "qualified"

// Multiple conditions
[Email Valid] == true AND [Company Size] > 100

// OR logic
[Source] == "website" OR [Source] == "referral"

// Complex
([Priority] == "high" OR [Value] > 10000) AND [Approved] == true

What Happens When Condition Fails

Cell State: Skipped (Condition failed)

Skipped (Condition failed)

What happened: The condition expression evaluated to false for this row.

Example: Condition was [Company Size] > 100, but Company Size was 50.

Impact: This cell is considered "finished" for dependency purposes. Downstream columns can still run but will see an empty/null value from this cell.

State: Cell shows as Skipped (with option icon, gray color)

Visual indicators:

Gray color in cell
Option icon indicator
Click cell to see details: "Skipped (Condition failed)"

Impact on downstream columns:

Skipped cells are considered "finished" for dependency purposes
Downstream columns can still run
They'll see empty/null value from skipped column
Can add their own condition to check: [Upstream] != null

Other Skip States

Skipped (Dependencies not present):

Cell State: Skipped (Dependencies not present)

Skipped (Dependencies not present)

What happened: The cell's dependencies couldn't be resolved.

Common reasons:

Referenced column doesn't exist
Cross-table dependencies point to deleted rows
Required data is missing

What to do: Review the dependency configuration and ensure all referenced columns and rows exist.

This state occurs when a cell's dependencies cannot be resolved—for example:

Referencing a column that doesn't exist
Cross-table dependencies point to rows that have been deleted
Required data is missing

Visual indicators:

Gray color in cell
Circle-slash icon
Text: "Skipped (Dependencies not present)"

What to do: Review the dependency configuration and ensure all referenced columns and rows exist.

Rate Limiting Configuration

Location: Run Configuration → Rate limiting section

The Concept

Rate limiting throttles execution to respect API limits and control costs. Essential for external API calls.

Why needed:

API providers have limits (e.g., 100 requests/hour)
Prevent overwhelming external systems
Control costs
Avoid getting blocked

Enabling Rate Limiting

Rate limit the calculation of rows.

Run up to

rows (times) per

Configured: Maximum 100 executions per 1 hour(s)

When limit reached, remaining cells wait until the quota refreshes.

Step 1: Find the Toggle

Look for: "Rate limit the calculation of rows."

Below it is a toggle switch.

Step 2: Toggle ON

Click the toggle to enable
Configuration fields appear

Step 3: Configure Limits

The interface shows:

Run up to [X] rows (times) per [Y] [UNIT]

Fields explained:

Run up to: How many executions allowed (e.g., 100)
rows (times) per: Text label
Number field: Time period (e.g., 1)
Unit dropdown: SECONDS, MINUTES, HOURS, or DAYS

Example configurations:

10 per minute:

Run up to: 10
Per: 1
Unit: minutes

1000 per hour:

Run up to: 1000
Per: 1
Unit: hours

5 per second:

Run up to: 5
Per: 1
Unit: seconds

What Happens When Rate Limited

Cell State: Rate Limited

Rate Limited

What happened: The column hit its rate limit threshold.

Example scenario:

Rate limit: 100 executions per hour
Column already executed 100 cells this hour
Remaining cells show as "Rate Limited"
Will auto-retry when quota refreshes

What happens next: The system automatically retries when a slot becomes available. No manual action needed!

State: Cells show as Rate Limited (yellow color, pause icon)

Behavior:

Column starts executing cells
Hits rate limit threshold
Remaining cells move to Rate Limited state
System automatically retries after quota refreshes
Cells execute when slot available

Visual indicators:

Yellow/orange color in cells
Pause icon
Hover tooltip: "Rate Limited"
Column header may show: "5 rate limited"

User experience:

Transparent: You can see throttling happening
Automatic: No manual intervention needed
Predictable: Know when cells will run

Best Practices for Configuration

Design Principles

1. Minimum Dependencies

✅ Good: Only depends on what it uses

Column: Company Name
Dependencies: Company Data
Uses: Company Data to extract name

❌ Bad: Unnecessary dependencies

Column: Company Name
Dependencies: Company Data, Email, Validation, Social Profiles
Problem: Waits for columns it doesn't need

2. Appropriate Run Modes

✅ Good: Calculated field

Full Name (Always mode): Combines First and Last name

✅ Good: API call

Company Data (Once mode): Clearbit API enrichment

❌ Bad: API with Always

Company Data (Always mode): Clearbit API
Problem: Re-calls API on every change (expensive!)

3. Use Conditions to Optimize

✅ Good: Skip unnecessary operations

Column: Premium Enrichment
Condition: [Basic Enrichment Company Size] > 100
Result: Only enriches large companies, saves money

4. Clear Dependency Chains

✅ Good: Linear, understandable

Email → Validation → Enrichment → Scoring

❌ Bad: Tangled

Email → Scoring
Scoring → Enrichment  (Backwards!)

5. Parallelize When Possible

✅ Good: Parallel enrichment

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

❌ Bad: Sequential (slower)

Email → Clearbit → Apollo → Hunter → Merged

Configuration Checklist

Before saving a calculated column:

[ ] Run Mode selected appropriately
[ ] Dependencies include all required columns (and no more)
[ ] Conditions added if some rows should skip
[ ] Rate limiting enabled for API calls
[ ] Tested with one row first
[ ] Reviewed for circular dependencies

Summary

You now know how to configure:

✅ Run Modes: When columns execute

Once for one-time operations
Always for reactive values
Manual for user control
Regularly for scheduled execution

✅ Dependencies: What columns wait for

Single dependencies
Multiple dependencies (AND logic)
Understanding dependency behavior
Removing and editing

✅ Conditions: Whether to skip execution

Expression syntax
Optimization strategies
Handling skipped cells

✅ Rate Limiting: Throttling execution

Setting limits
Understanding throttled state
Respecting API quotas

Next: 4.3 Template System and Data Flow — Learn how to access and transform data using templates, master data flow patterns, and troubleshoot dependency issues.

4.2 Configuring Dependencies ​

The Run Configuration Panel ​

Run Configuration

Accessing Run Configuration ​

The Four Configuration Elements ​

Run Modes: When Columns Execute ​

Overview of the Four Run Modes ​

Mode 1: Once (Most Common) ​

The Concept ​

Behavior Details ​

Configuring "Once" Mode ​

Example Scenarios ​

When NOT to Use "Once" ​

Mode 2: Always (Calculated Fields) ​

The Concept ​

Behavior Details ​

Configuring "Always" Mode ​

Example Scenarios ​

When NOT to Use "Always" ​

Best Practices for "Always" ​

Mode 3: Manual (User-Triggered) ​

The Concept ​

Behavior Details ​

Configuring "Manual" Mode ​

Running Manual Columns ​

Running a Single Cell

Running All Cells in Column

Running Selected Cells

Example Scenarios ​

Pattern: Human-in-the-Loop ​

Mode 4: Regularly (Scheduled) ​

The Concept ​

Behavior Details ​

Configuring "Regularly" Mode ​

Cron Expression Syntax ​

Common Cron Expressions

Example Scenarios ​

Combining Schedule with Dependencies ​

Cost Considerations ​

Configuring Dependencies: Step by Step ​

The Dependency Selector ​

Adding Your First Dependency ​

Click the dependencies dropdown

List of columns appears

Dependency added!

Adding Multiple Dependencies ​

Editing Dependencies ​

Understanding Dependency Behavior ​

Configuring Conditions ​

The Concept ​

Adding a Condition ​

Condition Syntax ​

What Happens When Condition Fails ​

Cell State: Skipped (Condition failed)

Other Skip States ​

Cell State: Skipped (Dependencies not present)

Rate Limiting Configuration ​

The Concept ​

Enabling Rate Limiting ​

What Happens When Rate Limited ​

Cell State: Rate Limited

Best Practices for Configuration ​

Design Principles ​

Configuration Checklist ​

Summary ​

4.2 Configuring Dependencies

The Run Configuration Panel

Accessing Run Configuration

The Four Configuration Elements

Run Modes: When Columns Execute

Overview of the Four Run Modes

Mode 1: Once (Most Common)

The Concept

Behavior Details

Configuring "Once" Mode

Example Scenarios

When NOT to Use "Once"

Mode 2: Always (Calculated Fields)

The Concept

Behavior Details

Configuring "Always" Mode

Example Scenarios

When NOT to Use "Always"

Best Practices for "Always"

Mode 3: Manual (User-Triggered)

The Concept

Behavior Details

Configuring "Manual" Mode

Running Manual Columns

Example Scenarios

Pattern: Human-in-the-Loop

Mode 4: Regularly (Scheduled)

The Concept

Behavior Details

Configuring "Regularly" Mode

Cron Expression Syntax

Example Scenarios

Combining Schedule with Dependencies

Cost Considerations

Configuring Dependencies: Step by Step

The Dependency Selector

Adding Your First Dependency

Adding Multiple Dependencies

Editing Dependencies

Understanding Dependency Behavior

Configuring Conditions

The Concept

Adding a Condition

Condition Syntax

What Happens When Condition Fails

Other Skip States

Rate Limiting Configuration

The Concept

Enabling Rate Limiting

What Happens When Rate Limited

Best Practices for Configuration

Design Principles

Configuration Checklist

Summary