5.1: Understanding Collections
You've built automations that handle individual things—one customer message, one lead, one order. But what about when you need to work with multiple related items?
Imagine an order with 5 products, an email with 3 attachments, or a customer with 10 past conversations. These are collections—lists of items that belong together.
The challenge: How do you automatically process each item in a list while keeping everything organized?
The solution: Sub-tables! They're Taibles' way of handling collections, and they make complex data relationships surprisingly simple.
💡 What You'll Learn
By the end of this section, you'll understand:
- ✅ What collections are and when you need them
- ✅ Why processing items individually matters
- ✅ How sub-tables solve the collections problem
- ✅ The parent-child relationship pattern
5.1.1: What Is a Collection?
A collection is simply a list of multiple items that belong to one thing.
Think of everyday examples:
- 🛒 An order with multiple products
- 📧 An email with several attachments
- 💬 A customer with their conversation history
- 📊 A report with hundreds of data points
The pattern: ONE parent thing has MANY child items.
Real-World Collection Examples
Order with 5 Items
Email with 3 Attachments
Customer with 10 Past Conversations
Report with 100 Data Points
Each of these scenarios has the same challenge: How do you work with EACH item while keeping track of what they belong to?
💡 💡 Think of It Like This
A shopping cart is a perfect analogy for collections:
- The cart itself is the parent (one order)
- The items in the cart are the children (multiple products)
- You need to process each item separately (check stock, calculate price)
- But you also need the total for the whole cart!
5.1.2: Why Process Items Individually?
Sometimes you need to DO something with EACH item in a collection.
Here are common scenarios:
Scenario 1: Order Processing
You receive an order with 5 products. For each product, you need to:
- Check if it's in stock
- Calculate the line total (quantity × price)
- Update inventory levels
- Then calculate the order total from all line totals
Scenario 2: Email Attachments
You receive an email with 3 attachments. For each attachment, you need to:
- Scan for viruses
- Extract text content
- Categorize the document type
- Then summarize all attachments in one response
Scenario 3: Customer History
A customer contacts support. You want to check their past 10 conversations and:
- Extract common issues from each conversation
- Calculate satisfaction scores for each
- Identify patterns across all conversations
- Then provide a summary to the support agent
The pattern: Process each item → Gather results → Use combined information
Why This Matters
Processing Items One by One
Contains 3 items
Process EACH item separately
Item 1: Laptop
→ Check stock: ✓ In stock
→ Calculate price: $1,299.00
Item 2: Mouse
→ Check stock: ✓ In stock
→ Calculate price: $29.99
Item 3: Keyboard
→ Check stock: ✓ In stock
→ Calculate price: $79.99
All items processed! ✓
Total: $1,408.98
Without processing items individually:
- ❌ Can't check stock for each product
- ❌ Can't scan each attachment separately
- ❌ Can't analyze each conversation
- ❌ Can't calculate accurate totals
- ❌ Hard to handle items with different requirements
With individual item processing:
- ✅ Each item gets the right treatment
- ✅ Results roll up to parent automatically
- ✅ Easy to track progress
- ✅ Simple to debug issues
- ✅ Flexible for complex logic
💡 🎯 The Power of Collections
By processing items individually, you can handle complex scenarios that would be nearly impossible otherwise. An order with 100 items? No problem—each one gets processed automatically!
5.1.3: The Solution: Sub-Tables
A sub-table is like a mini-table that lives inside a cell of your main table.
Here's the magic:
- The parent table has your main entities (orders, customers, emails)
- The sub-table has the related items (order items, conversations, attachments)
- Each child row knows which parent row it belongs to
- You can add columns and automations to both tables!
Visual: How Sub-Tables Look
Sub-Tables: A Mini-Table Inside a Cell
Order Items:
What you see:
- Main table shows orders
- The "Items" column shows item count: "3 items"
- Click the arrow to expand and see the sub-table
- Sub-table shows individual items with their own columns
- Each item processes independently
- Results combine back to the parent
The Parent-Child Relationship
Parent → Children Relationship
PARENT ROW
Order #1234
Customer: Sarah Chen
CHILD ROWS (in sub-table)
ITEM 1
Laptop
Qty: 1
$1,299.00
ITEM 2
Mouse
Qty: 1
$29.99
ITEM 3
Keyboard
Qty: 1
$79.99
Each child row belongs to one parent row
Key concepts:
- One parent can have many children
- Each child belongs to exactly one parent
- Parent and children can both have columns and automations
- Data flows both directions (parent to child, child to parent)
5.1.4: How Sub-Tables Work
Think of sub-tables as two connected tables:
1. Parent Table (Main Table)
- Regular table like you've been using
- Has a special "sub-table column" that shows item count
- Parent-level columns work with parent-level data
- Example: Order total, customer name, order date
2. Child Table (Sub-Table)
- A separate table, but linked to parent rows
- Each row automatically connected to a parent row
- Child-level columns work with individual items
- Example: Product name, quantity, price, line total
The Connection:
- Sub-table column in parent links to child table
- Each child row has a hidden "parent" reference
- You can access parent data from child rows
- You can aggregate child data up to parent
💡 💡 Like Folders and Files
Think of it like your computer's file system:
- Folder = Parent row (one order)
- Files inside = Child rows (order items)
- The folder "contains" the files
- Each file "knows" which folder it's in
- You can see folder properties AND file properties
5.1.5: When Do You Need Sub-Tables?
Use sub-tables whenever you have a one-to-many relationship:
✅ Perfect for Sub-Tables
E-commerce:
- Orders → Line items
- Carts → Products
- Invoices → Invoice lines
Communication:
- Emails → Attachments
- Conversations → Messages
- Campaigns → Recipients
Projects:
- Projects → Tasks
- Customers → Support tickets
- Reports → Data points
Data Processing:
- Batches → Records
- Forms → Form fields
- Surveys → Survey responses
❌ When NOT to Use Sub-Tables
You probably DON'T need sub-tables if:
- Each row only has one of something (one customer name, one email address)
- The data is a simple value, not a list
- Items don't need individual processing
- There's no parent-child relationship
💡 ⚠️ Keep It Simple
Don't use sub-tables just because you can. Only use them when you genuinely need to process multiple related items. For simple data, regular columns work great!
5.1.6: What's Coming Next
Now that you understand what collections are and why sub-tables are the solution, you're ready to build your first sub-table!
In the next section (5.2: Creating Sub-Tables), you'll:
- 🛠️ Create your first sub-table step-by-step
- 🎯 Process order items automatically
- 📊 Calculate totals from child data
- ✨ See the power of sub-tables in action
Get excited! Sub-tables might seem complex at first, but once you see them in action, you'll wonder how you ever lived without them.
💡 🎉 You're Ready!
You now understand:
- ✅ Collections are lists of related items
- ✅ Processing items individually is often necessary
- ✅ Sub-tables are mini-tables inside cells
- ✅ Parent-child relationships connect the data
- ✅ When to use (and when NOT to use) sub-tables
Let's build one! →
What You've Learned
Congratulations! You now understand the concept of collections and why they matter:
📝 Collections are lists of multiple items that belong together
🔄 Processing items individually lets you handle each item with its own logic
📊 Sub-tables are the solution—mini-tables inside cells
👨👧👦 Parent-child relationships connect main entities to their related items
🎯 Know when to use sub-tables (one-to-many relationships)
Next up: Let's actually build a sub-table and see the magic happen! You'll create an order processing system that handles multiple items automatically.
Previous: 4.3 Conditional ActionsNext: 5.2 Creating Sub-Tables