6.1 Understanding Triggers

So far, you've been creating rows manually or importing them from CSV files. But what if rows could create themselves automatically when something happens?

A customer submits a form → New row appears
An email arrives in your support inbox → New ticket row created
It's 9 AM Monday → New weekly report row generated
Someone places a Shopify order → New order row processed
A file is uploaded to Google Drive → New row with file data

This is the power of triggers—and they transform your taibles from manual tools into fully automated systems.

The Concept: From Manual to Automatic

What is a Trigger?

Simple definition: A trigger automatically creates new rows in your taible when specific events happen.

The fundamental difference:

Columns process existing rows (transform data, call APIs, send emails)
Triggers create new rows (bring data into your taible)

Think of it this way:

Without triggers:

You → Manually add rows → Columns process them

With triggers:

Event happens → Trigger creates row → Columns process it automatically

Why Triggers Matter

❌

Without Triggers

•

You must manually check for new submissions

•

Copy data from emails/forms by hand

•

Create rows one by one

•

Easy to miss events or make mistakes

•

Only works during business hours

•

Can't handle high volumes

Time per event: 2-3 minutes

Maximum capacity: ~30 events/day

✅

With Triggers

•

Automatic detection of new events

•

Data captured instantly and accurately

•

Rows appear automatically

•

Never miss an event

•

Works 24/7, even while you sleep

•

Handles unlimited volume effortlessly

Time per event: Instant

Maximum capacity: Unlimited

The Power of End-to-End Automation

Before triggers (semi-automated):

Customer fills form
You manually add row with customer data ← Still manual!
Automation enriches and processes
Email sent automatically

After triggers (fully automated):

Customer fills form
Trigger creates row automatically ← Zero intervention!
Automation enriches and processes
Email sent automatically

💡 Real-World Impact

Support ticket system: Email arrives → Ticket created → Classified → Assigned → Response drafted → Human reviews

Order processing: Shopify order → Row created → Validated → Fulfilled → Tracking sent → Customer notified

Lead generation: Form submitted → Lead created → Enriched → Scored → Routed to sales rep

How Triggers Work: The Listener Pattern

The Mental Model

Think of triggers as event listeners that sit in the background, constantly watching for specific events:

How Triggers Work: Data Flow

Event Happens

Someone submits a form, places an order, or sends an email

↓

Trigger Catches Event

Your trigger detects the event and captures the data

↓

New Row Created

A new row appears in your taible automatically

↓

Data Written to Column

Event data is saved to the column you specified

↓

Automation Runs

Your columns process the new row automatically

Zero manual work required! Everything happens automatically.

Key characteristics:

Always running: Triggers are background processes
Event-driven: Only act when something happens
Data mapping: Event data gets saved to a column you choose
Automatic: No human intervention needed

Finding Triggers in the Interface

When viewing any taible, you'll see two trigger-related buttons in the toolbar:

Tip: Click "Add Trigger" to open the trigger selection window and start configuring your automation.

"Add Trigger" - Opens a modal to connect a new service
"3 Triggers" - Shows how many triggers are active and opens the management sidebar

Adding Your First Trigger

Step 1: Browse Available Services

Click the "Add Trigger" button to open the trigger selection modal:

Add Trigger

Choose a service to automatically create rows when events occur

Step 2: Configure the Trigger

After selecting a service, a configuration sidebar appears on the right:

📝

Trigger Name

Typeform Trigger

Automatically creates a new row whenever someone submits your Typeform. The form response data will be written to the column you specify below.

⚠️

Token Cost: Each trigger event consumes API tokens based on the data size

Configuration fields (varies by service):

Trigger Name: Give it a descriptive name like "Contact Form Submissions"
Service-specific settings:
- For forms: Which form to monitor
- For email: Which inbox and folder
- For Shopify: Which event type (orders, customers, etc.)
Write Data To Column: Choose which column receives the event data
- Usually a JSON-type column
- The trigger will save all event data here

💡 Token Cost Warning

Some triggers show a token cost warning. This means each event will consume API tokens based on the data size. This is normal for services that send large amounts of data.

Click "Add Trigger" when you're ready, and the trigger starts listening immediately!

Managing Active Triggers

Click the "3 Triggers" button in the toolbar to open the management sidebar:

Triggers (3)

Manage automatic row creation

📝

Contact Form Submissions

Active

Typeform • Last event: 2 minutes ago

▼

Trigger Name

Configuration

Form: Contact Form

Column: form_data

✉️

Support Email Monitor

Active

Gmail • Last event: 1 hour ago

▶

🛍️

New Shopify Orders

Warning

Shopify • Last event: 3 days ago

▶

What you'll see:

Collapsed view (default):

Trigger icon and name
Service type
Status badge (Active/Warning/Error)
Last event time

Expanded view (click to expand):

Edit trigger name
View/edit configuration
Save Changes button
Remove button (red, dangerous action)

💡 Status Indicators

🟢 Active: Working normally, processing events
🟡 Warning: Some issues but still working
🔴 Error: Not working, needs attention (expired auth, disconnected)

Understanding Service Triggers

Taibles come with 80+ pre-built service integrations that automatically create rows when events happen in external platforms.

80+ Pre-Built Service Integrations

📝

Forms & Surveys

Typeform, Google Forms, JotForm, Tally

Process form submissions instantly

🛍️

E-commerce

Shopify, WooCommerce, Stripe, Square

Automate order and payment processing

☁️

CRM Systems

Salesforce, HubSpot, Pipedrive, Zoho

Sync leads and customer data

✉️

Email

Gmail, IMAP, Outlook

Monitor inboxes for support tickets

📅

Calendar

Google Calendar, Calendly, Acuity

Track meetings and appointments

📁

Cloud Storage

Google Drive, Dropbox, OneDrive

React to file uploads and changes

💬

Communication

Slack, Teams, Discord, Telegram

Respond to messages and activity

📧

Marketing

Mailchimp, ActiveCampaign, Facebook Ads

Track campaigns and leads

All triggers follow the same pattern: choose service → configure → events create rows automatically

The Key Insight

You don't work with generic trigger "types"—instead, you choose the specific service you want to connect (Typeform, Shopify, Gmail, etc.), and the system handles the technical details.

All triggers follow the same pattern:

You add a trigger and configure it
The trigger listens for events from that service
When an event occurs → New row created automatically
Event data is written to the column you specified
Your automation columns process the new row

Popular Service Triggers

Form & Survey Triggers

When to use: Automatically process form submissions

Available services:

Typeform: Form submissions with answer data
Google Forms: Response received
JotForm: Form submission events
Tally: Form responses
Gravity Forms & WPForms: WordPress form submissions

What you get: All form response data including answers, respondent info, submission time, and metadata

Example flow:

User submits Typeform contact form
    ↓
Typeform trigger creates new row
    ↓
Trigger writes form data to specified column
    ↓
Columns extract email, enrich lead, score, add to CRM

E-commerce Triggers

When to use: Automate order processing and customer management

Available services:

Shopify: Orders, products, customers, inventory
WooCommerce: Orders, products, customers
Stripe: Payments, subscriptions, invoices
Square: Payments and transactions

What you get: Complete order/payment data including customer info, items, amounts, status, shipping details

Event types available:

Order events: created, updated, paid, fulfilled, canceled
Customer events: created, updated
Product events: created, updated, deleted
Inventory events: item sold, stock updated

Email Triggers

When to use: Process incoming emails automatically (perfect for support tickets, inquiries)

Available services:

IMAP: Monitor any IMAP-compatible inbox (Gmail, Outlook, custom servers)
Gmail: Gmail-specific features with Google API
Microsoft Outlook: Outlook email events

What you get: Full email data including:

Sender email address and name
Subject line
Email body (text and HTML)
Attachments (downloaded and stored)
Timestamp
Thread ID (for tracking conversations)

Example flow:

Email arrives at support@company.com
    ↓
IMAP trigger detects new email
    ↓
New row created with email data
    ↓
Columns classify issue (AI), determine priority, assign to team, draft response

💡 Advanced Email Features

Filtering: Only trigger for emails matching criteria (specific sender, subject keywords, folder)
Folders: Monitor specific folders (not just INBOX)
Mark as read: Automatically mark emails as read after processing
Thread tracking: Match replies to existing rows for conversation continuity

Scheduled Triggers

What it is: Time-based trigger that creates rows on a schedule

How it works:

You set a schedule (every hour, daily at 9 AM, weekly on Monday, etc.)
When time arrives → Trigger creates new row
Row creation triggers your automation pipeline

Common use cases:

Daily reports: Every morning at 8 AM, create row that pulls yesterday's metrics
Periodic syncs: Every hour, create row that checks for updates in external system
Batch processing: Every night at midnight, create row that processes accumulated data
Monitoring: Every 15 minutes, create row that checks system health

Example flow:

9:00 AM Monday arrives
    ↓
Scheduled trigger fires
    ↓
New row created
    ↓
Columns fetch sales data, calculate metrics, generate report, email to team

Scheduling options:

Every X minutes/hours/days
Specific time daily (e.g., 9:00 AM)
Specific day of week (e.g., Monday)
Specific day of month (e.g., 1st of month)
Custom expressions for complex schedules

CRM Triggers

When to use: Sync CRM events and automate sales workflows

Available services:

Salesforce: Leads, opportunities, contacts, accounts, cases
HubSpot: Deals, contacts, companies, form submissions
Pipedrive: Deals, activities, contacts, organizations
Close: Leads, opportunities, activities
Zoho CRM: Leads, contacts, deals

What you get: CRM record data with all standard and custom fields, relationships, and activity history

Example: New lead created in Salesforce → Row created → Automation enriches with company data, scores lead, assigns to rep based on territory

Calendar & Scheduling Triggers

When to use: Automate meeting and appointment workflows

Available services:

Google Calendar: Events created, updated, deleted
Calendly: Booking events (scheduled, canceled, rescheduled)
Acuity Scheduling: Appointments scheduled

What you get: Event details including time, attendees, location, meeting links, custom fields

Example: New Calendly meeting booked → Row created → Automation sends pre-meeting materials, adds to CRM, creates follow-up task

Cloud Storage & File Triggers

When to use: React to file uploads and changes in cloud storage

Available services:

Google Drive: Files created, updated, deleted in specific folders
Dropbox: File and folder changes
Microsoft Excel: Spreadsheet changes
Google Docs: Document changes

What you get: File metadata (name, type, size, modified date), download links, and optionally file contents

Example flow:

Partner uploads daily_orders.csv to shared Google Drive folder
    ↓
Google Drive trigger detects new file
    ↓
Row created with file metadata
    ↓
Columns download file, parse CSV, process each order

Communication Platform Triggers

When to use: Respond to messages and team activity

Available services:

Slack: Messages, mentions, reactions, channel events
Microsoft Teams: Messages and channel activity
Discord: Server and channel events
Telegram: Bot messages and updates

What you get: Message content, sender info, channel, timestamps, attachments

Example: Customer messages Slack support channel → Row created → Automation logs conversation, checks for urgent keywords, notifies on-call team if needed

Marketing Platform Triggers

When to use: React to marketing events and campaign activities

Available services:

Mailchimp: Subscriber events, campaign activity
ActiveCampaign: Contact events, automations, deals
Klaviyo: Customer events, email activity
Facebook Lead Ads: New lead captured
LinkedIn Ads: Lead generation form submissions
Google Ads: Conversion events

How Triggers Actually Work: Behind the Scenes

Behind the scenes, triggers use two technical methods to detect events. You don't need to configure this—it's handled automatically.

Webhook-Based Triggers (Most Common)

How it works:

When you add a trigger, the system registers with the external service
Service sends instant notification when event occurs
Trigger receives notification and creates row immediately

Characteristics:

Real-time: Sub-second latency
Efficient: No unnecessary checking
Reliable: No missed events
Examples: Typeform, Shopify, Stripe, Salesforce, WooCommerce

Polling-Based Triggers (Some Services)

How it works:

System periodically checks service for new events (every 1-15 minutes)
When new events found, creates rows for each
Tracks what's been processed to avoid duplicates

Characteristics:

Slight delay: 1-15 minute lag (still automatic)
Necessary: When service doesn't support instant notifications
Reliable: Eventually consistent
Examples: Google Forms, YouTube, Instagram, some older platforms

You'll never need to choose between these methods—the system automatically uses the best option available for each service.

Trigger Data Flow: Where Event Data Goes

Key concept: Triggers write event data to a specific column in the new row that you choose during configuration.

The Data Mapping

Trigger fires (event occurs in external service)
New row created with:
- Unique row ID (automatically generated)
- Creation timestamp
- System user ID (for triggered rows)
Event data written to your designated column:
- You choose which column during trigger setup
- Usually a JSON-type column
- Contains entire event payload with all data from the service
Other columns process:
- Columns that depend on the trigger column execute automatically
- Extract needed fields from the data
- Continue automation pipeline

Example: Typeform Trigger Data Flow

Configuration:

Trigger service: Typeform
Form: Contact Form
Data written to column: form_data (JSON type)

When form submitted:

New row appears with:

Row ID: automatically generated
Created: current timestamp
Column form_data contains:

json

{
  "eventType": "form_response",
  "responseId": "xyz789",
  "submittedAt": "2024-10-24T15:42:10Z",
  "answers": [
    {
      "question": "What is your email?",
      "answer": "john@acme.com"
    },
    {
      "question": "Company name",
      "answer": "Acme Corp"
    },
    {
      "question": "Message",
      "answer": "Interested in your product"
    }
  ],
  "hiddenFields": {
    "source": "website",
    "campaign": "summer2024"
  }
}

Other columns can now access this data:

Column email extracts the email answer
Column company extracts the company name
Column enrichment uses the email to look up additional data

Multiple Triggers on One Taible

Can you have multiple triggers on one taible? Yes!

Use Case: Multi-Source Lead Generation

Taible: Lead Pipeline

Trigger 1: Typeform (website form)

Writes to: lead_source_data column
Also sets: source_type = "typeform"

Trigger 2: IMAP (inquiries@company.com)

Writes to: lead_source_data column
Also sets: source_type = "email"

Trigger 3: LinkedIn Ads (lead form submissions)

Writes to: lead_source_data column
Also sets: source_type = "linkedin"

Result: All leads flow into same taible, regardless of source, processed by same automation pipeline. Your columns can check source_type to handle source-specific logic if needed.

When to use multiple triggers:

✅ Different sources, same process
✅ Multiple entry points
✅ Unified pipeline
✅ Consolidated reporting

When to use separate taibles:

❌ Completely different processes
❌ Different column structures needed
❌ No shared logic

Trigger Reliability and Error Handling

What Happens if Trigger Fails?

Most triggers automatically retry:

Services typically retry failed deliveries (3-5 times with delays)
Error logged in trigger activity (visible in management sidebar)
No row created until successful delivery
You're notified if permanently fails

Email triggers (IMAP):

Email remains unread in inbox
Trigger retries on next check (typically every minute)
Won't mark as read until successfully processed
Ensures no emails are lost

💡 Built-in Reliability

Most services guarantee eventual delivery. The system handles retries and queuing automatically—you don't need to worry about the technical details.

Monitoring Trigger Health

Status indicators (shown in management sidebar):

🟢 Active: Listening normally, events being processed
🟡 Warning: Some errors, but mostly working
🔴 Error: Not working, needs attention (auth expired, connection lost)
⚪ Inactive: Turned off by you

Activity information shows:

Successful triggers (row created, when, what data)
Failed triggers (what went wrong, error message)
Trigger frequency (how often firing)
Last trigger time
Recent event history

Triggers vs. Manual Row Creation: When to Use Each

Use Triggers When:

✅ Events happen automatically

Forms submitted by users
Emails arrive in inbox
Orders placed on e-commerce platform
Files uploaded to cloud storage
CRM records updated

✅ Need immediate/real-time processing

Support tickets need instant response
Orders need immediate fulfillment
Leads need instant follow-up

✅ High volume of events

Hundreds or thousands of events per day
Can't manually keep up
Need consistent processing

✅ 24/7 operation required

Events happen outside business hours
Can't be present all the time
Global operations across timezones

✅ Consistency and reliability critical

Every event must be captured (no missed opportunities)
No human error or forgetfulness
Audit trail of all events

Use Manual Row Creation When:

✅ One-time or infrequent data imports

Migrating data from old system
Loading historical data
Occasional bulk updates

✅ Ad-hoc processing and testing

Testing automation logic
Processing special cases
One-off data analysis

✅ Human judgment needed before processing

Not every event should automatically create a row
Need to review and validate before processing
Approval workflows

✅ Very small volumes

A few rows per week
Manual entry faster than trigger setup
Data source doesn't support automation

The Trigger-Column Relationship

Critical understanding: Triggers and columns work together to create complete automation

Trigger (Creates rows) + Columns (Processes rows) = Complete Automation

Example: Support Ticket System

Trigger (IMAP - support@company.com):

Monitors inbox for new emails
Creates row per email received
Writes email data to email_data column

Columns (Process ticket automatically):

sender_email: Extracts sender from email data
subject: Extracts subject line
body_text: Extracts email content
category: AI classifies email content
priority: AI determines urgency (high/medium/low)
assigned_to: Auto-assigns based on category and team availability
response_draft: AI generates suggested response
ticket_sent: Manual checkbox - human reviews draft and approves

Result: Email arrives → Automatic ticket creation → AI processes and drafts response → Human reviews and sends

💡 Neither Alone is Enough

Trigger without columns = Rows created but nothing happens with them
Columns without trigger = Automation works but requires manual row creation

Both are needed for true end-to-end automation!

Common Trigger Patterns

Pattern 1: Event → Process → Store

Example: Form submission → Enrich → CRM

Typeform Trigger (form submitted)
    ↓
Row created with form data
    ↓
Columns enrich (company data, lead score)
    ↓
Column syncs enriched data to Salesforce

Pattern 2: Email → Classify → Route → Respond

Example: Support ticket routing

IMAP Trigger (new email to support@)
    ↓
Row created with email content
    ↓
Columns classify (issue type, priority)
    ↓
Column assigns to appropriate team member
    ↓
Column drafts response (AI)
    ↓
Human reviews and sends

Pattern 3: Order → Validate → Fulfill → Notify

Example: E-commerce order processing

Shopify Trigger (order created)
    ↓
Row created with order data
    ↓
Columns validate (inventory check, fraud detection)
    ↓
Column creates shipping label
    ↓
Column sends confirmation email to customer
    ↓
Column updates order status in Shopify

Pattern 4: File Upload → Parse → Batch Process

Example: Daily partner data feed

Google Drive Trigger (CSV file uploaded)
    ↓
Row created with file reference
    ↓
Column downloads and parses CSV
    ↓
Column creates child rows (one per CSV line) in sub-taible
    ↓
Child rows processed independently
    ↓
Parent row aggregates results

Key Concepts Summary

Before moving to setup (Section 6.2), make sure you understand:

✅ What triggers are: Automatic row creators that listen for events in external services

✅ Why they matter: Enable fully automated, end-to-end workflows without manual intervention

✅ Service-specific approach: 80+ pre-built integrations for popular platforms (not generic trigger types)

✅ How they work:

Listen for events (instant or periodic checking)
Create rows automatically
Write data to column you specify
Columns process the data

✅ Where data goes: Triggers write to a column you choose (usually JSON type)

✅ Reliability: Built-in retries, error handling, and activity logging

✅ Monitoring: Status indicators show trigger health (Active/Warning/Error)

✅ Relationship with columns: Triggers create rows, columns process them—both needed for complete automation

Real-World Impact

Before triggers:

Manual semi-automated process:
1. Check email/form/service for new events
2. Copy relevant data
3. Manually add row to taible
4. Automation runs from there
5. Repeat for each event

Time: 2-3 minutes per event
Availability: Only during work hours
Errors: Frequent (copy/paste mistakes, forgetting to check)
Scale: 20-30 events/day maximum
Missed events: Common (forgot to check, off sick, vacation)

After triggers:

Fully automated process:
1. Event happens in external service
2. Trigger creates row automatically
3. Automation runs completely
4. Done

Time: Instant (sub-second)
Availability: 24/7/365
Errors: Rare (only if automation logic has issues)
Scale: Unlimited (handles 1 or 10,000 events/day)
Missed events: Zero (every event captured)

The transformation: From semi-automated (human-in-the-loop for data entry) to fully automated (human-in-the-loop only for decisions/approvals).

Next Up: Setting Up Your First Trigger

Now that you understand what triggers are and how they work, Section 6.2 will walk you through:

Step-by-step guide to adding your first trigger
Choosing the right service for your use case
Configuring trigger settings in detail
Testing triggers before going live
Monitoring and managing active triggers
Troubleshooting common issues

Let's make your taibles fully automatic! 🚀

6.1 Understanding Triggers ​

The Concept: From Manual to Automatic ​

What is a Trigger? ​

Why Triggers Matter ​

Without Triggers

With Triggers

The Power of End-to-End Automation ​

💡 Real-World Impact

How Triggers Work: The Listener Pattern ​

The Mental Model ​

How Triggers Work: Data Flow

Event Happens

Trigger Catches Event

New Row Created

Data Written to Column

Automation Runs

Finding Triggers in the Interface ​

The Toolbar Buttons ​

Adding Your First Trigger ​

Step 1: Browse Available Services ​

Add Trigger

Categories

Typeform

Shopify

Google Forms

Salesforce

Gmail

Calendly

Step 2: Configure the Trigger ​

💡 Token Cost Warning

Managing Active Triggers ​

The Triggers Sidebar ​

Triggers (3)

Contact Form Submissions

Support Email Monitor

New Shopify Orders

💡 Status Indicators

Understanding Service Triggers ​

80+ Pre-Built Service Integrations

Forms & Surveys

E-commerce

CRM Systems

Email

Calendar

Cloud Storage

Communication

Marketing

The Key Insight ​

Popular Service Triggers ​

Form & Survey Triggers ​

E-commerce Triggers ​

Email Triggers ​

💡 Advanced Email Features

Scheduled Triggers ​

CRM Triggers ​

Calendar & Scheduling Triggers ​

Cloud Storage & File Triggers ​

Communication Platform Triggers ​

Marketing Platform Triggers ​

How Triggers Actually Work: Behind the Scenes ​

Webhook-Based Triggers (Most Common) ​

Polling-Based Triggers (Some Services) ​

Trigger Data Flow: Where Event Data Goes ​

The Data Mapping ​

Example: Typeform Trigger Data Flow ​

Multiple Triggers on One Taible ​

Use Case: Multi-Source Lead Generation ​

Trigger Reliability and Error Handling ​

What Happens if Trigger Fails? ​

💡 Built-in Reliability

Monitoring Trigger Health ​

Triggers vs. Manual Row Creation: When to Use Each ​

Use Triggers When: ​

Use Manual Row Creation When: ​

The Trigger-Column Relationship ​

Example: Support Ticket System ​

💡 Neither Alone is Enough

Common Trigger Patterns ​

Pattern 1: Event → Process → Store ​

Pattern 2: Email → Classify → Route → Respond ​

6.1 Understanding Triggers

The Concept: From Manual to Automatic

What is a Trigger?

Why Triggers Matter

The Power of End-to-End Automation

How Triggers Work: The Listener Pattern

The Mental Model

Finding Triggers in the Interface

The Toolbar Buttons

Adding Your First Trigger

Step 1: Browse Available Services

Step 2: Configure the Trigger

Managing Active Triggers

The Triggers Sidebar

Understanding Service Triggers

The Key Insight

Popular Service Triggers

Form & Survey Triggers

E-commerce Triggers

Email Triggers

Scheduled Triggers

CRM Triggers

Calendar & Scheduling Triggers

Cloud Storage & File Triggers

Communication Platform Triggers

Marketing Platform Triggers

How Triggers Actually Work: Behind the Scenes

Webhook-Based Triggers (Most Common)

Polling-Based Triggers (Some Services)

Trigger Data Flow: Where Event Data Goes

The Data Mapping

Example: Typeform Trigger Data Flow

Multiple Triggers on One Taible

Use Case: Multi-Source Lead Generation

Trigger Reliability and Error Handling

What Happens if Trigger Fails?

Monitoring Trigger Health

Triggers vs. Manual Row Creation: When to Use Each

Use Triggers When:

Use Manual Row Creation When:

The Trigger-Column Relationship

Example: Support Ticket System

Common Trigger Patterns

Pattern 1: Event → Process → Store

Pattern 2: Email → Classify → Route → Respond

Pattern 3: Order → Validate → Fulfill → Notify

Pattern 4: File Upload → Parse → Batch Process

Key Concepts Summary

Real-World Impact

Next Up: Setting Up Your First Trigger