7.2 Creating Sub-Taibles

You understand what sub-taibles are and when to use them. Now let's create them! This section walks you through converting collection data into organized parent-child relationships.

How Sub-Taibles Are Created

Sub-taibles are created by converting a column that contains collection (array) data into a separate taible with parent-child relationships. You cannot create sub-taible columns from scratch - you need existing collection data first.

Common starting points:

Webhook delivers array data (order with line items)
API returns collection (contact with interactions)
Imported data with nested arrays
JSON column containing array values

💡 Key Concept

Sub-taibles start life as regular columns containing arrays. The "Convert into taible" feature transforms this array data into a proper parent-child relationship with its own taible.

Prerequisites: Understanding Collection Columns

Before converting to a sub-taible, you need a column containing collection data.

What is collection data?

Data that contains multiple items (an array)
Examples: list of products, set of emails, array of tasks
Shows in cells as [X Entries] with a count badge

Visual example:

Order ID	Customer	Line Items	Status
1001	John Smith	3 Entries	Completed
1002	Sarah Johnson	5 Entries	Completed
1003	Mike Williams	2 Entries	Completed

👆 See the "Line Items" column? Each cell shows a green badge with the number of entries. This indicates the column contains collection (array) data and is ready to convert into a sub-taible.

In the example above:

The "Line Items" column contains array data
Each cell shows how many items are in that array
The green badge indicates the data is ready to process
This column is ready to convert into a sub-taible

💡 Important

You can only convert columns that contain collection (array) data. Regular text or number columns cannot be converted into sub-taibles.

Converting a Collection Column to Sub-Taible

This is the only way to create sub-taibles. Follow these steps to transform your collection data into a proper parent-child relationship.

Step 1: Locate the Collection Column

Find the column in your taible that contains the array data you want to convert.

Visual cues to look for:

Cell displays [X Entries] with a count
Green or blue badge showing the number of items
Column type is typically JSON or Collection
Contains array data from webhooks or API calls

How to Identify Collection Columns

✅Collection Column

3 EntriesShows entry count
Green or blue badge
• Type: JSON or Collection
• Contains array data

❌Regular Column

• Shows plain text or numbers
• No badge with count
• Type: Text, Number, Date, etc.
• Cannot convert to sub-taible

Order ID	Customer	Line Items← This column	Total
1001	John	3 Entries	$95.00
1002	Sarah	5 Entries	$280.00

Hover over the column header and click the three-dot menu (⋮) on the right side.

Line Items

Step-by-step:

Hover your mouse over the "Line Items" column header
Two icons appear on the right side
Click the three-dot menu (⋮) - highlighted in yellow above
A dropdown menu will open with options

What you'll see:

Column configuration icon (⚙️) on the left
Three-dot menu (⋮) on the right
Hover highlights the header
Click the three-dot menu to open options

Step 3: Select "Convert into Taible"

In the dropdown menu, look for the "Convert into taible" option.

Note: The "Convert into taible" option only appears for columns that contain collection (array) data and haven't been converted yet.

💡 Don't See This Option?

The "Convert into taible" option only appears for columns that:

Contain collection (array) data
Have NOT already been converted to a sub-taible

If the option is missing, check that your column actually contains array data.

Step 4: Configure the Conversion

A modal dialog opens with conversion settings. Let's understand each option.

Convert into taible

Select ID column *

The ID property is used to check the existence of entries in the taible we'll create.

Destructure this Object into multiple columns for each property

When enabled, properties become separate columns in the parent taible instead of creating a separate sub-taible.

Delete orphaned entries

When enabled, entries in the sub-table that no longer appear in the parent list will be automatically soft-deleted.

Step 5: Select ID Property (Required for Object Arrays)

What it is: The property that uniquely identifies each item in your collection.

When it appears: Only when your array contains objects (not simple values).

Select ID column *

The ID property is used to check the existence of entries in the taible we'll create.

💡 Choosing the Right ID Property

Pick a unique identifier - No duplicates across items
Use stable values - Choose properties that won't change
Examples: sku, product_id, email
Avoid: Names, descriptions, or changing values

How to choose:

Pick a property that uniquely identifies each item
Good choices: id, sku, product_name, email
Avoid properties that might change
This helps the system track which items exist

Examples:

Your Data	Good ID Property	Why
Product list	`sku` or `product_id`	Unique identifier
Email list	`email`	Email addresses are unique
Task list	`task_id` or `name`	Identifies each task

💡 Simple Arrays

If your array contains simple values (like ["item1", "item2", "item3"]), this field won't appear. The system uses the values themselves as IDs.

Step 6: Choose Destructure Mode

The Toggle: "Destructure this Object into multiple columns for each property"

This is the most important choice when converting. Let's understand both options.

✅ Separate Sub-Taible Result

Parent Taible (Orders):

Order	Line Items
1001	[3 Entries] →

Click to navigate

Child Taible (Order Line Items):

Product	Qty	Price	Total
Product A	2	$10	$20
Product B	1	$20	$20

Option A: Unchecked (Separate Sub-Taible) ✅ Recommended

What happens:

Creates a completely separate child taible
Each array item becomes a row in the child taible
Click parent cell to navigate to children
Full automation capabilities on children

Use for:

One-to-many relationships (one order, many line items)
When you need to process child data
When children need calculated columns
Most use cases (99% of the time)

Example Result:

Parent Taible (Orders):
┌────────────────────────────────┐
│ Order │ Line Items            │
├───────┼───────────────────────┤
│ 1001  │ [3 Entries] →        │ ← Click to view
└────────────────────────────────┘

Child Taible (Order Line Items):
┌──────────────────────────────────┐
│ Product │ Qty │ Price │ Total   │
├─────────┼─────┼───────┼─────────┤
│ A       │ 2   │ $10   │ $20     │
│ B       │ 1   │ $20   │ $20     │
│ C       │ 3   │ $15   │ $45     │
└──────────────────────────────────┘

Option B: Checked (Destructured - Inline Columns)

What happens:

No separate child taible is created
Properties become new columns in the parent taible
All data visible inline
Limited to single items or fixed counts

Use for:

One-to-one relationships (person → address)
Very simple child data (2-3 fields)
When you want everything in one view
Rarely needed

Example Result:

Parent Taible (Customers):
┌────────────────────────────────────────────────┐
│ Customer │ Street      │ City    │ State │ Zip │
├──────────┼─────────────┼─────────┼───────┼─────┤
│ John     │ 123 Main St │ Seattle │ WA    │98101│
└────────────────────────────────────────────────┘

💡 When to Use Which?

Use Separate Sub-Taible (unchecked) when:

You have multiple items per parent (one-to-many)
You need to process or calculate on children
You want to add columns to children later
You need automation on child rows

Use Destructured (checked) when:

Each parent has exactly one child (one-to-one)
Child data is very simple (2-3 fields)
You want everything visible at once
No need for child automation

Default recommendation: Keep it unchecked for true sub-taibles.

Step 7: Select Properties to Include (If Destructuring)

When this appears: Only if you checked "Destructure" in Step 6.

Select columns to create

We'll create a column for each selected property of the source data type. Hold Ctrl/Cmd to select multiple.

Selected Properties Will Become:

product columnquantity columnprice column

Each selected property creates a new column in your parent taible.

Note: This field only appears when "Destructure" is checked. For separate sub-taibles (recommended), this step is skipped.

What it does:

Shows all properties from your collection data
You select which ones become columns
Each selected property creates a column in the parent taible

Example:

If your data looks like:

{
  "product": "Widget A",
  "sku": "WID-001",
  "quantity": 2,
  "price": 10.00,
  "notes": "Rush order"
}

You might select:

✅ product
✅ quantity
✅ price
❌ sku (not needed)
❌ notes (not needed)

This creates three columns: product, quantity, and price.

💡 Remember

This field only appears if you're destructuring. If you're creating a separate sub-taible (recommended), this step is skipped.

Step 8: Configure Orphaned Entry Deletion

The Toggle: "Delete orphaned entries"

Delete orphaned entries

When enabled, entries in the sub-table that no longer appear in the parent list will be automatically soft-deleted.

✅Checked (Recommended)

• Child rows removed when missing from parent
• Keeps data in sync
• Prevents stale data
• Good for: Dynamic data, orders, tasks

☐Unchecked

• Child rows persist even when removed
• Preserves history
• Good for: Audit trails, archives
• May accumulate old data

Example Scenario:

Order initially has 3 items: A, B, C

Later updated to only have items: A, B

✅ With delete orphaned:

Child taible: A, B

(Item C automatically removed)

☐ Without delete orphaned:

Child taible: A, B, C

(Item C still remains)

What it means:

When your parent data changes and items are removed from the array, should the corresponding child rows be deleted?

Checked (✅ Recommended):

Child rows are deleted when removed from parent
Keeps child taible in sync with parent
Prevents stale data
Good for: Order line items, task lists, dynamic data

Unchecked:

Child rows remain even if removed from parent
Useful for historical tracking
Good for: Audit trails, archived data

Example:

Imagine an order initially has 3 line items. Later, the order is updated and now only has 2 line items.

With "Delete orphaned entries" checked:

Before Update:
Child Taible: Item A, Item B, Item C

After Update:
Child Taible: Item A, Item B
(Item C was automatically deleted)

With it unchecked:

Before Update:
Child Taible: Item A, Item B, Item C

After Update:
Child Taible: Item A, Item B, Item C
(Item C remains, even though not in parent anymore)

💡 Best Practice

For most use cases, check this option. It keeps your data clean and ensures child rows always match what's in the parent.

Only uncheck if you specifically need to preserve historical child rows even after they're removed from the parent.

Step 9: Review and Convert

Before clicking "Convert", review your configuration:

Pre-Conversion Checklist

ID property selected

For object arrays: unique identifier chosen

Destructure mode chosen

Unchecked for one-to-many, checked for one-to-one

Properties selected (if destructuring)

Only appears when destructure is enabled

Orphaned entry deletion configured

Checked to auto-delete removed items (recommended)

✅ All green? You're ready to convert! Click the "Convert" button.

Double-check:

✅ ID property selected (if using object arrays)
✅ Destructure mode chosen correctly
✅ Properties selected (if destructuring)
✅ Orphaned entry deletion configured

Ready? Click the "Convert" button.

Step 10: Conversion in Progress

The system processes your data and creates the sub-taible relationship.

Converting to Sub-Taible...

Please wait while we process your data

Child taible created

Columns configured

Converting rows... (23/47)

Linking parent-child relationships

About 30 seconds remaining...

What's happening behind the scenes:

Creates a new child taible (if non-destructured)
Creates columns in the child taible
For each parent row:
- Iterates through the array items
- Creates a child row for each item
- Links child to parent
- Copies property values to columns

Time: Usually a few seconds to a minute, depending on data volume.

Step 11: Conversion Complete!

Success! Your collection column is now a sub-taible.

Conversion Successful!

Your collection column is now a sub-taible

Parent Rows

156

Child Rows Created

100%

Complete

What Changed:

✓ Cells now show X Entries with count
✓ Cells are clickable to view children
✓ Separate child taible created
✓ Parent-child relationships established

What changed:

Before conversion:

┌─────────────────────────────────┐
│ Order │ line_items (JSON)      │
├───────┼────────────────────────┤
│ 1001  │ [raw JSON array data]  │
└─────────────────────────────────┘

After conversion:

┌─────────────────────────────────┐
│ Order │ Line Items             │
├───────┼────────────────────────┤
│ 1001  │ [3 Entries] →         │ ← Click to view
└─────────────────────────────────┘

Visual changes:

Cell now shows [X Entries] with count
Cell is clickable (hover shows navigation button)
Badge indicates data is ready
Tooltip: "Click to view entries"

Step 12: Verify the Conversion

Click on the [3 Entries] badge in the first row to view the child taible.

Click on any cell with the entry count to navigate to the child taible:

Order ID	Customer	Line Items
1001	John Smith	3 Entries View →

Try hovering: When you hover over a sub-taible cell, a "View →" button appears. Click anywhere on the cell to navigate to the child taible.

What you'll see:

Child Taible View:

|Parent: Order #1001

Order Line Items

Product	Quantity	Unit Price	Line Total
Product A	2	$10.00	$20.00
Product B	1	$20.00	$20.00
Product C	3	$15.00	$45.00

All 3 entries shownFiltered to parent: Order #1001

Check for:

✅ Correct number of child rows
✅ Columns for each property
✅ Data populated correctly
✅ Parent context in header ("Parent: Order #1001")
✅ Back button to return to parent
✅ Ability to add more rows

Success! Your collection is now a fully functional sub-taible with parent-child relationships.

Understanding the Result

After conversion, you have a powerful parent-child relationship. Let's explore what you can do.

Parent View Features

Parent Taible Features

3 EntriesEntry Count Badge

Shows how many child rows exist for this parent

🎨Status Colors

Green - All children processed successfully
Blue - Children currently processing
Red - Error in child processing

🖱️Interactive Navigation

• Hover shows "View →" button
• Click anywhere on cell to navigate
• Opens filtered child view

In the parent taible:

Cell shows entry count: [3 Entries]
Badge color indicates status:
- Green: All children processed successfully
- Blue: Children currently processing
Hover shows navigation button: "View entries →"
Click navigates to filtered child view

Child View Features

Child Taible Features

Interactive example component

In the child taible:

Header shows parent context
Back button returns to parent
Add button creates new child rows
Full taible functionality (edit, delete, columns)
Can add calculated columns
Can set up automation

Adding More Child Rows

After creating a sub-taible, you'll often need to add more child rows. Here are three methods.

Method 1: Manual Entry

The simplest way - just add rows directly in the child taible.

Steps:

Click the sub-taible cell in the parent row

Click to Open Child Taible

Interactive example component

Child taible view opens

Empty Child Taible View

Interactive example component

Click the "Add" button (or press Enter)
Fill in the new row

Manual Entry Example

Interactive example component

Row saves automatically when you press Enter or click away
Add more rows by clicking "Add" again
Return to parent with the back button

Parent cell now shows updated count: [4 Entries]

💡 Quick Add

When viewing a child taible, press Enter to quickly add a new row. Press Tab to move between fields.

Method 2: Import from CSV

Import multiple child rows at once from a CSV file.

Steps:

Navigate to child taible view
Click "Upload CSV" button

CSV Import

Interactive example component

Select your CSV file

Example CSV format:

csv

product_name,quantity,unit_price,parent_order_id
"Product A",2,10.00,1001
"Product B",1,20.00,1001
"Product C",3,15.00,1002

Map CSV columns to taible columns

CSV Column Mapping

Interactive example component

Match parent identifier so rows link correctly
Import and rows are created

💡 Parent Linking

Your CSV must include a way to identify which parent each child belongs to. This is typically a parent ID column that matches your parent taible's ID.

Method 3: Automation Creates Children

The most powerful method - let automation create child rows automatically.

How it works:

When a parent row is created (e.g., from a webhook), a column in the parent taible can automatically create the child rows.

Example: E-commerce Order Processing

Automation Flow

Interactive example component

Setup:

Parent Taible: Orders

Trigger: Webhook from Shopify
Creates new order (parent row)

Parent Column: "Create Line Items"

Type: Custom Code or API node
Dependencies: Webhook data
Run Mode: DEPENDENT_ONCE (runs once when order arrives)

What happens:

Webhook delivers order with line items array
Parent row created for the order
"Create Line Items" column runs
For each item in the array, creates a child row
All line items automatically linked to parent

User sees:

Parent row: Order #1001 with [3 Entries] in Line Items column
Click to view: 3 line item rows already created and populated

💡 Automation Benefits

This method is powerful because:

No manual data entry needed
Child rows created instantly
Always in sync with webhook data
Scales to any number of items
Fully automated end-to-end

Configuring Child Columns

Child taibles are full taibles with all the same capabilities as parent taibles. You can add calculated columns, automation, conditions, and more.

Adding Columns to Children

From the child taible view:

Navigate to child taible (click parent cell)
Click "Add Column" just like in any taible

Add Child Column

Interactive example component

Select column type (Text, AI, API, Transform, etc.)
Configure the column normally

Child columns can:

✅ Access child row data (their own columns)
✅ Access parent data using [Parent Column Name]
✅ Have dependencies on other child columns
✅ Have conditions
✅ Use any node type (AI, API, Transform, etc.)

Example 1: Calculate Line Total

Let's add a calculated column to automatically compute the line total for each item.

Child Taible: Order Line Items

Add column: "Line Total"

Line Total Calculation

Interactive example component

Configuration:

Name: Line Total
Type: Transform Data
Formula: Multiply Quantity × Unit Price
Dependencies: Quantity, Unit Price
Run Mode: DEPENDENT_ALWAYS (recalculates when inputs change)

Result: Each child row automatically calculates its line total.

┌──────────────────────────────────────────┐
│ Product │ Quantity │ Unit Price │ Total │
├─────────┼──────────┼────────────┼───────┤
│ Widget  │ 2        │ $10.00     │ $20   │
│ Gadget  │ 1        │ $35.00     │ $35   │
│ Doohkey │ 5        │ $8.00      │ $40   │
└──────────────────────────────────────────┘

Example 2: Access Parent Data

Child columns can reference data from the parent row.

Scenario: Show the customer's shipping address on each line item for packing slips.

Child Taible: Order Line Items

Add column: "Shipping Address"

Parent Data Reference

Interactive example component

Configuration:

Name: Shipping Address
Type: Transform Data
Template: Reference [Shipping Address] from parent
Dependencies: (parent columns are automatically available)
Run Mode: DEPENDENT_ALWAYS

Result: Each child row "inherits" the parent's shipping address.

Use cases:

Shipping labels (need parent address)
Customer info (need parent customer name/email)
Order date (need parent order timestamp)
Any parent data needed on child rows

💡 Referencing Parent Data

In child columns, you can reference parent columns by name. The system automatically knows to look in the parent row.

Example references:

[Customer Name] - gets customer from parent
[Order Date] - gets date from parent
[Shipping Address] - gets address from parent

Navigating Between Parent and Child

Understanding navigation helps you work efficiently with sub-taibles.

From Parent to Child

Navigate Parent to Child

Interactive example component

In parent taible:

Find the sub-taible column
Look at the cell with [X Entries] badge
Hover over the cell (navigation button appears)
Click anywhere on the cell or the button

Result:

URL changes to include parent row ID
Child taible loads
Automatically filtered to show only this parent's children
Header shows parent context

Example URL:

/taibles/order_items_123?parentRow=row_1001

From Child to Parent

Navigate Child to Parent

Interactive example component

In child taible:

Look at the top of the page
Find "← Back to [Parent Taible Name]" button
Click the back button

Result:

Returns to parent taible view
Scrolls to the parent row you came from
Highlights the row briefly

Also available:

Breadcrumb navigation at the top
Click parent taible name in breadcrumbs
Browser back button works too

Direct Child Taible Access

Child taibles are real taibles with their own URLs. You can navigate directly without going through the parent.

Access: Use the taible switcher or direct URL

Direct Child Taible Access

Interactive example component

Shows: All child rows from all parents (not filtered)

┌──────────────────────────────────────────────┐
│ Order Line Items - All Entries               │
├──────────────────────────────────────────────┤
│ Parent Order │ Product │ Qty │ Price │ Total│
├──────────────┼─────────┼─────┼───────┼──────┤
│ 1001         │ A       │ 2   │ $10   │ $20  │
│ 1001         │ B       │ 1   │ $20   │ $20  │
│ 1001         │ C       │ 3   │ $15   │ $45  │
│ 1002         │ D       │ 2   │ $50   │ $100 │
│ 1002         │ E       │ 1   │ $80   │ $80  │
│ ...                                           │
└──────────────────────────────────────────────┘

Use when:

Need to see all items across all parents
Searching for specific child rows
Bulk operations on children
Reports across all children

Reconfiguring an Existing Sub-Taible

After creating a sub-taible, you can change one setting: orphaned entry deletion.

Reconfigure Sub-Taible

Interactive example component

To reconfigure:

Open column menu (three-dot menu on sub-taible column header)
Select "Reconfigure Subtaible"
Modal opens with one toggle:
- Delete Orphaned Entries (on/off)
Change the setting and click "Save"

💡 Limited Reconfiguration

You can only change the "Delete Orphaned Entries" setting after conversion. Other settings (ID property, destructure mode) are permanent.

If you need to change those settings, you'll need to:

Delete the sub-taible column
Re-convert the original collection data
Choose new settings

Understanding Destructured vs. Non-Destructured

Let's clarify this important choice with side-by-side comparisons.

Non-Destructured: Separate Sub-Taible ✅ Recommended

Structure:

Parent taible with sub-taible column
Completely separate child taible
Click parent cell to navigate
Full taible functionality on children

Non-Destructured Example

Interactive example component

Characteristics:

✅ Handles unlimited children (one-to-many)
✅ Children can have calculated columns
✅ Children can have automation
✅ Full flexibility
✅ Clean separation
✅ Easy to understand

Use for: Almost everything (99% of cases)

Examples:

Order → Line Items
Contact → Emails
Project → Tasks
Customer → Support Tickets

Destructured: Inline Columns

Structure:

No separate child taible
Child properties become parent columns
All data in one view
Limited functionality

Destructured Example

Interactive example component

Characteristics:

⚠️ Limited to fixed number (usually one)
❌ No calculated columns on child data
❌ No child automation
✅ See all data at once
✅ Simple for one-to-one relationships

Use for: Rarely needed

Examples:

Customer → Primary Address (single address)
User → Profile (single profile)
Product → Main Image (single image)

💡 Common Mistake

Don't destructure collections!

If you have multiple items per parent (one-to-many), always use non-destructured mode. Destructured mode is only for one-to-one relationships.

Wrong: Destructuring order line items (multiple items) Right: Non-destructured sub-taible for line items

Wrong: Destructuring email history (multiple emails) Right: Non-destructured sub-taible for emails

Viewing Sub-Taible Status

Sub-taible cells show different visual states depending on the data.

Cell States

Cell States Overview

Interactive example component

Green Badge (Completed):

All child rows processed successfully
Data is ready
Safe to view and use

Blue Badge (Processing):

Child rows currently being processed
Automation running
Wait or view partial results

Red Badge (Error):

Error occurred in child processing
Click to view error details
Fix errors in child taible

Gray Badge (Empty):

No child rows yet
Click to add first child
Sub-taible configured but empty

Best Practices

Follow these guidelines for successful sub-taibles.

✅ Do This

Best Practices: Do

Interactive example component

1. Name Child Taibles Clearly

Use descriptive names with context
"Order Line Items" not just "Items"
"Customer Support Tickets" not just "Tickets"
Makes navigation easier

2. Choose Non-Destructured (Default)

Unless you have a specific one-to-one use case
Gives you maximum flexibility
Can always simplify later if needed

3. Enable Orphaned Entry Deletion

For most use cases
Keeps child data in sync with parent
Prevents stale data

4. Test with One Parent First

Create the sub-taible
Add children to one parent row
Verify the structure works
Then expand to other parents

5. Add Calculated Columns to Children

Take advantage of child taible capabilities
Calculate totals, statuses, derived data
Use parent data when needed

❌ Avoid This

Best Practices: Don't

Interactive example component

1. Don't Create Too Many Levels

Maximum two levels: Parent → Child
Don't do: Parent → Child → Grandchild
Keep it simple and maintainable

2. Don't Destructure Collections

Only destructure one-to-one relationships
Not for one-to-many (multiple items)
You'll lose flexibility

3. Don't Forget to Choose ID Property

Pick a meaningful unique identifier
Not auto-generated unless necessary
Use business IDs when available

4. Don't Skip Testing

Always verify conversion with sample data
Check that children link correctly
Confirm navigation works

5. Don't Mix Children

Each child belongs to ONE parent
Don't try to share child rows
Create separate children if needed

Troubleshooting Common Issues

Issue: "Convert into Taible" Option Missing

Troubleshoot: Convert Option Missing

Interactive example component

Cause: Column doesn't contain collection data or already converted.

Solutions:

Check column data type - Must be array/collection
Verify cell contents - Should show [X Entries]
Already converted? - Look for sub-taible icon on header
Create new data - Add array data via webhook or API

Issue: No Child Rows After Conversion

Troubleshoot: No Child Rows

Interactive example component

Cause: Parent cells contain empty arrays.

Solutions:

Check parent data - Verify arrays have items
Re-run parent columns - Generate the array data again
Manually add children - Click cell and add rows
Check conversion log - Look for errors during conversion

Issue: Can't Click Cell to Navigate

Troubleshoot: Can't Navigate

Interactive example component

Cause: Cell is not a sub-taible column or data hasn't loaded.

Solutions:

Verify conversion - Check column has sub-taible icon
Refresh the page - Reload to update
Check permissions - Ensure you have access
Wait for processing - Blue badge means still processing

Issue: Child Rows Not Linked to Correct Parent

Troubleshoot: Wrong Parent

Interactive example component

Cause: ID property incorrectly configured or CSV import error.

Solutions:

Check ID property - Verify correct unique identifier chosen
Re-import with parent ID - Include parent reference in CSV
Manually reassign - Edit child rows to fix parent link
Reconvert - Delete and reconvert with correct settings

Real-World Example: E-Commerce Orders

Let's walk through a complete real-world example.

Scenario

You're building an e-commerce order management system. Orders come from Shopify webhooks with line items.

Webhook data structure:

json

{
  "order_id": "1001",
  "customer": "John Smith",
  "order_date": "2025-01-15",
  "line_items": [
    {
      "product_name": "Widget Pro",
      "sku": "WID-001",
      "quantity": 2,
      "unit_price": 49.99
    },
    {
      "product_name": "Gadget Plus",
      "sku": "GAD-002",
      "quantity": 1,
      "unit_price": 79.99
    }
  ]
}

Step-by-Step Implementation

E-Commerce Example

Interactive example component

1. Set up webhook to receive orders

Create Orders taible
Add Shopify webhook trigger
Webhook creates parent row for each order

2. Identify collection column

Column: "Line Items"
Contains: line_items array from webhook
Shows: [2 Entries] in each cell

3. Convert to sub-taible

Open column menu → "Convert into taible"
Select ID property: sku (unique product identifier)
Destructure: Unchecked (separate sub-taible for items)
Delete orphaned: Checked (remove items if order updated)
Click "Convert"

4. Result

Parent taible: Orders with clickable [2 Entries] cells
Child taible: Order Line Items with one row per item

5. Add calculated column to children

Column: "Line Total"
Formula: Quantity × Unit Price
Shows total for each line item

6. Add aggregation to parent

Column: "Order Total"
Formula: Sum of all child Line Totals
Shows total order amount

Complete flow:

Webhook → Order created (parent)
Line items array → Converted to child rows
Each child calculates line total
Parent aggregates to order total
Fully automated, no manual entry

💡 Automation Benefits

This setup means:

Orders automatically create parent row
Line items automatically create child rows
Totals automatically calculate
Everything stays in sync
No manual data entry required

Summary: Sub-Taible Creation Mastered

You now know how to create and manage sub-taibles!

Key Takeaways

✅ Converting Collection Columns:

Find column with array data ([X Entries] badge)
Open column menu → "Convert into taible"
Configure ID property, destructure mode, orphan deletion
System creates parent-child relationship

✅ Choosing Destructure Mode:

Unchecked (Separate sub-taible): For one-to-many relationships (recommended)
Checked (Destructured inline): For one-to-one relationships only

✅ Adding Child Rows:

Manual: Click cell → Add button → Enter data
CSV Import: Upload file with parent IDs
Automation: Parent columns create children automatically

✅ Configuring Children:

Add calculated columns to child taible
Reference parent data in child columns
Full automation capabilities
Works like any other taible

✅ Navigating:

Parent → Child: Click [X Entries] cell
Child → Parent: Back button or breadcrumbs
Direct access: Child taible has its own URL

✅ Best Practices:

Use non-destructured for collections
Enable orphaned entry deletion
Choose meaningful ID properties
Test with one parent first
Name child taibles clearly

Next Steps

You've mastered creating sub-taibles!

Section 7.3 will show you:

Parent-child data flow in detail
Aggregating child data to parent (sum, count, average)
Using child data in parent calculations
Real workflows with complete examples
Advanced sub-taible patterns

Let's make parent and child taibles work together! 🚀

7.2 Creating Sub-Taibles ​

How Sub-Taibles Are Created ​

💡 Key Concept

Prerequisites: Understanding Collection Columns ​

💡 Important

Converting a Collection Column to Sub-Taible ​

Step 1: Locate the Collection Column ​

How to Identify Collection Columns

Step 2: Open the Column Menu ​

Step 3: Select "Convert into Taible" ​

💡 Don't See This Option?

Step 4: Configure the Conversion ​

Convert into taible

Step 5: Select ID Property (Required for Object Arrays) ​

💡 Choosing the Right ID Property

💡 Simple Arrays

Step 6: Choose Destructure Mode ​

✅ Separate Sub-Taible Result

Option A: Unchecked (Separate Sub-Taible) ✅ Recommended ​

Option B: Checked (Destructured - Inline Columns) ​

💡 When to Use Which?

Step 7: Select Properties to Include (If Destructuring) ​

Selected Properties Will Become:

💡 Remember

Step 8: Configure Orphaned Entry Deletion ​

Example Scenario:

💡 Best Practice

Step 9: Review and Convert ​

Pre-Conversion Checklist

Step 10: Conversion in Progress ​

Converting to Sub-Taible...

Step 11: Conversion Complete! ​

Conversion Successful!

Step 12: Verify the Conversion ​

Order Line Items

Understanding the Result ​

Parent View Features ​

Parent Taible Features

Child View Features ​

Child Taible Features

Adding More Child Rows ​

Method 1: Manual Entry ​

Click to Open Child Taible

Empty Child Taible View

Manual Entry Example

💡 Quick Add

Method 2: Import from CSV ​

CSV Import

CSV Column Mapping

💡 Parent Linking

Method 3: Automation Creates Children ​

Automation Flow

💡 Automation Benefits

Configuring Child Columns ​

Adding Columns to Children ​

Add Child Column

Example 1: Calculate Line Total ​

Line Total Calculation

Example 2: Access Parent Data ​

Parent Data Reference

💡 Referencing Parent Data

Navigating Between Parent and Child ​

From Parent to Child ​

Navigate Parent to Child

From Child to Parent ​

Navigate Child to Parent

Direct Child Taible Access ​

Direct Child Taible Access

Reconfiguring an Existing Sub-Taible ​

Reconfigure Sub-Taible

💡 Limited Reconfiguration

Understanding Destructured vs. Non-Destructured ​

Non-Destructured: Separate Sub-Taible ✅ Recommended ​

Non-Destructured Example

Destructured: Inline Columns ​

Destructured Example

💡 Common Mistake

Viewing Sub-Taible Status ​

Cell States ​

Cell States Overview

7.2 Creating Sub-Taibles

How Sub-Taibles Are Created

Prerequisites: Understanding Collection Columns

Converting a Collection Column to Sub-Taible

Step 1: Locate the Collection Column

Step 2: Open the Column Menu

Step 3: Select "Convert into Taible"

Step 4: Configure the Conversion

Step 5: Select ID Property (Required for Object Arrays)

Step 6: Choose Destructure Mode

Option A: Unchecked (Separate Sub-Taible) ✅ Recommended

Option B: Checked (Destructured - Inline Columns)

Step 7: Select Properties to Include (If Destructuring)

Step 8: Configure Orphaned Entry Deletion

Step 9: Review and Convert

Step 10: Conversion in Progress

Step 11: Conversion Complete!

Step 12: Verify the Conversion

Understanding the Result

Parent View Features

Child View Features

Adding More Child Rows

Method 1: Manual Entry

Method 2: Import from CSV

Method 3: Automation Creates Children

Configuring Child Columns

Adding Columns to Children

Example 1: Calculate Line Total

Example 2: Access Parent Data

Navigating Between Parent and Child

From Parent to Child

From Child to Parent

Direct Child Taible Access

Reconfiguring an Existing Sub-Taible

Understanding Destructured vs. Non-Destructured

Non-Destructured: Separate Sub-Taible ✅ Recommended

Destructured: Inline Columns

Viewing Sub-Taible Status

Cell States

Best Practices

✅ Do This

❌ Avoid This

Troubleshooting Common Issues

Issue: "Convert into Taible" Option Missing

Issue: No Child Rows After Conversion

Issue: Can't Click Cell to Navigate

Issue: Child Rows Not Linked to Correct Parent

Real-World Example: E-Commerce Orders

Scenario

Step-by-Step Implementation

Summary: Sub-Taible Creation Mastered

Key Takeaways

Next Steps