16.1 Regular Maintenance
Regular maintenance keeps your automations running smoothly, prevents issues from accumulating, and ensures optimal performance. This section provides practical maintenance workflows you can implement today.
Overview: Why Maintenance Matters
Without Regular Maintenance
Problems accumulate:
- Old test data clutters your taibles
- Error rates creep up unnoticed
- Costs increase unexpectedly
- Performance degrades gradually
- Integrations break silently
- OAuth tokens expire
Result: Surprises and emergencies
With Regular Maintenance
Stay ahead of problems:
- Clean, organized taibles
- Consistent error rates
- Predictable costs
- Fast execution times
- Reliable integrations
- Proactive issue resolution
Result: Smooth operations and confidence
Part 1: Weekly Health Checks
Time investment: 30-45 minutes per week Impact: Catch 80% of issues before they become problems
Weekly Health Check Workflow
Step 1: Review Error Rates (10 minutes)
For each critical taible:
1. Open taible
2. Scan columns visually:
Look for cells showing error indicators (cells will display with an error badge). Count them:
- 0-2 error cells = Normal
- 3-10 error cells = Review needed
- 10+ error cells = Problem (investigate immediately)
3. Use filter for failed cells:
Filter for Failed Cells
Step 1: Click the filter button on any column header
Step 2: In the filter dialog, select:
Result: Only cells with errors will be shown
💡 Tip: You can also filter by date range to see failures from the past 7 days: Add another filter with "Updated >= [7 days ago]"
4. Click failed cells to review errors:
For each failed cell:
- Click the cell to view the error details panel
- Note error type (API, timeout, etc.)
- Categorize: Transient (retry) or Persistent (fix needed)
5. Document findings:
Taible: Lead Enrichment
Failed cells: 8
Error types:
- 5x "API timeout" (transient)
- 3x "404 Not Found" (bad data)
Action:
- Retry 5 timeout cells
- Fix data source for 404 errorsExpected error rates:
0-1%: Excellent (normal transient failures)
1-5%: Good (acceptable for external APIs)
5-10%: Fair (review and optimize)
>10%: Poor (requires immediate action)Step 2: Review Costs (5 minutes)
1. Open Settings → Usage History
Usage History
Get a detailed breakdown of your token usage.
| Date | Description | Amount |
|---|---|---|
| 10/28/2024 2:45 PM | Lead Enrichment - Company Research | 89,450 |
| 10/28/2024 10:22 AM | Email Generation - Customer Outreach | 51,230 |
| 10/27/2024 4:15 PM | Lead Scoring - Qualification | 24,560 |
| 10/27/2024 11:30 AM | Content Summarization | 18,920 |
| 10/26/2024 3:10 PM | Lead Enrichment - Company Research | 92,150 |
Week Total
450,000
tokens
Daily Average
64,000
tokens/day
vs Last Week
+18%
within normal range
2. Check last 7 days usage:
Week total: 450,000 tokens
Daily average: 64,000 tokens
Compare to previous week:
Last week: 380,000 tokens
Change: +18% (investigate if >20%)3. Identify expensive operations:
Sort by date to see patterns. Look for:
- Sudden spikes in usage
- Columns that consistently use many tokens
- Days with unusually high activity
4. Calculate projected monthly cost:
Weekly average: 450,000 tokens
Monthly projection: 450K × 4.3 = 1,935,000 tokens
Estimated cost: ~$40-60/month (GPT-4)
Budget check: Within expectations?5. Document anomalies:
Week of Oct 24: 650,000 tokens (+44%)
Cause: New lead enrichment campaign
Expected? Yes
Action: None (justified spike)Step 3: Validate Automations (10 minutes)
Check that automations are running as expected:
1. Verify trigger activity:
For each trigger-based taible:
- Check: New rows created recently?
- Expected: Shopify orders - 20-30/day
- Actual: Last row created 3 days ago ⚠️
- Action: Check webhook status, test trigger
2. Check processing times:
For each critical workflow:
- Check: Time from row created → fully processed
- Expected: Lead enrichment - 2-5 minutes
- Actual: Taking 15-20 minutes ⚠️
- Action: Investigate bottleneck (see Performance Tuning)
3. Validate data quality:
Sample check: Review 10 random recent rows
- Are outputs correct?
- Any unexpected empty values?
- Data format as expected?
- Reasonable results?
4. Test critical paths:
Manually create test row and watch it flow through:
- Does it trigger correctly?
- Do dependencies execute in order?
- Does it reach completion?
- Are outputs correct?
- Delete test row after validation
Step 4: Update Configurations (10-15 minutes)
Review and update as needed:
1. Rate limits:
Check: Are rate limits still appropriate?
- Too strict: Many cells rate-limited, slow processing
- Too loose: Hitting API provider limits, getting blocked
Adjust: Increase/decrease based on actual usage patterns
2. Conditions:
Review conditional columns:
- Are conditions still valid?
- Has business logic changed?
- Update conditions to reflect current requirements
3. Prompts (for LLM columns):
Review AI column prompts:
- Are results still good quality?
- Any drift in output format?
- Update prompts for better results
- Add examples for clarity
4. Dependencies:
Check: Are all dependencies still necessary?
- Remove unused dependencies
- Optimize execution order
- Add missing dependencies if issues found
Weekly Health Check Checklist
Print and use weekly:
Weekly Health Check Checklist
Part 2: Data Cleanup
Frequency: Monthly or as needed Time investment: 15-30 minutes Impact: Keeps taibles fast, organized, and manageable
Cleanup 1: Archive Old Rows
When to archive:
- Completed orders older than 6 months
- Closed support tickets older than 90 days
- Processed leads older than 1 year
- Any historical data no longer actively used
Archive workflow:
Step 1: Export for backup
Export Taible for Archive
Support Tickets
Archive closed tickets from Q3 2024
Export the taible structure along with all row data
Selected rows: 1,245 rows (filtered by: status = closed, closed_date < 90 days ago)
💡 Best Practice: Always export before deleting! Store archives in a safe location with backup copies. Keep per compliance requirements (typically 7 years for business records).
After export completes:
- File will be downloaded:
support-tickets-archive-2024-Q3.agent - Verify the export by opening the file
- Store in your archives folder
- Create a backup copy
- Only then proceed to delete rows from taible
1. Open taible with old data
2. Filter for old rows:
Use the filter feature to select rows based on date:
- Open the filter dialog
- Select the status or date field
- Choose rows that meet your archival criteria
- Example: status = 'closed' AND closed_date < [90 days ago]
3. Select all filtered rows:
After applying the filter:
- Click checkbox in the header row
- You'll see: "50 rows selected. Select all 1,245?"
- Click "Select all 1,245 rows"
4. Export selected rows:
- Right-click on the selection
- Choose "Export"
- Format: CSV
- Save as: "support-tickets-archive-2024-Q3.csv"
5. Store export safely:
- Location: /archives/support-tickets/
- Backup: Copy to secondary storage
- Retention: Keep per compliance requirements (7 years typical)
Step 2: Delete archived rows
6. Verify export completed:
- Open CSV file in Excel/Sheets
- Verify: Row count matches (1,245 rows)
- Spot check: Sample 10 rows for data integrity
7. Delete rows from taible:
With same filter and selection:
- Right-click → Delete
- Confirmation dialog appears: "Delete 1,245 rows? This cannot be undone."
- Click "Yes - Delete"
8. Wait for deletion (large batches may take a minute)
9. Verify deletion:
- Clear filter
- Check: Old rows no longer visible
- Row count decreased appropriately
Cleanup 2: Remove Test Data
When to clean:
- After testing new columns
- After validating workflows
- Before sharing taible with team
- Before production deployment
Test data cleanup workflow:
Remove Test Data
Step 1: Identify Test Rows
Filter by test indicators:
Filter results: 47 rows match test data patterns
Step 2: Review and Verify
| Name | Company | ||
|---|---|---|---|
| John TEST | test@example.com | Test Company | |
| Test User | testuser@test.com | Testing Inc | |
| xxx-delete-xxx | delete@test.com | XXX Company |
47 rows selected. Select all 47 rows
Step 3: Delete Test Rows
Confirm Deletion
Delete 47 rows? This cannot be undone.
✅ Best Practice: Add an "is_test" toggle column to your taible. Set it to true for test rows. This makes cleanup easier and safer - just filter for is_test = true and delete in bulk!
Step 1: Identify test rows
Pattern 1: Test naming convention:
Filter for test indicators:
- Email contains "test@"
- Name contains "TEST"
- Company contains "Test Company"
- Any field with "xxx" or "zzz"
Pattern 2: Date range:
Filter by creation date:
- Created_date: During testing period
- Example: Oct 15-17 (testing days)
- Review: Manually verify these are test rows
Pattern 3: User created:
Filter by creator:
- Created_by: Your user account
- During: Testing period
- Review: Check which are test vs real
Step 2: Delete test rows
- Apply test data filter
- Review filtered rows (manual verification)
- Select rows to delete
- Right-click → Delete
- Confirm deletion
- Clear filter
- Verify test data removed
Best practice: Test data tagging:
Add an "is_test" column:
- Column type: Toggle (boolean)
- Default: false
- For test rows: Set to true
Filter for deletion:
- is_test = true
Cleanup:
- Select all is_test rows
- Delete in bulk
- No risk of deleting real data
Cleanup 3: Remove Duplicate Rows
Manual duplicate removal (automated detection planned):
Step 1: Identify duplicates
Sort by unique identifier:
- Email address
- Order ID
- Customer ID
- etc.
Visually scan for consecutive duplicates:
- john@example.com (row 45)
- john@example.com (row 46) ← Duplicate
Step 2: Verify and delete
For each suspected duplicate:
- Compare row data side by side
- Verify: Truly duplicate or separate entries?
- If duplicate: Note which row to keep (newer? more complete?)
- Select duplicate row(s)
- Delete
OR: Export, deduplicate in Excel, re-import
Part 3: Performance Tuning
Frequency: Monthly or when performance degrades Time investment: 30-60 minutes Impact: Faster execution, better user experience
Tuning 1: Monitor Execution Times
Identify slow columns:
Monitor Column Execution Times
Watch a test row process end-to-end:
Target: <15 seconds. AI Enrichment needs optimization.
Performance Analysis
- Consider reducing prompt size
- Implement caching for repeat lookups
- Split into fast + slow parts
Method 1: Manual observation
Watch a row process end-to-end:
- Create new test row
- Note timestamp when created
- Watch each column execute (look for "Running" badge)
- Note timestamp when all done
- Calculate: Total time and per-column time
Example findings:
- Company Lookup: 2 seconds ✓
- AI Enrichment: 45 seconds ⚠️ (target: <10s)
- Email Send: 1 second ✓
- Total: 48 seconds (target: <15s)
Bottleneck: AI Enrichment needs optimization
Method 2: Sample multiple rows
Filter: Recent rows (last 24 hours) Sample: 10-20 rows
For each row:
- Check timestamps in each cell
- Calculate processing time per column
- Note: Fastest, slowest, average
Column: AI Enrichment
- Fastest: 5 seconds
- Slowest: 120 seconds (timeout?)
- Average: 28 seconds
- Median: 22 seconds
Analysis: High variance suggests inconsistent API performance
Tuning 2: Optimize Slow Columns
Common optimizations:
1. Reduce LLM prompt size:
Optimize LLM Prompt Size
Based on the following comprehensive data analysis including market trends, competitor analysis, historical performance metrics, customer demographics, purchase patterns, and seasonal variations...
[3,000 tokens of context]
Summarize in 100 words: [Company name], [Industry], [Key metrics]
[500 tokens of focused context]
Faster execution
Lower token usage
Cost reduction
💡 Optimization Tips:
- Remove unnecessary context - only include what the AI needs
- Use placeholders like [Customer Name] instead of long examples
- Set specific output length limits (e.g., "in 100 words")
- Test with minimal prompts first, then add context as needed
2. Add caching:
Pattern: Company enrichment
- 100 leads from 10 companies
- Currently: 100 API calls
- With caching: 10 API calls + 90 cache hits
Implementation:
- Create "Company Cache" taible
- Lookup company first in cache
- If found: Use cached data
- If not found: Call API, store in cache
- Subsequent lookups: Cache hit (instant)
Result: 90% faster for repeat lookups
3. Adjust timeouts:
Problem: Unnecessary waits or premature failures
Too short:
- Timeout: 10 seconds
- API typically responds in 15-20 seconds
- Result: Most calls timeout and fail
Too long:
- Timeout: 120 seconds
- API typically responds in 5 seconds
- Slow API calls block queue for 2 minutes
- Result: Queue backs up
Optimal:
- Check: Average + 2× standard deviation
- Example: Average 8s, StdDev 3s
- Set timeout: 8 + 2(3) = 14 seconds
- Result: 95% success, minimal blocking
4. Optimize API calls:
Optimization 1: Batch requests
- Instead of: 10 separate API calls
- Do: 1 batch API call with 10 items
- Result: 10x faster
Optimization 2: Reduce payload
- Instead of: Sending entire row data
- Do: Send only required fields
- Result: Faster transmission, lower token usage
Optimization 3: Use appropriate endpoints
- Instead of: Generic search endpoint
- Do: Direct lookup endpoint (if available)
- Result: Faster response from API
Tuning 3: Optimize Dependencies
Remove unnecessary dependencies:
Remove Unnecessary Dependencies
Column: Send Email
DEPENDENCIES
Before Optimization
Must wait for lead_score (15s) and enrichment_data (45s) to complete before email can be sent
After Optimization
Only waits for lead_email (2s) and company_name (3s). Email sends much faster!
✅ Best Practice: Review dependencies monthly. Ask for each dependency: "Is this actually used in the column?" If not, remove it. This speeds up execution significantly by reducing wait times.
Part 4: Account Maintenance
Frequency: As needed or quarterly Time investment: 15-30 minutes Impact: Prevents integration breakage, maintains security
Maintenance 1: Refresh OAuth Tokens
Why tokens expire:
- Security: Tokens have limited lifetime (typically 60-90 days)
- When expired: Integration stops working
- Symptom: Sudden authentication errors in columns
How to refresh OAuth tokens:
Refresh OAuth Tokens
Step 1: Open Settings → Accounts
john@company.com
john@company.com
Step 2: Click "Re-authenticate" Button
HubSpot Authorization
Taibles would like to access your HubSpot account
After authorization, popup will close automatically
Step 3: Verification Complete
john@company.com
Last authenticated: Just now
💡 Pro Tip: Set a calendar reminder every 60 days to refresh all OAuth tokens proactively. This prevents unexpected integration failures and keeps your automations running smoothly.
Proactive approach:
Set calendar reminder:
Frequency: Every 60 days
Task: "Refresh OAuth tokens for Taibles integrations"
Action: Go through all OAuth accounts, re-authenticateMaintenance 2: Rotate API Keys
Security best practice: Rotate API keys quarterly
API key rotation workflow:
Rotate API Keys (Quarterly)
Step 1: Generate New API Key in Service
Service: OpenAI API Dashboard
sk-proj-abc123xyz789...
Created: Oct 28, 2024
Important: This key will only be shown once. Copy it now!
Step 2: Update in Taibles → Settings → Accounts
OpenAI API
Enter the new API key you just generated
Step 3: Test Integration
Create a test row to verify the new API key works:
Step 4: Revoke Old API Key
Return to OpenAI API Dashboard:
sk-proj-old123... (Old Key)
Created: Jul 15, 2024 (Q3 2024)
After revoking, the old key will no longer work. This ensures security by disabling the previous credentials.
Recommended Rotation Schedule
| Service | Frequency |
|---|---|
| OpenAI / LLMs | Quarterly |
| Payment APIs | Every 60 days |
| CRM APIs | Quarterly |
| Internal APIs | Annually |
| Development keys | Monthly |
Rotation schedule:
Service Frequency
OpenAI / LLMs Quarterly
Payment APIs Every 60 days
CRM APIs Quarterly
Internal APIs Annually
Development keys MonthlyMaintenance 3: Test Integrations
Monthly integration health check:
For each critical integration:
1. Verify connectivity:
Manual test:
- Create test row
- Run column using integration
- Check: Succeeds without errors ✓
- Delete test row
2. Check for API changes:
Review:
- Service's changelog or developer updates
- Any breaking changes announced?
- Required actions?
- Timeline for migration?
3. Validate data format:
Check:
- Is returned data format still as expected?
- Any new fields available?
- Any fields deprecated?
- Update column configurations if needed
4. Monitor error patterns:
Review recent errors:
- Any new error types?
- Frequency increasing?
- Specific to one integration?
- Indicates service issues or changes
Maintenance 4: Update Credentials After Changes
When to update:
- Password changed for email account
- API key rotated by service (forced)
- OAuth scopes updated
- Account ownership transferred
- Email address changed
Update workflow (same as API key rotation):
- Update credential in service
- Update in Taibles (Settings → Accounts)
- Test integration
- Document change (date, reason, updated by)
Part 5: Maintenance Calendar
Weekly Tasks (30-45 min)
Every Monday morning:
Weekly Tasks (30-45 min)
Every Monday Morning
Review error rates
10 minutes
Check costs and usage
5 minutes
Validate automations
10 minutes
Update configurations as needed
10-15 minutes
Document issues and resolutions
5 minutes
Monthly Tasks (1-2 hours)
First week of each month:
Monthly Tasks (1-2 hours)
First Week of Each Month
Archive old rows
15-30 minutes
Clean up test data
15 minutes
Remove duplicates
15 minutes
Monitor execution times
15 minutes
Optimize slow columns
30 minutes
Review dependencies
15 minutes
Test integrations
15 minutes
Quarterly Tasks (2-3 hours)
Every 3 months:
Quarterly Tasks (2-3 hours)
Every 3 Months
Rotate API keys
30-60 minutes
Refresh all OAuth tokens
30 minutes
Review and optimize rate limits
30 minutes
Audit unused columns (remove if not needed)
30 minutes
Review taible structure
30 minutes
Update documentation
30 minutes
Train new team members on changes
30-60 minutes
Annual Tasks (Half day)
Once per year:
Annual Tasks (Half Day)
Once Per Year
Full taible audit
2 hours
Performance benchmarking
1 hour
Security review
1 hour
Compliance export (all data for records)
1 hour
Disaster recovery test
1 hour
Team training refresh
2 hours
Summary: Regular Maintenance
You now have actionable maintenance workflows:
✅ Weekly health checks:
- Error rate monitoring (target: <5%)
- Cost review (usage history)
- Automation validation (triggers, processing times)
- Configuration updates (rate limits, conditions, prompts)
- 30-45 minute investment
✅ Data cleanup:
- Archive old rows (export → delete)
- Remove test data (filter → delete)
- Remove duplicates (manual review)
- Keep taibles lean and fast
✅ Performance tuning:
- Monitor execution times
- Optimize slow columns (prompts, caching, timeouts)
- Remove unnecessary dependencies
- Optimize dependency order
✅ Account maintenance:
- Refresh OAuth tokens (every 60-90 days)
- Rotate API keys (quarterly)
- Test integrations (monthly)
- Update credentials when changed
- Maintain security and reliability
✅ Maintenance calendar:
- Weekly: Health checks (30-45 min)
- Monthly: Cleanup and optimization (1-2 hours)
- Quarterly: Security and account maintenance (2-3 hours)
- Annual: Full audit and disaster recovery (half day)
Next Steps
You've completed Section 16.1: Regular Maintenance!
Next: Section 16.2: Common Issues → Learn how to troubleshoot common problems like stuck queues, high failure rates, and unexpected behavior.
Let's build your troubleshooting skills! 🔧