15.3 Alerts and Notifications

Stay ahead of problems by building custom alert workflows that notify you when something important happens in your Taibles.

---

Overview: How Alerts Work in Taibles

Traditional Monitoring vs. Taibles

Traditional monitoring tools:

• Fixed dashboard with preset alerts
• Limited customization options
• One-size-fits-all thresholds
• Separate from your workflow

Taibles:

• Build your own alert workflows using columns
• Use any notification channel (Email, Slack, Telegram, etc.)
• Completely customizable alert logic
• Integrated directly into your data processing

Key concept: In Taibles, alerts are just columns that send messages when certain conditions are met. You have complete control over when and how they trigger.

---

What You Can Build

Alert types available today:

✅ Error alerts - Get notified when a column fails ✅ Threshold alerts - Alert when metrics exceed limits (error rate >10%) ✅ Cost alerts - Know when spending exceeds budget ✅ Inactivity alerts - Detect when data stops flowing ✅ SLA alerts - Catch service level breaches ✅ Custom alerts - Any condition you can define

Notification channels:

• ✅ Email (SMTP)
• ✅ Slack
• ✅ Telegram
• ✅ Microsoft Teams
• ✅ WhatsApp
• ✅ SMS (via Twilio)
• ✅ Webhooks (connect to any service)

---

Part 1: Setting Up Your First Alert

Let's start with a simple example: get an email when a column fails.

Step 1: Connect Your Email Account

Before you can send alerts, you need to connect an email account.

Navigate to Settings → Accounts → Add Account

Create SMTP Email Account

Account Name

SMTP Server Settings

SMTP Server

Port

Security

Authentication

Username / Email

Password

Tip: For Gmail, use an App Password instead of your regular password. Learn more

Sender Information

From Address

From Name

Test Connection

Verify your settings work before saving

What you're configuring:

• Account Name: A label to identify this email account (e.g., "Company Alerts")
• SMTP Server: Your email provider's server (gmail uses smtp.gmail.com)
• Port: Usually 587 for TLS or 465 for SSL
• Security: Choose TLS (recommended) for encrypted connection
• Username/Password: Your email login credentials
• From Address: The email address that will send alerts
• From Name: How the sender name appears

Gmail Users

For Gmail accounts, you'll need to create an "App Password" instead of using your regular password. Go to your Google Account settings → Security → App Passwords to generate one.

---

Step 2: Add an Email Alert Column

Now add a column that sends an email when another column fails.

In your Taible, click "Add Column" → Browse → Communication → SMTP Email

Configure Email Alert

Email Account

Choose which email account to send from

To (Recipient Email)

Subject

Email Message

ALERT: Lead enrichment has failed Row Details: Lead Email: [Lead Email] Company: [Company Name] Error Details: Column: Company Enrichment Error: [Error Message] Please investigate immediately.

Use [Column Name] to insert data automatically

Preview

Email will be sent to admin@company.com when this column runs

Configuration explained:

• Email Account: Select the account you just created
• To: Who receives the alert (can be multiple addresses separated by commas)
• Subject: The email subject line - make it clear and actionable
• Message: The email body with all the context needed to investigate

Using data placeholders:

Instead of showing technical template syntax, you can insert data using simple placeholders:

• [Column Name] - Insert the value from any column
• [Customer Email] - Insert customer information
• [Error Message] - Insert the error that occurred

The system automatically replaces these with actual data when the email is sent.

---

Step 3: Configure When to Send

You don't want alerts every time - only when there's actually an error.

In the same configuration, scroll down to "Run Configuration"

When to Send Alert

Only send alert when condition is met

Alert will only be sent if the condition evaluates to true

Build your condition:

When

Result[Company Enrichment] is empty

How conditions work

The alert will check this condition before sending. If the condition is false, the alert is skipped. This prevents alert fatigue and ensures you only get notified when it matters.

Advanced: Edit condition expression directly

Condition Expression

How conditions work:

1. Enable the condition toggle - Turn on conditional execution

2. Build your condition - Use the visual builder to create rules like:

   • When Company Enrichment → is empty or has error
   • When Lead Score → is greater than → 80
   • When Email Validation → equals → invalid

3. The alert checks first - Before sending, it evaluates the condition

4. Only sends if true - If the condition is false, the alert is skipped

Prevent Alert Fatigue

Always use conditions to limit when alerts fire. Getting too many alerts makes people ignore them - only alert on what truly matters!

---

Step 4: Set Dependencies

Tell the alert which column to watch.

In Run Configuration → Dependencies

1. Click "Add Dependency"
2. Select the column you want to monitor (e.g., "Company Enrichment")
3. Choose "Once" for run mode (alert only runs once when the column completes)

How it works:

• When the monitored column finishes running, your alert column automatically checks
• If the condition is met, the email is sent
• If not, nothing happens

---

Part 2: Alert Patterns for Common Scenarios

Pattern 1: Simple Error Alerts

Use case: Get notified immediately when any column fails

Simple Error Alert Flow

1

Column Runs

Company Enrichment column processes new lead

2

Failure Detected

Column fails with an error

3

Alert Triggered

Email alert column checks condition

4

Email Sent

Admin receives failure notification

Email Preview

To: admin@company.com

⚠️ Lead Enrichment Failed

ALERT: Lead enrichment has failed

Row Details:

• Lead Email: john@example.com

• Company: Acme Corp

Error Details:

• Column: Company Enrichment

• Error: API rate limit exceeded

Please investigate immediately.

Setup summary:

1. Add Email or Slack column
2. Set condition: [Column Name] is empty or [Column Name] has error
3. Add the column you want to monitor as a dependency
4. Set run mode to "Once"

Best for: Critical operations that can't fail (payment processing, customer notifications)

---

Pattern 2: Error Rate Threshold Alerts

Use case: Alert when too many failures occur (e.g., >10% error rate)

This pattern requires a separate monitoring Taible that checks your main Taible periodically.

How it works:

1. Create a "Monitor" Taible - A separate Taible just for monitoring
2. Add a CRON trigger - Runs every 15 minutes to check
3. Add columns that:
   • Pull data from your main Taible
   • Calculate error rate (failed cells / total cells)
   • Check if rate exceeds threshold
   • Send alert if threshold exceeded

Visual flow:

Every 15 minutes
  → Check main Taible
    → Calculate: 15 failed / 100 total = 15% error rate
      → 15% > 10% threshold
        → Send Slack alert to #team

Best for: Detecting systemic problems vs. individual failures

---

Pattern 3: Slack Alerts for Critical Failures

Use case: Instant team notification in Slack for high-priority issues

Configure Slack Alert

Slack Workspace

Channel

Choose which channel receives the alert

Alert Message

🚨 CRITICAL FAILURE Taible: Order Processing Row: [Order ID] Customer: [Customer Name] Failed Column: Payment Processing Error: [Error Message] Action Required: Review payment failure and contact customer View Order: [Link]

Use [Column Name] to insert data

• Use **bold** and *italic* for formatting

• Use @channel or @here to notify team

Message Preview

TA

Taibles Alert Bot

🚨 CRITICAL FAILURE Taible: Order Processing Row: [Order ID] Customer: [Customer Name] Failed Column: Payment Processing Error: [Error Message] Act...

Setup steps:

1. Settings → Accounts → Add Account → Choose Slack
2. Authorize your Slack workspace (you'll be redirected to Slack)
3. Add Column → Slack in your Taible
4. Select channel where alerts should go (e.g., #alerts, #support)
5. Write your message with formatting:
   • Use **bold** for emphasis
   • Use *italic* for details
   • Use @channel to notify everyone (use sparingly!)
   • Use emojis for severity: 🚨 critical, ⚠️ high, ⚡ medium

Best for: Team coordination on time-sensitive issues

---

Pattern 4: Cost Threshold Alerts

Use case: Get notified when daily spending exceeds your budget

Setup approach:

1. Create a Cost Monitor Taible with a daily CRON trigger
2. Add a column that checks your usage from Settings → Usage History
3. Calculate if current spending exceeds your daily budget
4. If yes, send alert via Email or Slack

Example alert:

💰 DAILY COST ALERT

Date: 2024-11-19
Tokens Used: 150,000
Estimated Cost: $45.00
Budget: $30.00

Exceeded by: $15.00

Action: Review usage in Settings → Usage History

Best for: Budget control and preventing surprise bills

---

Pattern 5: Inactivity Alerts

Use case: Detect when a trigger stops receiving data (webhook broken, integration disconnected)

Setup approach:

1. Create a Trigger Health Monitor Taible with CRON (runs every 6 hours)
2. Add columns that:
   • Pull the most recent row from your trigger-driven Taible
   • Calculate hours since last update
   • Check if hours > 24 (your threshold)
   • Send alert if inactive too long

Example alert:

⚠️ TRIGGER INACTIVITY ALERT

Taible: Form Submissions
Trigger: Typeform Webhook
Last Activity: 28 hours ago
Expected: New data every 1-2 hours

Possible Issues:
- Webhook disconnected at source
- Trigger configuration problem
- No new submissions (verify at source)

Action: Check trigger status and webhook configuration

Best for: Ensuring critical data pipelines stay healthy

---

Pattern 6: SLA Breach Alerts

Use case: Alert when support tickets exceed response time limits

Setup in Support Tickets Taible:

1. Add column: Time Since Received (calculates hours since ticket arrived)
2. Add column: SLA Breached (checks if time > your SLA limit)
3. Add Slack alert column:
   • Condition: [SLA Breached] equals true
   • Dependency: SLA Breached column
   • Run mode: "Always" (re-checks whenever ticket is updated)
   • Message mentions the assigned person: @[Assigned To]

Why "Always" run mode?

The alert needs to check every time the ticket is updated. If a ticket has been open for 3 hours and someone adds a note, the alert should check again to see if it's still breached.

Best for: Maintaining service quality and catching overdue items

---

Part 3: Managing Notification Channels

Email Alerts (SMTP)

When to use Email:

• ✅ Formal notifications requiring documentation
• ✅ Alerts to non-technical stakeholders
• ✅ Detailed reports with formatting
• ✅ External recipients who aren't in your team chat

Best practices:

• Clear subject lines: Include Taible name, severity, and issue type
• Full context in body: All information needed to investigate
• Direct links: Link to the specific row in Taibles
• Multiple recipients: CC relevant team members
• Avoid spam: Use conditions to limit frequency

Example subject lines:

• ✅ 🚨 CRITICAL: Payment Failed - Order #12345
• ✅ ⚠️ High Error Rate Alert - Lead Processing
• ❌ Error (too vague)
• ❌ Something went wrong (not actionable)

---

Slack Alerts

When to use Slack:

• ✅ Real-time team notifications
• ✅ Alerts requiring immediate discussion
• ✅ High-frequency updates (handled better than email)
• ✅ Collaborative troubleshooting

Formatting tips:

🚨 **CRITICAL: Payment Processing Failure**

**Order**: #ORD-12345
**Customer**: John Smith (john@example.com)
**Amount**: $299.99

**Error**: Credit card declined (insufficient funds)
**Time**: 2024-11-19 14:23:45

**Action Required**: Contact customer for alternate payment

[View Order in Taibles]

@sales-team

Best practices:

• Use emojis for severity: 🚨 critical, ⚠️ high, ⚡ medium, ℹ️ info
• Use bold for important info
• Include direct links to investigate
• @mention specific people or teams
• Save @channel for true emergencies

---

Telegram Alerts

When to use Telegram:

• ✅ Mobile-first notifications
• ✅ Personal alerts for individual users
• ✅ Lower-volume, high-priority messages
• ✅ International teams (Telegram widely available)

Setup process:

1. Create a Telegram bot via @BotFather
2. Get your bot token (looks like: 110201543:AAHdqTcvCH1vG...)
3. Get your chat ID by messaging your bot and visiting: https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates
4. Add account in Taibles with token and chat ID
5. Add Telegram column and configure your message

---

Webhook Alerts

When to use Webhooks:

• ✅ Connect to services not directly supported (PagerDuty, Opsgenie)
• ✅ Custom internal dashboards
• ✅ Integration with existing monitoring tools
• ✅ Trigger actions in other systems

Setup:

1. Add Column → Web (HTTP Request)
2. Method: POST
3. URL: Your webhook endpoint
4. Headers: Add authentication (Authorization, API keys)
5. Body: JSON with alert details

Example webhook body:

{
  "alert_type": "error",
  "severity": "critical",
  "taible": "Order Processing",
  "row_id": "[Row ID]",
  "error_message": "[Error Message]",
  "timestamp": "[Current Time]"
}

---

Part 4: Alert Management Best Practices

Practice 1: Avoid Alert Fatigue

The problem: Too many alerts → people ignore them → real issues get missed

Solutions:

1. Use severity levels

🚨 CRITICAL: Immediate action required
   → @channel in Slack
   → Email to manager
   → High-priority notification sound

⚠️ HIGH: Urgent but not emergency
   → @here in Slack
   → Email to team
   → Standard notification

⚡ MEDIUM: Should review soon
   → Normal Slack message
   → No email

ℹ️ INFO: For awareness only
   → Log to monitoring Taible
   → No notification

2. Batch similar alerts

❌ Bad: 50 individual alerts for 50 failed cells
✅ Good: 1 alert: "50 cells failed in last hour - error rate 25%"

3. Use time windows

Alert once when threshold exceeded
Wait 1 hour before next alert
Even if problem continues

4. Create escalation paths

0-10 min: Log to monitoring Taible
10-30 min: Send Slack message
30-60 min: Email to team lead
60+ min: Page on-call engineer

---

Practice 2: Include Actionable Context

❌ Bad alert:

Error occurred

Why it's bad: No information to act on

✅ Good alert:

Payment Processing Failed

Order: #12345
Customer: john@example.com
Error: Credit card declined (insufficient funds)
Amount: $299.99
Payment Method: Visa ending in 1234

Action: Contact customer for alternate payment method

[View Order in Taibles]

Why it's good: Complete context, clear action, direct link

---

Practice 3: Test Your Alerts

Before going live:

1. ✅ Create test row in your Taible
2. ✅ Manually trigger the alert condition
3. ✅ Verify delivery to the correct channel
4. ✅ Check formatting looks correct (no broken placeholders)
5. ✅ Verify links work and go to the right place
6. ✅ Test at different times (business hours and off-hours)
7. ✅ Confirm escalation works as designed

Testing checklist:

• □ Alert sends to correct recipient/channel
• □ Subject/title is clear and descriptive
• □ Message includes all necessary context
• □ Data placeholders are replaced correctly
• □ Links work and are accessible
• □ Formatting displays correctly (bold, emoji, etc.)
• □ Alert only fires when condition is met
• □ Alert doesn't fire when condition is false

---

Practice 4: Document Alert Response

For each alert, write down:

What it means:

This alert fires when payment processing fails due to declined card

What to check first:

1. Is it a customer-side issue (insufficient funds) or system issue (API down)?
2. Check payment processor status page
3. Review recent similar failures for patterns

How to resolve:

If customer-side:
  → Email customer with payment update link
  → Log issue in CRM

If system-side:
  → Check payment processor API status
  → Verify API credentials are valid
  → Contact payment processor support

Who to escalate to:

Business hours: @payment-team
After hours: On-call engineer (via PagerDuty)
If unresolved after 1 hour: Engineering manager

---

Practice 5: Regular Alert Review

Monthly review checklist:

• □ Alert frequency: Are we getting too many? Too few?
• □ False positives: Any alerts that weren't actually actionable?
• □ Missed issues: Any problems that didn't trigger alerts but should have?
• □ Response times: How fast are we responding to alerts?
• □ Alert accuracy: Are messages providing enough context?
• □ Channel appropriateness: Right alerts going to right places?
• □ Threshold adjustments: Do alert thresholds need tuning?

Adjust based on findings:

• Increase thresholds if getting too many false positives
• Decrease thresholds if missing real issues
• Change channels if alerts going to wrong audience
• Update message templates if context is insufficient
• Add new alerts if gaps are discovered

---

Part 5: Common Alert Patterns Reference

Quick Pattern Table

Alert Type	When It Runs	Check Frequency	Channel	Use For
Cell Failure	When cell completes	Per row	Email/Slack	Critical operations
Error Rate >10%	CRON schedule	Every 15 min	Slack @channel	System health
Cost Threshold	CRON schedule	Daily	Email/Slack	Budget control
Processing Delay	When cell completes	Per row	Slack	Performance issues
Trigger Inactive	CRON schedule	Every 6 hours	Email	Data pipeline health
SLA Breach	When ticket updates	Per update	Slack @user	Service quality
Low Inventory	When inventory changes	Per row	Email	Stock management
Daily Summary	CRON schedule	Daily 6pm	Email	Status reports

---

Part 6: Alert Dashboard Overview

Here's what a well-configured alert system looks like in action:

Alerts Sent Today

9

+12%

Active Alerts

3

stable

Avg Response Time

1m 45s

-8%

Success Rate

98.5%

+2%

Active Alerts

Lead Enrichment Failed

activeEmail

Taible: Lead Processing

Last sent: 5 minutes agoSent today: 3Avg response: 2m 15s

High Error Rate Alert

activeSlack

Taible: Order Processing

Last sent: 1 hour agoSent today: 1Avg response: 45s

Daily Cost Alert

inactiveEmail

Taible: Cost Monitor

Last sent: YesterdaySent today: 0Avg response: -

SLA Breach Warning

activeSlack

Taible: Support Tickets

Last sent: 10 minutes agoSent today: 5Avg response: 1m 30s

Recent Alert Activity

SLA Breach Warning sent to #support

10 minutes ago • Delivered successfully

High Error Rate Alert sent to team@company.com

1 hour ago • Delivered successfully

Lead Enrichment Failed delivery failed

2 hours ago • SMTP connection timeout

Lead Enrichment Failed sent to admin@company.com

5 hours ago • Delivered successfully

Dashboard features:

• Overview statistics: Alerts sent, response times, success rate
• Active alerts list: All configured alerts with status
• Recent activity: Recent deliveries and any failures
• Performance metrics: Track alert effectiveness

Monitoring your alerts:

• Check success rate (should be >95%)
• Review response times (are team responding quickly?)
• Look for delivery failures (SMTP errors, API issues)
• Track alert volume trends (increasing or stable?)

---

Summary: Alerts and Notifications

You now understand how to build effective alerting workflows:

✅ Alert setup:

• Connect notification accounts (Email, Slack, Telegram)
• Configure alert columns with clear messages
• Set conditions to control when alerts fire
• Add dependencies to monitor specific columns

✅ Alert patterns:

• Simple error alerts (immediate notification)
• Threshold alerts (aggregate metrics)
• Slack team alerts (collaboration)
• Cost monitoring (budget control)
• Inactivity detection (health monitoring)
• SLA breach alerts (service quality)

✅ Best practices:

• Avoid alert fatigue with severity levels and batching
• Include actionable context in every alert
• Test thoroughly before going live
• Document response procedures
• Review and adjust regularly

✅ Notification channels:

• Email: Formal, detailed, external recipients
• Slack: Real-time, collaborative, team coordination
• Telegram: Mobile-first, personal alerts
• Webhooks: Integration with external services

✅ Key techniques:

• Use conditions to prevent unnecessary alerts
• Set up monitoring Taibles for complex checks
• Use CRON triggers for periodic monitoring
• Create escalation paths for critical issues
• Batch similar alerts to reduce noise

---

Next Steps

You've completed Section 15.3: Alerts and Notifications!

Continue to: Chapter 16: Maintenance and Troubleshooting → Learn how to keep your automations running smoothly and resolve issues effectively.

Keep your systems monitored and your team informed! 🔔