Part 1: Welcome to AI Automation
Section 1.2: Core Architecture - The Building Blocks
Now that you've seen what you can build, let's understand how it all works under the hood. Don't worry—this isn't a computer science lecture. Think of it as learning how a car works so you can drive it better.
Understanding these four simple building blocks will help you:
- Design better automations
- Fix problems when they arise
- Know exactly what's happening at every step
- Get the most out of the system
The Four Building Blocks
Everything in the system is built from just four pieces:
Table (Your Workspace)
└─ Rows (Individual Items)
└─ Columns (Actions to Take)
└─ Cells (Where Work Happens)Let's explore each one, starting from the top.
1. Tables: Your Automation Workspace
What is a Table?
A table is your workspace for one specific automation or process. Think of it like:
- A dedicated project folder for one type of work
- A factory assembly line set up for one product
- A spreadsheet on steroids that can take actions in the real world
💡 💡 Real-World Analogy
If spreadsheets are like notebooks where you write down information, tables are like robots that do work based on that information.
- A spreadsheet calculates numbers
- A table can send emails, search databases, call AI, update systems, and much more
What Makes Up a Table?
Every table has:
Identity:
- A unique name (e.g., "Customer Support", "Lead Enrichment")
- A description explaining what it does
- A type (standard table, chatbot, or nested sub-table)
Structure:
- Columns that define what actions to take
- Triggers that automatically create new rows
- Settings for permissions, notifications, etc.
State:
- Enabled or disabled (you can pause a table)
- Active or archived
Here's What a Table Looks Like
My Tables
Your automated workflows
Customer Support
ActiveAI-powered support ticket handling
Lead Enrichment
ActiveAutomatic lead data enrichment pipeline
Order Processing
ActiveE-commerce order fulfillment workflow
💡 Each table is a workspace for one type of automation. Click any table to see its rows and columns.
When to Create a New Table
Create separate tables for distinct processes:
✅ Good Examples:
- "Customer Support Tickets" (one table)
- "Sales Leads" (another table)
- "Order Fulfillment" (a third table)
❌ Poor Examples:
- "All My Data" (too broad—breaks it down by process)
- Separate tables for "New Leads" vs "Qualified Leads" (use one table with filters instead)
💡 Rule of Thumb
If it's a distinct workflow with its own steps, it deserves its own table.
If it's just a different view of the same workflow, use one table with filters.
2. Rows: Individual Instances
What is a Row?
A row represents one item moving through your automation. It's the atomic unit of work.
- In a "Customer Support" table → Each row is one support conversation
- In a "Sales Leads" table → Each row is one potential customer
- In an "Orders" table → Each row is one order
💡 💡 Think of It Like This
If a table is a factory assembly line, a row is one item moving down that line.
Each station (column) does its work as the item passes through.
How Rows Are Created
Rows can be created in three ways:
- Manually: You click "+ Add Row" and enter data yourself
- Import: You upload a CSV file with many rows at once
- Automatically: Triggers create rows when events happen:
- Someone fills out your website form → New row
- An email arrives → New row
- A scheduled time is reached (e.g., every Monday) → New row
- A webhook is received from another system → New row
What's Inside a Row?
Every row contains:
System Information (automatically tracked):
- Unique row ID
- When it was created
- Who created it (if applicable)
- Link to parent row (for nested tables)
Your Data (one value per column):
- Email address
- Customer name
- AI-generated response
- Status
- Score
- And whatever else your columns produce
The Life of a Row
Creation
Row is created
- •Manual click "+ Add Row"
- •CSV import
- •Form submission
- •Email arrives
- •Webhook trigger
Processing
Columns execute automatically
- •Cells go from gray → blue → green
- •Data flows left to right
- •AI generates responses
- •APIs are called
Completion
All automations finish
- •All cells are green or red
- •Data is ready to use
- •Actions have been taken
- •Results are visible
Management
You can review and manage
- •Export data
- •Delete old rows
- •Retry failed cells
- •Use as historical data
Each row moves through these stages automatically. You can watch it happen in real-time!
💡 The Beautiful Part
Once you set up your columns, every single row flows through the same automation automatically.
Create 1 row or 1,000 rows—they all get processed the same way, with zero extra effort from you.
3. Columns: The Actions You Take
What is a Column?
A column defines one step in your automation. It specifies:
- What operation to perform
- When to perform it
- What data it needs
- What data it produces
Think of columns as instructions for what to do with each row.
Two Types of Columns
Manual Columns
You enter the data yourself
Text
Customer name, notes, descriptions
Number
Prices, quantities, scores
Date
Due dates, timestamps
Checkbox
Yes/No, completed/not completed
File Upload
Attachments, documents, images
Automated Columns
Do work automatically (200+ types available)
AI & Intelligence
- →Generate text with AI
- →Classify sentiment
- →Summarize content
- →Answer questions
Communication
- →Send email
- →Post to Slack
- →SMS notification
- →Create calendar event
Data & APIs
- →Call HTTP API
- →Transform data
- →Search database
- →Parse JSON
Business Tools
- →Add to CRM
- →Create invoice
- →Update spreadsheet
- →Log to analytics
💡 Each automated column runs for every row automatically. Set it up once, and it works forever!
Manual Columns: You Enter the Data
These are like traditional spreadsheet columns. You type in the data yourself:
- Customer name
- Email address
- Priority level
- Notes
- Order ID
When to use: For information that only you know or that you want to enter manually.
Automated Columns: They Do the Work
These are the magic. They automatically:
- Generate text with AI ("Write a response to this customer question")
- Call APIs ("Look up company data from this email")
- Send messages ("Email this person with the result")
- Make decisions ("If score > 80, assign to sales team")
- Transform data ("Extract the domain from this email address")
- And 200+ more types...
When to use: For anything you want to happen automatically.
How Columns Work Together
Columns can depend on each other. One column waits for another to finish before starting.
How Columns Work Together
Columns execute in order based on dependencies. Watch the flow from left to right:
You enter the email address
Validate
Check if email is valid
Waits for: Email
Company Data
Look up company info
Waits for: Validate
Lead Score
Calculate lead quality
Waits for: Validate
Send to CRM
Add to sales system
Waits for: Company Data, Lead Score
📌 Manual Columns Go First
These have no dependencies. They're ready immediately when a row is created.
⚡ Automated Columns Execute in Order
Each waits for its dependencies to complete, then runs automatically.
💡 The Magic: It All Happens Automatically
You just enter an email address (Step 1). Everything else runs on its own, step by step, following the dependencies you set up. You can watch it happen in real-time!
This creates a pipeline: data flows from left to right, with each column doing its part.
💡 💡 Key Insight
You set this up once. Then every row that comes in flows through this pipeline automatically, forever.
No need to remember steps. No need to click buttons. It just happens.
4. Cells: Where Work Actually Happens
What is a Cell?
A cell is where a row meets a column. It's the intersection where work gets done.
Think of a spreadsheet: Row 5, Column C is a cell. Same here, but these cells:
- Store data
- Track their execution state
- Show you what's happening in real-time
- Store errors if something goes wrong
What's Inside a Cell?
Every cell contains:
Data: The actual value (text, number, JSON object, etc.)
State: What's happening right now
- Is it waiting?
- Is it processing?
- Is it done?
- Did it fail?
Timestamp: When it was last updated
Error Details (if failed): What went wrong and why
Understanding Cell States
This is crucial for watching your automation work:
Cell States: What You'll See
Every cell shows its current state with color and icon. Here's what each means:
Running
Cell is currently executing - AI is working, API is being called, or action is in progress
👉 Watch it work in real-time with the spinning gear icon
Queued
Cell is in the execution queue, will start processing soon
👉 Processing will start momentarily
Rate Limited
Temporarily throttled to stay within API rate limits
👉 Will automatically resume when quota is available
Scheduled
Waiting for an external event (webhook, email, or scheduled time)
👉 Will update automatically when the event occurs
Skipped (Condition failed)
The condition expression evaluated to false, so this cell was intentionally skipped
👉 This is normal - the column's condition wasn't met for this row
Skipped (Dependencies not present)
Required dependencies are not in completed state, so this cell cannot execute
👉 This is normal if upstream columns failed or were skipped
Unsuccessful
⚡ UNSUCCESSFULExecution failed with an error - needs your attention
👉 Click to see detailed error information and retry the cell
Completed
Cell successfully completed and data is ready
👉 Click to view the data produced by this cell
🎬 Watch a Cell Flow Through States
Watch cells transition: Running → Completed (success) or Unsuccessful (if errors occur)
Why States Matter
States give you X-ray vision into your automation.
Instead of wondering "Is it working?", you can see exactly what's happening:
- 10 rows waiting → They'll process when their dependencies are ready
- 5 rows processing → AI is working on them right now
- 50 rows complete → Finished successfully
- 2 rows failed → Click to see the error and fix it
💡 This Is What Makes It Different
Most automation tools are a black box. You click a button and hope it works.
Here, you see every step of every row in real-time. It's like watching your factory work.
Putting It All Together: Complete Example
Let's watch all four building blocks work together in a real automation.
Scenario: You have a "Lead Enrichment" table that automatically processes leads from your website form.
Complete Example: Watch It Work
Follow one lead through the entire automation pipeline
New Lead Arrives
Someone fills out your website form
→New row created with email: john@acme.com
| Column | State | Data |
|---|---|---|
| ✅complete | john@acme.com | |
| Validate | ⏸️waiting | — |
| Company Data | ⏸️waiting | — |
| Lead Score | ⏸️waiting | — |
| Assign To | ⏸️waiting | — |
🎯 What You Just Saw
- ✓One table managing your lead enrichment workflow
- ✓One row representing this specific lead
- ✓Five columns executing in order based on dependencies
- ✓Five cells transitioning through states automatically
- ✓Everything happens automatically once you set it up!
How They All Work Together
Let's recap the relationships:
The Hierarchy
1 Table
↓ contains
Many Rows
↓ each row has values for
Many Columns
↓ each column creates
1 Cell per RowThe Execution Flow
1. Row created (manually, import, or trigger)
↓
2. Columns with no dependencies start immediately
↓
3. As columns complete, dependent columns start
↓
4. Cells transition: Waiting → Processing → Complete
↓
5. You see it all happen in real-time
↓
6. When all columns done, row is completeThe Key Insight
💡 The Power of This Architecture
You design the columns once. Then every row that flows through gets the same treatment automatically.
It's like programming a robot assembly line: Set up the stations (columns), then send items through (rows). The robot does the work.
And unlike traditional robots, you can watch every step, see exactly where each item is, and jump in to help if something goes wrong.
What This Enables
Understanding this architecture means you can:
✅ Design better automations
- Know which operations should be separate columns
- Understand when to use dependencies
- Plan your data flow
✅ Debug faster
- See which cell failed
- Understand why (check dependencies)
- Retry or fix and move on
✅ Scale effortlessly
- 10 rows or 10,000 rows—same effort
- System handles parallelism automatically
- You just watch it work
✅ Build complex workflows
- Chain columns together
- Create branching logic
- Handle errors gracefully
- Integrate with any system
Common Patterns
Pattern 1: Data Enrichment
Manual Column (Email)
↓
Validation Column (Check if valid)
↓
Enrichment Column (Look up company)
↓
Scoring Column (Calculate quality)
↓
Action Column (Add to CRM)Use case: Lead qualification
Pattern 2: AI Processing
Manual Column (Question)
↓
AI Column (Generate answer)
↓
Review Column (Manual check)
↓
Action Column (Send email)Use case: Customer support
Pattern 3: Scheduled Processing
Cron Column (Runs daily at 9am)
↓
API Column (Fetch new data)
↓
Transform Column (Clean and format)
↓
Action Column (Update database)Use case: Daily data sync
Key Takeaways
If you remember nothing else, remember this:
📊 Tables = Workspaces
One table per distinct automation or workflow
📋 Rows = Items
Each row is one instance moving through your workflow
🔧 Columns = Actions
Each column is one step in your automation
📦 Cells = Execution
Where data and state meet—visible in real-time
What's Next?
Now that you understand the architecture, you're ready to see what it looks like in practice.
In the next section, we'll take a tour of the actual interface and show you where to find everything you just learned about.
Continue to Section 1.3: Your First Look at the Interface →
💡 📚 For Technical Users
This guide focuses on concepts, not technical details. If you're a developer looking for:
- API specifications
- Data models
- Technical architecture
- Integration guides
Check out the Technical User Guide instead.