3.2 Understanding What Just Happened
In Section 3.1, you built your first automation. Now let's step back and understand the concepts in action. This deeper understanding will help you build more complex automations with confidence.
The Data Flow
Here's what happened behind the scenes in your contact enrichment automation:
Manual Input
You entered: john@acme.com
Dependency Satisfied
System detects: company_data dependencies satisfied
API Enrichment
Clearbit API call executes
Extraction Cascade
company_name dependencies satisfied
Parallel Extraction
Other extract columns also run simultaneously
Step-by-Step Breakdown:
- Manual Input - You typed an email address into the email column
- System Detection - Taibles noticed the email was complete and ready
- API Enrichment - The system automatically called Clearbit with that email
- Data Storage - The company information came back and was saved
- Extraction Cascade - Multiple columns pulled different pieces from that data
- Parallel Execution - All extractions happened at the same time
💡 Why This Matters
Key Concepts Demonstrated
Let's name the patterns you just learned:
1. Manual Columns (Input Layer)
What you did: Created an email column where you typed contact emails
The concept:
- Manual columns are where you enter data or import it from files
- Think of them as the "inbox" of your automation
- No automation happens here - it's pure data entry
- Always shown with a checkmark because entry completes them
Manual Column: Email
Input Layer| Row | Status | |
|---|---|---|
| 1 | Complete | |
| 2 | Complete | |
| 3 | Empty |
- • Direct data entry by users
- • No automation or processing
- • Always marked Complete when filled
- • Can be edited anytime
Use cases:
- Initial data entry (names, emails, amounts)
- User decisions (checkboxes, yes/no choices)
- Override fields (manually fix incorrect data)
Pattern in your automation:
[Manual Input] → [Processing] → [Output]
email → company_data → extractions2. Calculated Columns (Processing Layer)
What you did: Created a company_data column that automatically looked up company info
The concept:
- Calculated columns do the work in your automation
- They call APIs, run AI, transform data, or perform actions
- Run automatically based on what they depend on
- Produce results without any manual work
Calculated Column: Company Data
Processing Layer| Email (Input) | Company Data (Calculated) | Status |
|---|---|---|
john@acme.com Complete | Acme Corporation | Complete |
sarah@techcorp.com Complete | TechCorp Industries | Complete |
mike@startup.io Complete | Looking up... | Processing |
Runs automatically for every row
Same process every time
Handles 1 or 1,000 rows
Reproducible results
Use cases:
- API calls (enrichment, validation, lookups)
- AI operations (classification, generation, analysis)
- Transformations (formatting, calculations)
- Actions (send emails, update CRM, create tickets)
💡 The Power of Automation
Why calculated columns matter:
- Automation: No manual work per row
- Consistency: Same process for every row
- Scalability: Process 1 or 1,000 rows the same way
- Reliability: Reproducible results every time
3. Dependencies (Execution Order)
What you did: Made company_data wait for email to complete first
The concept:
- Dependencies create a chain of execution
- Column B waits for Column A to finish before running
- Ensures correct order: input → processing → output
- Creates automatic cascading - one completion triggers the next
Parallel Processing Example
Parallel execution: Max(2s, 2s) = ~2 seconds
Result: 2× faster!
Why it matters:
- You don't manually click each column
- The system orchestrates the flow
- Add a row, watch everything cascade automatically
- No race conditions (Column B won't run before Column A finishes)
Dependency chain in your automation:
email (complete)
↓
company_data (waits for email)
↓
company_name (waits for company_data) ← These run
company_size (waits for company_data) ← in parallel
industry (waits for company_data) ← after
location (waits for company_data) ← company_data finishes4. Data References (Accessing Information)
What you did: Told columns which data to use (like "use the email" or "extract the company name")
The concept:
- You tell each column where to find its input data
- Point to other columns in the same row
- Access nested information (like company name inside company data)
- Use a picker or dropdown to select what you need
How Columns Reference Data
email columnname from company_dataemployees from company_datalocation from company_data- • Use dropdowns to select which column to reference
- • For nested data (like company name inside company data), use a picker to drill down
- • The system shows you available fields as you configure
- • All references are to data in the same row
Examples from your automation:
- Email lookup used: the email column
- Company name extracted: the name from company data
- Company size extracted: employee count from company data
- Location extracted: location from company data
Where you specify data:
- In the column configuration when setting up APIs
- In extraction columns when pulling specific fields
- In AI prompts when providing context
💡 Think of It Like This
5. Run Modes (Execution Behavior)
What you did: Selected when each column should run
The concept:
- Run modes control when columns execute
- Different modes for different purposes
- Choose the right mode to save money and time
Choose When This Column Runs
The four modes:
Run Once When Ready
- Runs when its dependencies complete
- Then stays finished forever
- Use for: Enrichment, lookups, one-time operations
Always Re-run When Inputs Change
- Re-runs whenever its dependencies change
- Keeps data always up-to-date
- Use for: Calculations, status indicators, formatted displays
Manual Trigger Only
- Only runs when you click "Run"
- Waits for your approval
- Use for: Actions like sending emails, making purchases, creating tickets
Scheduled
- Runs on a timer (hourly, daily, etc.)
- Use for: Periodic checks, data refreshes, scheduled actions
💡 Choose Wisely
Example: Why "Run Once" for enrichment:
- Enrichment costs money (API charges)
- Don't want to re-run every time email changes
- One-time lookup is sufficient
- Can manually re-run if needed
Example: Why "Always Re-run" for calculations:
Column: full_name
Formula: Combine first_name and last_name
Run Mode: Always Re-run
Dependencies: first_name, last_name
Result: If user changes first_name, full_name automatically updates6. Real-Time Execution (Live Updates)
What you experienced: Watching cells change as processing happened
The concept:
- Live connection provides instant updates
- No page refresh needed
- See the exact moment each cell completes
- Multiple people can watch the same automation
Cell State Progression
Click on any cell to see detailed information including error messages, execution history, and raw data.
State progression you saw:
- Empty (not started) → Gray placeholder text
- Queued (waiting to run) → Gray with pulsing clock icon
- Processing (running now) → Gray with spinning gear icon
- Complete (done successfully) → Green checkmark with data
- Error (something failed) → Red "Unsuccessful" badge
Why this matters:
- Debugging: See immediately what's working/failing
- Monitoring: Track progress of bulk operations
- Confidence: Visual feedback that the system is working
- Fun: Actually enjoyable to watch!
💡 Collaboration
7. Cell States (Execution Status)
What you saw: Different visual indicators showing what's happening
Let's understand each state you might see:
Cell State Visual Reference
| State | Visual | What It Means |
|---|---|---|
| Ready | Gray text | Waiting to start |
| Queued | Pulsing clock | In line to run |
| Running | Spinning gear | Currently processing |
| Completed | Completed | Successfully finished |
| Skipped | Skipped (Condition failed) | Condition failed - skipped |
| Rate Limited | Rate Limited | Waiting due to rate limits |
| Error | Unsuccessful | Something went wrong |
States in your automation:
Queued Queued
- Shows: Gray text with pulsing clock icon
- Means: In line to run, will start soon
- You saw: Brief moment before API call started
Processing Processing
- Shows: Gray text with spinning gear icon
- Means: Running right now
- You saw: While API call was happening
Complete Complete
- Shows: Green styling with checkmark
- Means: Successfully finished
- You saw: Final state for all successful cells
Error Unsuccessful
- Shows: Red badge with "Unsuccessful" label
- Means: Something went wrong
- You might see: For invalid emails or API failures
Other states you might encounter:
Throttled Rate Limited
- Shows: Yellow text
- Means: Slowed down to avoid hitting rate limits
- Common with: High-volume API operations
Scheduled Scheduled
- Shows: Gray text with hourglass icon
- Means: Waiting for a webhook or scheduled time
- Common with: Trigger-based automations
Skipped Skipped
- Shows: Gray text with circle-slash icon
- Means: Didn't run because conditions weren't met
- Common with: Conditional logic
💡 Click Any Cell
8. Parallel Execution (Performance)
What you didn't see (but happened): All rows processed at the same time
The concept:
- Taibles processes all rows simultaneously
- Your 4 emails → 4 API calls happening at once
- Maximizes speed
- Respects rate limits to avoid overwhelming APIs
Parallel Execution
- • Speed: Process hundreds of rows in minutes, not hours
- • Efficiency: Don't wait for serial execution
- • Control: Rate limiting prevents API abuse
- • Visibility: See progress across entire dataset
What happened behind the scenes:
Time 0: You clicked save
Time 1: All 4 rows queued at once
Time 2: All 4 API calls started together
Time 5: First call completes
Time 6: Third call completes
Time 7: Second call completes
Time 8: Fourth call completes
Total time: ~8 seconds for 4 rowsIf it ran one at a time (sequential):
2 seconds + 2 seconds + 2 seconds + 2 seconds = 8+ secondsScaling:
- 10 rows? 10 parallel operations
- 100 rows? 100 parallel operations (throttled by rate limits)
- 1,000 rows? Still works, just respects rate limits
💡 Speed Matters
The Fundamental Pattern
What you built follows a universal pattern that applies to all Taibles automations:
The Universal Automation Pattern
emailcompany_datacompany_namecompany_sizeindustrylocationlead_scoresend_emailYou don't need all layers for every automation. Start with what you need (Input → Processing → Extraction) and add more layers as requirements grow.
Your automation used layers 1-3:
- Input: email (manual entry)
- Processing: company_data (API lookup)
- Extraction: company_name, company_size, industry, location
You could extend to layers 4-5: 4. Analysis: lead_score (AI classification) 5. Action: send_email (automated outreach)
Comparison: What You Built vs. Traditional Automation
Let's compare your Taibles automation to other approaches:
Traditional Automation Platforms
What they lack:
- ❌ Black box - can't see what's happening
- ❌ No visibility into processing states
- ❌ Hard to debug when things fail
- ❌ One row at a time (serial execution)
- ❌ Can't inspect intermediate data
- ❌ Difficult to change after setup
Your Taibles Automation
What you get:
- ✅ Full visibility - see every cell's state
- ✅ Real-time monitoring with live icons
- ✅ Easy debugging - click cells for details
- ✅ Parallel execution across all rows
- ✅ Complete data access - inspect any step
- ✅ Flexible - add/change columns anytime
💡 Transparency Wins
What You've Achieved
Let's recap everything you accomplished:
Skills You Now Have
✅ Create Automations - You can build automation workflows ✅ Manual Columns - You can add input fields ✅ Calculated Columns - You can add automated processing ✅ Set Dependencies - You can chain execution order ✅ Choose Run Modes - You can control execution behavior ✅ Monitor Progress - You can watch automations run live ✅ Debug Issues - You can inspect cells and diagnose problems
Concepts You Understand
✅ Input → Process → Output - The fundamental pattern ✅ Cell States - What the visual indicators mean ✅ Data Flow - How information moves through columns ✅ Parallel Execution - Processing multiple rows simultaneously ✅ Rate Limiting - Controlling API usage ✅ Real-time Updates - Live feedback as work happens
What You Built
✅ Working Automation - A real enrichment pipeline ✅ Reusable Pattern - Apply this to other use cases ✅ Scalable Solution - Add more rows, it just works ✅ Extensible Base - Easy to add more features ✅ Production Ready - This is a tool you can actually use
The Power of Table-Based Automation
What makes Taibles different from other automation tools?
1. Observability
Every piece of data is visible:
- See all rows at once
- Inspect any cell
- Track state changes
- View execution history
- Monitor in real-time
Why this matters: Confidence in your automation, easy debugging, full audit trail, team transparency
2. Flexibility
Change anytime:
- Add new columns
- Remove old columns
- Change dependencies
- Update logic
- No migration needed
Why this matters: Iterate quickly, adapt to changing requirements, no downtime, safe experimentation
3. Scalability
From 1 to 100,000 rows:
- Same interface
- Same patterns
- Parallel execution
- Rate limiting handles scale
Why this matters: Start small and grow, no rewrite needed, performance built-in, cost control
4. Collaboration
Team-friendly:
- Multiple users
- Real-time updates
- Comments and notes
- Assignment workflows
Why this matters: Share workload, coordinate efforts, knowledge transfer, team visibility
Next: Where to Go From Here
You've mastered the fundamentals. Now you can:
Deepen Your Understanding
- Chapter 4: Dependencies and Data Flow: Deep dive into how dependencies work
- Chapter 5: Conditional Execution: Learn to skip unnecessary operations
- Section 2.2: Column Types: Explore all available column types
Expand Your Automation
- Add Scoring: Use AI to calculate lead quality scores
- Add Routing: Automatically assign leads based on criteria
- Add Actions: Send emails, update CRM systems, create tasks
- Add Triggers: Automate row creation with webhooks
Build New Automations
- Support Tickets: Email → Classification → Assignment → Response
- Order Processing: Webhook → Validation → Fulfillment → Tracking
- Content Pipeline: Research → Draft → Review → Publish
- Data Sync: Extract → Transform → Load → Verify
Summary: The Mental Model
Remember these key points:
Rows = Things Being Processed
- Each row is one item (contact, order, ticket, etc.)
- Rows are independent of each other
- Rows process in parallel
Columns = Processing Steps
- Each column does one thing
- Columns run in dependency order
- Columns reference other columns for data
Cells = Where Work Happens
- Each cell has data and a state
- States show what's happening right now
- Click any cell to see details
The Pattern:
Input → Process → Extract → Analyze → ActThe Power:
Visibility + Flexibility + Scalability + CollaborationCongratulations! You not only built your first automation, you now understand how and why it works. This deep understanding will serve you as you build more complex automations.
Next: Continue to Chapter 4: Dependencies and Data Flow for advanced patterns, or jump to Chapter 6: Triggers to learn how to automate row creation.
Happy building! 🚀