17.1 Understanding Output Types

Output types tell Taibles what kind of data a column produces. When you specify output types, you get helpful suggestions as you work, catch mistakes before they become problems, and make your automation easier to understand. This section explains output types in practical terms.

Why Output Types Matter

Without Output Types

Without Types

Guessing Field Names

Column: company_data

Output: [Some data... but what exactly?]

⚠️ Problem:

What fields exist? Have to guess!
No autocomplete suggestions
Typos cause silent failures

Trying to Reference Field

Result:

(empty - typo in field name)

↑ Typo: "employe_count" should be "employee_count"

Without Types:

Trial and error to find field names
Typos cause silent failures
No validation until runtime
Hard to debug issues

When columns don't have clear output types, you have to guess what data they contain:

Trial and error: Try different field names until something works
Silent failures: Typos don't show errors, just empty results
No guidance: Can't tell what fields are available
Hard to debug: Problems only appear after running

With Output Types

With Types

Smart Suggestions

Column: company_data

Output Type: Company

Fields: name, domain, employee_count, industry, founded_year

When you reference this data:

✓ Autocomplete shows available fields:

name

domain

employee_count ← Selected ✓

industry

founded_year

With Types:

Autocomplete suggests correct fields
Typos caught immediately
Clear documentation of structure
Easy to debug issues

When columns have output types defined, Taibles helps you:

Smart suggestions: See available fields as you type
Instant error checking: Catch typos immediately
Clear documentation: Know exactly what data exists
Easy debugging: Understand data structure at a glance

Output types = Self-documenting automation

Understanding the Type System

Three Categories of Types

Taibles uses three main categories to organize types:

Simple Values

(Primitives)

📝Text

🔢Number

✓True/False

📅Date

Basic, single values

How Data is Organized

(Containers)

🎯SINGLE

📋COLLECTION

🗂️MAP

One value, multiple values, or structured

Complex Structures

(Structured Types)

🏢Model Types

Pre-built (Company, Contact)

✨Virtual Types

Your custom structures

Data with multiple related fields

1. Simple Values (Primitives)

Basic, single values that represent one piece of information:

Type	Examples	Use For
📝Text	"John Smith" "New York"	Names, descriptions, addresses, emails
🔢Number	42 3.14 -100	Counts, amounts, scores, quantities
✓True/False	true false	Yes/no, flags, status indicators
📅Date	2024-10-31 2024-01-15 10:30	Timestamps, deadlines, created dates

When to use:

Text: Names, descriptions, addresses, emails
Number: Counts, amounts, scores, quantities
True/False: Yes/no flags, status indicators
Date: Timestamps, deadlines, created dates

2. How Data is Organized (Containers)

Containers determine whether you have one value, multiple values, or structured data:

SINGLE

"John Smith"

One value

Use for:

Most columns (90%+ of cases)

COLLECTION

[0]"Email 1"

[1]"Email 2"

[2]"Email 3"

Ordered list

Use for:

Multiple items of same type

MAP

name:"John"

age:35

city:"NYC"

Named fields

Use for:

Structured data with named fields

SINGLE (Most Common)

Stores one value
Example: John Smith
Use for: 90%+ of columns

COLLECTION (Lists)

Stores multiple values in order
Example: [Email 1, Email 2, Email 3]
Use for: Multiple items of the same type

MAP (Structured Objects)

Stores named fields
Example: name: John, age: 35, city: NYC
Use for: Related information grouped together

3. Complex Structures

For data with multiple related fields:

🏢

Model Types

Pre-built

Examples:

Company

Contact

Order

User

✓Defined by system developers

✓Generated automatically

✓Available in autocomplete

✓Consistent across system

✨

Virtual Types

Custom

Your Structure:

lead_score: number

qualification: text

priority: text

notes: text

✓Define inline in column

✓No code required

✓Specify field names and types

✓Used for specific use cases

Pre-built Types (Model Types):

Defined by system developers
Examples: Contact, Company, Order
Consistent across all automations
Available in suggestions automatically

Custom Types (Virtual Types):

You define your own structure
No coding required
Specify field names and what type each field is
Perfect for unique data formats

How Types Work Together

The complete type specification combines a container with an output type:

Container	+	Output Type	=	Result
SINGLE	+	text	=	One text value
COLLECTION	+	text	=	List of text values
SINGLE	+	Company	=	One Company object
COLLECTION	+	Contact	=	List of Contact objects
MAP	+	(varies)	=	Key-value pairs with mixed types

Examples:

SINGLE text → One name
COLLECTION text → Multiple tags
SINGLE Company → One company record
COLLECTION Contact → List of contacts
MAP → Custom structured data

Setting Output Types

Automatic Type Detection

Most columns automatically know what type of data they produce:

🔮

Automatic Type Detection

Manual Input Columns:

Text Field✓ Auto

→ SINGLE text

Number Field✓ Auto

→ SINGLE number

True/False Toggle✓ Auto

→ SINGLE boolean

Multi-select✓ Auto

→ COLLECTION text

Calculated Columns with Known Outputs:

AI Generate Text✓ Auto

→ SINGLE text

Company Enrichment✓ Auto

→ SINGLE Company

HTTP GETVaries

→ Depends on API response

✓ You don't need to do anything

Type is set automatically for these columns

Manual input columns:

Text field → Text type ✓
Number field → Number type ✓
True/False toggle → True/False type ✓
Multi-select → List of text ✓

Calculation columns with known outputs:

AI Generate Text → Text type ✓
Web Request → Depends on API
Enrichment services → Company/Contact type ✓

You don't need to do anything - the type is set automatically.

Configuring Types Manually

Some columns need you to specify the output type:

JSON Columns

🗂️JSON

Configuring JSON Column Type

When storing custom structured data in JSON columns:

Add JSON column to your Taible
Click to edit the column
Set Output Type field (shown below)

Output Type

Common options:

💡 Tip

Setting the output type enables autocomplete and validation for this column's data!

When storing custom structured data in JSON columns:

Add JSON column to your Taible
Click to edit the column
Set Output Type field:
- Map<String, Object> - for general objects
- List<String> - for lists of text
- List<Number> - for lists of numbers
- YourCustomType - if you defined one

Example configurations:

Example 1

For metadata object:

Output Type:

Map<String, Object>

Data:

created_by: "admin"
version: 2
notes: "Important lead"

Example 2

For list of tags:

Output Type:

List<String>

Data:

["hot-lead", "enterprise", "follow-up-needed"]

Example 3

For list of scores:

Output Type:

List<Number>

Data:

[85, 92, 78, 95]

Custom Code Columns

⚙️Custom Code

Configuring Custom Code Type

When your code returns specific structured data:

Add Custom Code column
Write your code that returns data
Set Output Type to match what your code returns

Code Example:

// Your code here
return [
  score: 85,
  grade: 'A',
  passed: true
]

Output Type

Code returns object? → Map<String, Object>
Code returns number? → number
Code returns list? → List<String> or List<Number>

When your code returns specific structured data:

Add Custom Code column
Write your code that returns data
Set Output Type to match what your code returns:
- If code returns single number → Number
- If code returns object → Map<String, Object>
- If code returns array → List<String> (or appropriate type)

Example:

Code

return [
  score: 85,
  grade: 'A',
  passed: true
]

Output Type

Map<String, Object>

Now you can reference:

score→ 85

grade→ 'A'

passed→ true

Web/HTTP Request Columns

🌐HTTP Request

Configuring API Response Type

When calling external APIs:

Add Web/HTTP column
Configure your API call
Check the API response format
Set Output Type to match (optional but helpful)

Example API Response:

{
  "company": {
    "name": "Acme Corp",
    "employees": 500
  }
}

Output Type (optional)

When calling external APIs:

Add Web/HTTP column
Configure your API call
Check the API response format
Set Output Type to match (optional but helpful):
- Simple response → Map<String, Object>
- Known structure → Company, Contact, etc.

Benefits of Using Output Types

Benefit 1: Smart Suggestions

Without Types

company_data.[___]

No suggestions

Must memorize field names
Typos cause silent failures
Trial and error

With Types

company_data.

name

domain

employee_count

industry

Dropdown shows fields
Pick correct name
No typos!

Without types:

No suggestions when referencing fields
Must memorize all field names
Typos cause silent failures

With types:

Dropdown shows all available fields
Pick the correct field name
No typos, no guessing

Benefit 2: Catch Errors Early

Without Types

lead_score.total

❌ Error appears after running:

lead_score is a number, not an object!

Problem found too late ✗

With Types

lead_score.total

⚠️ Error shown immediately:

"number has no property 'total'"

Fix before running ✓

Without types:

Errors appear only after running
Hard to trace the cause
Wasted execution time

With types:

Errors shown immediately during setup
Clear explanation of the problem
Fix before running anything

Benefit 3: Self-Documenting

Without Types

Column: api_response

Output Type: (not specified)

❓ What fields does this have?

Have to run it and look at output ¯\\_(ツ)_/¯

With Types

Column: api_response

Map<String, Object>

Structure:

• status: text
• data: object
• timestamp: number

✓ Clearly documented!

Without types:

Must run column to see what it produces
No clear structure visible
Hard for team members to understand

With types:

Structure clearly documented
Fields and their types visible
Easy for anyone to understand

Benefit 4: Data Quality

With types, the system validates:

✓ Type Matching

employee_count is number (not text "500")

✓ Collection Validation

emails is list (not single email)

✓ Boolean Validation

active is true/false (not text "true")

✓ Field Presence

Required fields are present

With types, the system validates:

✓ Type matches expected format
✓ Required fields are present
✓ Field types are correct
✓ Lists contain expected elements

Examples:

employee_count is number (not text "500")
emails is list (not single email)
active is true/false (not text "true")

Working with Typed Data

Accessing Simple Values

Columncompany_name

TypeText

ResultAcme Corporation

The system automatically inserts the value where needed.

For columns that produce one value:

Column: company_name
Type: Text
Result: Acme Corporation

The system automatically inserts the value where needed.

Accessing Object Fields

Columncompany_data

TypeStructured object

Fields

• name

• domain

• employees

Pick which field to use:

Company name:Acme Corporation

Domain:acme.com

Employees:500

For columns that produce structured objects:

Column: company_data
Type: Structured object
Fields: name, domain, employees

When referencing this data, you can pick which field to use:

Company name: Acme Corporation
Domain: acme.com
Employees: 500

Accessing List Items

Columnemail_addresses

TypeList of text

Values

[0] Email 1

[1] Email 2

[2] Email 3

Access by position:

First email:Email 1

Second email:Email 2

Third email:Email 3

For columns that produce multiple values:

Column: email_addresses
Type: List of text
Values: [Email 1, Email 2, Email 3]

Access specific items by position:

First email: Email 1
Second email: Email 2
Third email: Email 3

Converting Between Types

Text to Number

Convert:

"42" → 42

Number to Text

Convert:

100 → "100"

List to Text (Join)

Convert:

["tag1", "tag2", "tag3"]

↓

"tag1, tag2, tag3"

Text to List (Split)

Convert:

"value1,value2,value3"

↓

["value1", "value2", "value3"]

Use Custom Code columns for these conversions.

Sometimes you need to convert data from one type to another:

Text to Number: Convert text like "42" to actual number 42

Number to Text: Convert number 100 to text "100"

List to Text (Join): Combine ["tag1", "tag2", "tag3"] into "tag1, tag2, tag3"

Text to List (Split): Break "value1,value2,value3" into ["value1", "value2", "value3"]

Use Custom Code columns for these conversions.

Virtual Types (Advanced)

What Are Virtual Types?

✨

Virtual Types

Custom

Virtual Types = Custom data structures you define inline

When to use:

API returns unique structure
Need specific format not available in pre-built types
One-off custom data layout
Don't want to create a system model

Virtual Types = Custom data structures you define inline

When to use:

API returns unique structure
Need specific format not available in pre-built types
One-off custom data layout
Don't want to create a system model

Defining a Virtual Type

API Response

{
  "full_name": "John Smith",
  "contact_score": 85,
  "is_qualified": true
}

Define Structure

full_name:text

contact_score:number

is_qualified:true/false

✓ Suggestions and validation work automatically!

Example: API returns custom lead data

API Response:

json

{
  "full_name": "John Smith",
  "contact_score": 85,
  "is_qualified": true
}

Define the structure:

Edit your column (Custom Code or HTTP)
Set Output Type to describe the structure:
- full_name: text
- contact_score: number
- is_qualified: true/false
Save

Now the system understands:

full_name exists and is text
contact_score exists and is a number
is_qualified exists and is true/false

Suggestions and validation work automatically!

Virtual Type Examples

Example 1: Nested Structure

Structure:

company

• name: text

• size: number

contacts: list of text

Access like:

Company name:[company name]

Company size:[company size]

First contact:[first contact]

Example 1: Nested Structure

Structure with company info and contact list:

company
- name: text
- size: number
contacts: list of text

Access like:

Company name: [company name]
Company size: [company size]
First contact: [first contact]

Example 2: List of Objects

List where each item has:

• email: text

• type: text (work/personal)

Data example:

Item 1: john@work.com (work)

Item 2: john@personal.com (personal)

Access like:

• First email address: [email]

• First email type: [type]

Example 2: List of Objects

List where each item has email and type:

Item 1: email + type
Item 2: email + type

Each item structure:

email: text
type: text (work/personal)

Access like:

First email address: [email]
First email type: [type]

Best Practices

Practice 1: Always Specify Types for JSON Columns

Don't

Column type: JSON

Output type: (not specified)

❌ No suggestions, no validation

Column type: JSON

Output type: Map<String, Object>

Or better: Define exact structure

✓ Suggestions work, validation active

Don't:

Column type: JSON
Output type: Not specified
Result: No suggestions, no validation

Do:

Column type: JSON
Output type: Map<String, Object>
Or better: Define exact structure
Result: Suggestions work, validation active ✓

Practice 2: Use Consistent Types

Within the same automation:

✅ Good:

All email columns: Text type
All score columns: Number type
All tag columns: List of text

❌ Bad:

Mix of different structures for same data

💡 Consistency makes maintenance easier and reduces confusion.

Within the same automation:

✅ All email columns: Text type
✅ All score columns: Number type
✅ All tag columns: List of text
❌ Mix of different structures for same data

Consistency makes maintenance easier and reduces confusion.

Practice 3: Document Custom Types

For custom structures, add clear descriptions:

What to document:

What the structure represents
What each field contains
Where the data comes from
When it was last updated
Link to API documentation if applicable

💡 Add this in column descriptions or a documentation column.

For custom structures, add clear descriptions:

What to document:

What the structure represents
What each field contains
Where the data comes from
When it was last updated
Link to API documentation if applicable

Add this in column descriptions or a documentation column.

Practice 4: Test Type Expectations

When defining types, always test:

Run column with sample data

Check the result structure

Click cell → View data

Verify structure matches type definition

Test references in other columns

Confirm suggestions work correctly

Adjust type if needed

When defining types, always test:

Run column with sample data
Check the result structure
Verify structure matches type definition
Test references in other columns
Confirm suggestions work correctly
Adjust type if needed

Practice 5: Start Simple, Add Complexity

Evolution path:

Phase 1Start simple

Column: company_name
Type: Text ✓

↓

Phase 2Add structure as needed

Column: company_data
Type: Map<String, Object> ✓

↓

Phase 3Refine with specifics

Column: company_data
Type: Company (Custom structure) ✓
Defined fields with specific types

⚡ Don't over-engineer from the start!

Add complexity only when needed.

Evolution path:

Phase 1: Start simple

Column: company_name
Type: Text ✓

Phase 2: Add structure as needed

Column: company_data
Type: Map<String, Object> ✓

Phase 3: Refine with specifics

Column: company_data
Type: Company (Custom structure) ✓
Defined fields with specific types

Don't over-engineer from the start! Add complexity only when needed.

Quick Reference

Simple Value Types

Type	Examples	Use For
📝Text	"John Smith" "New York"	Names, descriptions, addresses, emails
🔢Number	42 3.14 -100	Counts, amounts, scores, quantities
✓True/False	true false	Yes/no, flags, status indicators
📅Date	2024-10-31 2024-01-15 10:30	Timestamps, deadlines, created dates

Type	Example	Use For
Text	"John Smith"	Names, descriptions, emails
Number	42, 3.14	Counts, amounts, scores
True/False	true, false	Status, flags, conditions
Date	2024-10-31	Timestamps, deadlines

Container Types

Type	Example	Use For
SINGLE	"One value"	Most columns (default)
COLLECTION	["A", "B", "C"]	Lists, tags, multiple items
MAP	{name: "value"}	Structured data, objects

Type	Example	Use For
SINGLE	"One value"	Most columns (default)
COLLECTION	["A", "B", "C"]	Lists, tags, multiple items
MAP		Structured data, objects

Common Configurations

Output Type	Example	Use For
text	"Hello"	Text values
number	100	Numeric values
Map<String, Object>	{a: 1, b: 'x'}	General objects
List<String>	['a', 'b', 'c']	Lists of text
List<Number>	[1, 2, 3]	Lists of numbers
Custom	Your structure	Specific formats

Output Type	Example	Use For
Text	"Hello"	Text values
Number	100	Numeric values
`Map<String, Object>`	`{a: 1, b: "x"}`	General objects
`List<String>`	`["a", "b", "c"]`	Lists of text
`List<Number>`	`[1, 2, 3]`	Lists of numbers
Custom	Your structure	Specific formats

Summary

You now understand how output types work in Taibles:

✅ Three type categories:

Simple values (text, number, true/false, date)
Containers (SINGLE, COLLECTION, MAP)
Structured types (Model types, Virtual types)

✅ Setting types:

Most columns: Automatically determined ✓
JSON columns: Set manually
Custom Code: Match what your code returns
HTTP/Web: Match API response structure

✅ Benefits:

Smart suggestions (faster, fewer mistakes)
Early error detection (catch during setup)
Self-documentation (team understands structure)
Data quality validation (guaranteed correctness)

✅ Working with types:

Reference single values directly
Pick specific fields from objects
Access list items by position
Convert between types when needed

✅ Virtual Types (advanced):

Define custom structures inline
No system coding required
Specify field names and types
Enable suggestions for custom formats

✅ Best practices:

Always specify types for JSON columns
Use consistent types across automations
Document custom structures
Test type expectations
Start simple, add complexity as needed

Next Steps

You've completed Section 17.1: Understanding Output Types!

Continue to Chapter 18 to learn more practical automation features, or explore Section 17.2 if you want to dive deeper into custom data models (for advanced users).

Let's keep building your expertise! 📚

17.1 Understanding Output Types ​

Why Output Types Matter ​

Without Output Types ​

Guessing Field Names

With Output Types ​

Smart Suggestions

Understanding the Type System ​

Three Categories of Types ​

Simple Values

How Data is Organized

Complex Structures

1. Simple Values (Primitives) ​

2. How Data is Organized (Containers) ​

3. Complex Structures ​

Model Types

Virtual Types

How Types Work Together ​

Setting Output Types ​

Automatic Type Detection ​

Automatic Type Detection

Configuring Types Manually ​

JSON Columns ​

Configuring JSON Column Type

For metadata object:

For list of tags:

For list of scores:

Custom Code Columns ​

Configuring Custom Code Type

Web/HTTP Request Columns ​

Configuring API Response Type

Benefits of Using Output Types ​

Benefit 1: Smart Suggestions ​

Benefit 2: Catch Errors Early ​

Benefit 3: Self-Documenting ​

Benefit 4: Data Quality ​

With types, the system validates:

Working with Typed Data ​

Accessing Simple Values ​

Accessing Object Fields ​

Accessing List Items ​

Converting Between Types ​

Virtual Types (Advanced) ​

What Are Virtual Types? ​

Virtual Types

Defining a Virtual Type ​

Defining a Virtual Type

Virtual Type Examples ​

Best Practices ​

Practice 1: Always Specify Types for JSON Columns ​

Practice 2: Use Consistent Types ​

Within the same automation:

Practice 3: Document Custom Types ​

For custom structures, add clear descriptions:

Practice 4: Test Type Expectations ​

When defining types, always test:

Practice 5: Start Simple, Add Complexity ​

Evolution path:

Quick Reference ​

Simple Value Types ​

Container Types ​

Common Configurations ​

Summary ​

Next Steps ​

17.1 Understanding Output Types

Why Output Types Matter

Without Output Types

With Output Types

Understanding the Type System

Three Categories of Types

1. Simple Values (Primitives)

2. How Data is Organized (Containers)

3. Complex Structures

How Types Work Together

Setting Output Types

Automatic Type Detection

Configuring Types Manually

JSON Columns

Custom Code Columns

Web/HTTP Request Columns

Benefits of Using Output Types

Benefit 1: Smart Suggestions

Benefit 2: Catch Errors Early

Benefit 3: Self-Documenting

Benefit 4: Data Quality

Working with Typed Data

Accessing Simple Values

Accessing Object Fields

Accessing List Items

Converting Between Types

Virtual Types (Advanced)

What Are Virtual Types?

Defining a Virtual Type

Virtual Type Examples

Best Practices

Practice 1: Always Specify Types for JSON Columns

Practice 2: Use Consistent Types

Practice 3: Document Custom Types

Practice 4: Test Type Expectations

Practice 5: Start Simple, Add Complexity

Quick Reference

Simple Value Types

Container Types

Common Configurations

Summary

Next Steps