Build complete apps in Glide Builder via browser automation and API integration

version
0.1.0
GitHub stars
10

Install

/plugin install glide@glide

Run it inside Claude Code after adding the marketplace with /plugin marketplace add glideapps/glide-code.

Contents

Discovered from source

Skills 13

Glide AI

Glide has powerful AI columns that run inference on your data. These can add significant value to apps with minimal effort.

AI Column Types

ColumnInputOutputUse Case
Generate TextText/templateAI-generated textSummaries, descriptions, recommendations
Image to TextImage URLExtracted textReceipt scanning, document OCR, product analysis
Document to TextDocument URLExtracted/summarized textPDF parsing, document processing
Audio to TextAudio URLTranscriptionVoice notes, meeting recordings
Text to BooleanTexttrue/falseSentiment analysis, spam detection
Text to ChoiceText + optionsSelected optionAuto-categorization, priority assignment
Text to JSONTextStructured JSONEntity extraction, form parsing

AI Techniques

Detail Screen Summary with Hint Component

A powerful pattern: show an AI-generated summary at the top of detail screens.

How it works:

  1. Aggregate data - Create a Template column or JSON Object column that combines relevant fields
    • Template: Name: {Name}, Status: {Status}, Due: {Due Date}, Notes: {Notes}
    • Or use JSON Object to structure the data
  2. Generate summary - Create a Generate Text column that takes the aggregated data
    • Prompt: "Summarize this task in 1-2 sentences, highlighting priority and next steps"
  3. Display with Hint - Add a Hint component at the top of the detail screen
    • Bind it to the Generate Text column
    • Users see an instant AI summary of the item

Example prompts:

  • Task: "Summarize this task, noting urgency and blockers"
  • Customer: "Provide a brief profile of this customer based on their activity"
  • Order: "Summarize this order status and any issues"
  • Project: "Give a quick health check of this project"

This gives users instant context without reading through all fields.

Auto-Categorization with Text to Choice

Automatically categorize items as they're added:

  1. Create a Text to Choice column
  2. Define the categories (e.g., "Bug", "Feature", "Question", "Other")
  3. Point it at the text field to analyze (e.g., ticket description)
  4. New items get auto-categorized

Great for:

  • Support tickets → category
  • Feedback → sentiment (Positive, Negative, Neutral)
  • Expenses → expense type
  • Leads → qualification level

Smart Descriptions from Basic Info

Generate rich descriptions from minimal input:

  1. User enters basic info (name, a few keywords)
  2. Template column combines the inputs
  3. Generate Text creates a full description

Example for products:

  • Input: "Blue widget, small, outdoor use"
  • Generate Text prompt: "Write a compelling 2-sentence product description"
  • Output: "Introducing our compact Blue Widget, perfectly sized for any outdoor adventure. Built to withstand the elements while delivering reliable performance wherever you go."

Receipt/Document Scanning

Extract structured data from images:

  1. User uploads a receipt photo
  2. Image to Text extracts the content
  3. Text to JSON parses into structured fields (vendor, amount, date)
  4. Display parsed data in the UI

Works for:

  • Receipts → expense tracking
  • Business cards → contact creation
  • Documents → data entry
  • Product photos → inventory details

Sentiment Analysis

Detect sentiment in text:

  1. Create a Text to Boolean column
  2. Prompt: "Is this feedback positive?"
  3. Use result to show 😊 or 😞 emoji via If-Then-Else
  4. Or use Text to Choice for Positive/Neutral/Negative

Apply to:

  • Customer feedback
  • Support ticket tone
  • Review analysis
  • Survey responses

Best Practices

  • Aggregate before generating - Combine relevant data into one input for better AI results
  • Be specific in prompts - Tell the AI exactly what format and length you want
  • Use for summaries - AI excels at condensing information
  • Cache results - AI columns compute once and store the result
  • Consider cost - AI columns use Glide AI credits; use strategically

When to Add AI

Look for opportunities where:

  • Users need to quickly understand complex data
  • Manual categorization is tedious
  • Text input could be richer/more helpful
  • Images contain data that should be structured
  • Summaries would save users time

Glide API

API Overview

Two Ways to Access Data

  1. REST API v2 - Direct HTTP calls to api.glideapps.com
  2. @glideapps/tables - Official npm package (simpler for JavaScript/TypeScript)

Important Limitations

  • Big Tables Only: API v2 only works with Glide Big Tables, not native app tables
  • Team Scope: API operates at team level, not app level
  • Quota Costs: Read/write operations consume updates from your plan
  • Row Limits: Big Tables support up to 10 million rows
  • Aggregation Limits: Rollups/Lookups limited to 100 matching rows in Big Tables
  • Computed Column Limits: Some computed column types can't be filtered/sorted (see below)

Getting Your API Token

  1. Open any app in Glide Builder
  2. Go to Data tab
  3. Click Show API button (bottom of data grid)
  4. Click Copy secret token

Store token securely - never commit to version control.

REST API v2

Base URL

https://api.glideapps.com/

Authentication

Authorization: Bearer YOUR_API_TOKEN

Endpoints

MethodEndpointDescription
GET/tablesList all Big Tables
POST/tablesCreate new Big Table
GET/tables/{tableID}/rowsGet rows
GET/tables/{tableID}/rows/{rowID}Get single row
HEAD/tables/{tableID}/rowsGet table version
POST/tables/{tableID}/rowsAdd rows
PATCH/tables/{tableID}/rows/{rowID}Update row
PUT/tables/{tableID}Overwrite table
DELETE/tables/{tableID}/rows/{rowID}Delete row

Example: List Tables

curl -X GET "https://api.glideapps.com/tables" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json"

Example: Get Rows

curl -X GET "https://api.glideapps.com/tables/TABLE_ID/rows" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json"

Example: Create Table

Create a new Big Table with schema and initial data. See official docs.

curl -X POST "https://api.glideapps.com/tables" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Contacts",
    "appsToLink": ["APP_ID_HERE"],
    "schema": {
      "columns": [
        {"id": "fullName", "displayName": "Full Name", "type": "string"},
        {"id": "email", "displayName": "Email", "type": "string"},
        {"id": "photo", "displayName": "Photo", "type": "uri"},
        {"id": "createdAt", "displayName": "Created", "type": "dateTime"}
      ]
    },
    "rows": [
      {
        "fullName": "Alex Bard",
        "email": "alex@example.com",
        "photo": "https://randomuser.me/api/portraits/men/32.jpg",
        "createdAt": "2024-07-29T14:04:15.561Z"
      }
    ]
  }'

Response:

{
  "data": {
    "tableID": "2a1bad8b-cf7c-44437-b8c1-e3782df6",
    "rowIDs": ["zcJWnyI8Tbam21V34K8MNA"],
    "linkedAppIDs": ["APP_ID_HERE"]
  }
}

Column Types for Schema:

TypeDescription
stringText data
numberNumeric values
dateTimeISO 8601 dates
uriURLs (images, links)
booleanTrue/false

Key Points:

  • appsToLink: Array of app IDs to automatically link the table to
  • schema.columns: Each has id (used in row data), displayName (shown in UI), type
  • rows: Use column id values as keys, NOT displayName

Example: Add Rows

Use column IDs (not display names) as keys. Column IDs are defined in the schema when creating the table.

curl -X POST "https://api.glideapps.com/tables/TABLE_ID/rows" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "rows": [
      {"fullName": "Alice", "email": "alice@example.com"},
      {"fullName": "Bob", "email": "bob@example.com"}
    ]
  }'

Example: Update Row

curl -X PATCH "https://api.glideapps.com/tables/TABLE_ID/rows/ROW_ID" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Updated Name"
  }'

Example: Delete Row

curl -X DELETE "https://api.glideapps.com/tables/TABLE_ID/rows/ROW_ID" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

@glideapps/tables Package

Installation

npm install @glideapps/tables

Setup

import * as glide from "@glideapps/tables";

const myTable = glide.table({
  token: "YOUR_API_TOKEN",
  app: "APP_ID",           // Optional for Big Tables
  table: "TABLE_ID",
  columns: {
    name: { type: "string", name: "Name" },
    email: { type: "email-address", name: "Email" },
    photo: { type: "image-uri", name: "Photo" },
    active: { type: "boolean", name: "Active" }
  }
});

Column Types

TypeDescription
stringText
numberNumeric
booleanTrue/False
date-timeDate and time
image-uriImage URL
email-addressEmail
phone-numberPhone
uriURL

Get Rows

// Get all rows
const rows = await myTable.get();

// With query parameters
const filtered = await myTable.get({
  where: { active: true },
  limit: 10
});

Add Rows

// Add single row
await myTable.add({
  name: "Alice",
  email: "alice@example.com"
});

// Add multiple rows
await myTable.add([
  { name: "Alice", email: "alice@example.com" },
  { name: "Bob", email: "bob@example.com" }
]);

Update Row

await myTable.update(rowId, {
  name: "Updated Name"
});

Delete Row

await myTable.delete(rowId);

Data Versioning

The API supports optimistic locking via ETags:

# Get current version
HEAD /tables/{tableID}/rows

# Update with version check
PATCH /tables/{tableID}/rows/{rowID}
If-Match: "version-etag"

If the version has changed, you'll get HTTP 412 Precondition Failed.

Pricing

OperationCost
Write (per row)0.01 updates
Read (per row)0.001 updates
List tablesFree
Get versionFree

Additional updates beyond quota: $0.02 each

Big Table Computed Column Limits

When querying Big Tables, not all computed columns can be used for filtering or sorting.

Supported for filtering/sorting:

  • Math columns
  • If-Then-Else columns
  • Lookup columns (single relation, basic columns only)
  • Template columns (static template only)

NOT supported for filtering/sorting:

  • Rollup columns
  • Multi-relation columns
  • Query columns
  • Plugin-based columns

Lookup requirements:

  • Must use single relation (not multi-relation)
  • Relation column must be basic (non-computed)
  • Target table must be a Big Table
  • Target column must be basic and not user-specific

Aggregation limit: Rollups/Lookups return max 100 matching rows.

See the data-modeling skill for full Big Table documentation.

Best Practices

  1. Use Big Tables for API access - native tables aren't supported
  2. Batch operations - Add multiple rows in one call
  3. Use versioning - Prevent data conflicts with If-Match
  4. Cache tokens - Don't request new tokens repeatedly
  5. Handle errors - Check for 4xx/5xx responses
  6. Respect rate limits - Don't hammer the API
  7. Check computed column support - Not all computed columns work with filters

Common Patterns

Sync External Data to Glide

import * as glide from "@glideapps/tables";

const targetTable = glide.table({
  token: process.env.GLIDE_TOKEN,
  table: "my-big-table-id",
  columns: {
    externalId: { type: "string", name: "External ID" },
    name: { type: "string", name: "Name" },
    updatedAt: { type: "date-time", name: "Updated At" }
  }
});

async function syncData(externalData) {
  // Get existing rows
  const existing = await targetTable.get();
  const existingMap = new Map(existing.map(r => [r.externalId, r]));

  // Process updates and inserts
  const toAdd = [];
  for (const item of externalData) {
    if (!existingMap.has(item.id)) {
      toAdd.push({
        externalId: item.id,
        name: item.name,
        updatedAt: new Date().toISOString()
      });
    }
  }

  if (toAdd.length > 0) {
    await targetTable.add(toAdd);
  }
}

Bulk Import from CSV

import * as glide from "@glideapps/tables";
import { parse } from "csv-parse/sync";
import fs from "fs";

const table = glide.table({
  token: process.env.GLIDE_TOKEN,
  table: "target-table-id",
  columns: {
    col1: { type: "string", name: "Column 1" },
    col2: { type: "string", name: "Column 2" }
  }
});

const csvContent = fs.readFileSync("data.csv", "utf-8");
const records = parse(csvContent, { columns: true });

// Batch in chunks of 100
const chunkSize = 100;
for (let i = 0; i < records.length; i += chunkSize) {
  const chunk = records.slice(i, i + chunkSize);
  await table.add(chunk.map(r => ({
    col1: r["Column 1"],
    col2: r["Column 2"]
  })));
}

Documentation

Glide App Audit

Comprehensive performance audit tool for Glide applications. Analyzes data architecture and layout design to identify bottlenecks, anti-patterns, and optimization opportunities.

⚠️ Read-Only Guarantee

This tool is 100% read-only and NEVER modifies your app:

  • ✅ Reads data via API (GET requests only)
  • ✅ Navigates through Layout Editor to inspect screens
  • ✅ Takes snapshots to analyze components
  • ✅ Clicks to view settings panels (read-only)
  • ❌ NEVER edits columns, components, or settings
  • ❌ NEVER adds or deletes anything
  • ❌ NEVER saves any changes
  • ❌ NEVER modifies data or structure

Safe to run anytime - Your app remains exactly as it was before the audit.

Official Glide Performance Thresholds

These thresholds come directly from Glide documentation and community guidance:

MetricThresholdSource
Column computation time100msPerformance Analysis - columns exceeding this show ⚠️
Query column entries10,000 maxQuery Column Limits
Glide Table rows25,000 maxBig Tables Guide
Big Table rows10 million maxBig Tables
Big Table rollup/lookup matches100 maxBig Tables
Collection items visible24 recommendedBuild for Speed
Image dimensions1,500px maxBuild for Speed

Big Table Computed Column Limits

Big Tables use SQL (AlloyDB) for queries. Only certain computed columns can be filtered/sorted:

Supported for filtering/sorting in Big Tables:

  • Math columns
  • If-Then-Else columns
  • Lookup columns (single relation, basic columns only)
  • Template columns (static template only)

NOT supported for filtering/sorting in Big Tables:

  • Rollup columns
  • Multi-relation columns
  • Query columns
  • Plugin-based columns

See analysis-patterns.md for detailed requirements.

What It Audits

Data Layer Analysis

Using Glide's Performance Analysis tool:

  • Run Performance Analysis in the Data Editor
  • Identify columns with ⚠️ warning (>100ms computation)
  • Focus on those specific columns for optimization

Using Dev Tools plugin (Glide internal users only):

  • Column Dependencies - Complete dependency graph with depth calculations
  • Max Depth - Deepest computed column chain in the app
  • Access Control - Row Owner and Role columns
  • User Specific Columns - Per-user data storage
  • Table Row Counts - Accurate counts with CSV export

Known performance anti-patterns (from Glide docs):

  • Query columns - Slower than Relations for Glide Tables
  • Query on same table - Can crash the app (source)
  • Nested computed columns - Cause slowdowns with large datasets
  • Filtering on computed columns - Forces entire table recalculation
  • Tables approaching 25,000 rows - Need Big Tables migration

Layout Analysis

  • Collection item counts - More than 24 items hurts performance
  • Image sizes - Large images slow rendering
  • First screen weight - Heavy first screens hurt perceived performance

How to Use

Basic Usage

/app-audit https://go.glideapps.com/app/abc123

Support Mode URL

The audit also accepts a support-mode URL, which opens the app in a read-only support session (no edits or data saving possible):

/app-audit https://go.glideapps.com/support/8cfc3aa0-fed1-475e-a15d-ea8199d17d7d

The trailing value is a support-session UUID, not an App ID. For these URLs the audit navigates to the support URL directly (this is what grants read-only mode), then reads the real App ID from the loaded app. This pairs naturally with the audit's read-only guarantee.

The audit will:

  1. Extract app ID from URL (or open the support session and read it from the loaded app)
  2. Connect to app and retrieve API token
  3. Run Performance Analysis to find slow columns
  4. Analyze data structure via API + browser
  5. Inspect layout via browser automation
  6. Generate markdown report with findings

What You'll Get

A report identifying:

  • Columns exceeding 100ms - From Performance Analysis
  • Query columns that could be Relations - Glide's recommended optimization
  • Tables approaching row limits - 25,000 for Glide Tables
  • Computed column dependencies - Chains that may cause cascading delays
  • Layout issues - Collections, images, screen weight

Optional customer-facing report: After the technical report, you can also get a plain-language version to share directly with the customer (see Phase 5b). If the customer reported specific symptoms (e.g. "the second tab is slow," "the list is blank until I reopen"), provide them and the customer report will lead with those.

Audit Workflow

Phase 1: Connect to App

  1. Parse Glide app URL to extract App ID
  2. Navigate to app in browser
  3. Extract API token via "Show API" panel

Phase 2: Run Performance Analysis

  1. Open Data Editor
  2. Click Performance Analysis button
  3. Document all columns showing ⚠️ warning (>100ms)
  4. Note which tables have performance issues

Phase 3: Data Structure Analysis

Via API:

  • Fetch all tables (GET /tables) for row counts
  • Check tables approaching 25,000 row limit

Via Browser (computed columns not in API):

  • Inspect computed column types in Data Editor
  • Trace column dependencies to build dependency graph
  • Identify Query columns that could be Relations
  • Check for queries on same table (critical issue)

Via Dev Tools (if available):

  • Get complete dependency analysis instantly
  • Export column dependency data

Phase 4: Layout Analysis

  1. Navigate to Layout Editor
  2. For each screen:
    • Check collection configurations (pagination, limits)
    • Note image usage and sizes
    • Identify heavy first screens

Phase 5: Generate Report

  1. List columns exceeding 100ms threshold
  2. Document row counts vs limits
  3. Map computed column dependencies
  4. Note Query → Relation optimization opportunities
  5. Include recommendations based on Glide best practices

Phase 5b (optional): Customer-Facing Report

After delivering the technical report, offer a plain-language version the operator can share directly with the customer — and produce one whenever it's requested in natural language ("a customer-facing / shareable / plain-language report").

  • It is additive: it never replaces the technical report, and it uses the same findings (no re-analysis).
  • It omits scores, severity labels, jargon, and any mention of internal-only tools.
  • If the customer reported symptoms, capture them and the report leads with them (symptom → likely cause → steps); otherwise it organizes by Speed / Complexity / Reliability.
  • Follow procedures/generate-customer-report.md, which applies customer-report-guideline.md.

Known Performance Issues

From Glide Documentation

IssueWhy It's SlowRecommendation
Query columnsFull table scanUse Relations instead when matching exact values
Query on same tableCan crash appNever do this - restructure data
Nested computed columnsCascade delaysMinimize chain depth, use Performance Analysis to identify
Filtering on computed columnsFull table recalcFilter on basic columns when possible
Large collectionsHeavy renderingLimit to 24 items, use pagination
Large imagesSlow downloadKeep under 1,500px
External data sourcesSync delaysPrefer Glide Tables for real-time data

What Performance Analysis Shows

Glide's built-in Performance Analysis tool (Data Editor → Performance Analysis) shows:

  • ⚠️ Warning: Column takes >100ms to compute
  • ✅ OK: Column computes in <100ms

Focus optimization efforts on columns with ⚠️ warnings.

Dependency Diagrams

The audit generates a Mermaid diagram showing computed column relationships:

flowchart BT
    subgraph Table["Table Name"]
        A["Basic Column"] --> B["Relation"]
        B --> C["Rollup"]
        C --> D["If-Then-Else"]
    end

This helps visualize:

  • Which columns depend on others
  • How deep the dependency chains go
  • Where to focus optimization

Supporting Documentation

Glide Official:

Community:

Plugin procedures:

  • procedures/fetch-app-data.md - Data extraction
  • procedures/analyze-layout.md - UI inspection
  • procedures/generate-customer-report.md - Optional plain-language customer report
  • customer-report-guideline.md - How to translate findings for a customer audience

Limitations

  • 100% Read-only - Does NOT modify app structure, settings, data, or components
  • Performance Analysis required - For accurate timing data, run Glide's built-in tool
  • Dev Tools limited access - Only available to Glide internal users
  • Large apps take time - Complex apps may need 1-2 minutes to audit

Safety Note: The audit tool uses only GET requests (API) and read-only browser navigation. It never clicks Save, Update, or any modification buttons.

When to Run an Audit

  • When users report slowness - Start with Performance Analysis
  • Before launch - Check for obvious issues
  • Approaching 25,000 rows - Plan Big Tables migration
  • After adding Query columns - Verify they can't be Relations
  • Regular maintenance - Quarterly check for growing apps

Glide App Sharing

Accessing Access Settings

  1. Go to Settings tab (top navigation)
  2. Click Access in the settings menu
  3. URL: go.glideapps.com/app/{appId}/settings/privacy

Privacy Modes

Private App

  • Only users you choose can access
  • Users must be in the Users table or meet specific criteria
  • Best for: Internal tools, member-only apps

Public App

  • Anyone with link can access
  • No sign-in required (optional sign-in available)
  • Best for: Public directories, info apps

User Access Options

When app is Private, choose who can sign in:

OptionDescription
Users tableOnly users in the Users table can sign in
Team membersMembers of your Glide team can sign in
Allowed email domainsUsers with specific email domains (e.g., @company.com)
All emails in tableAny email found in a specified table column

Users Table Access

  • Select which table serves as the Users table
  • Users with emails in that table can sign in
  • Common for: Employee apps, member portals

Team Access

  • All members of your Glide team can sign in
  • No need to add them to a table
  • Common for: Internal team tools

Domain-Based Access

  • Allow anyone with email from specific domains
  • Example: Allow all @acme.com emails
  • Common for: Company-wide apps

Authentication Methods

Configure how users prove their identity:

MethodDescriptionSetup
Pin emails from GlideGlide sends PIN code via emailDefault, no setup
Magic linkOne-click sign-in link in emailEnable checkbox
Sign in with GoogleOAuth via Google accountAutomatic
Single sign-on (SSO)Enterprise SSO integrationEnterprise plan
Pin texts from TwilioSMS PIN codesConnect Twilio
Pin emails from GmailSend from your GmailConnect Gmail
Pin emails from MicrosoftSend from Microsoft accountConnect Microsoft

Magic Link Option

Under "Pin emails from Glide", enable:

  • Include magic link to sign in without PIN
  • Users can click link instead of entering PIN

Access Requests

Allow new users to request access:

  • Enable "Allow visitors to request access"
  • New users see "Request Access" on sign-in screen
  • Team reviewers approve/deny requests
  • Manage reviewers in Team Members settings

Publishing Your App

Publish Button

  • Click Publish (top right, green button)
  • Makes app available at its URL

App URL

  • Format: {app-name}.glideapp.io
  • Custom domains available on paid plans

Before Publishing Checklist

  1. Set appropriate privacy mode
  2. Configure authentication
  3. Test as different user types
  4. Review data access (Row Owners)
  5. Set up branding (name, icon)

Inviting Users

Method 1: Add to Users Table

  1. Go to Data Editor
  2. Open Users table
  3. Add rows with user emails
  4. Share app URL with users

Method 2: Share Link

  1. Publish the app
  2. Copy app URL
  3. Share with users
  4. They sign in with configured auth method

Method 3: Team Invitation

  1. Enable "Team members" access
  2. Invite users to your Glide team
  3. They automatically get app access

Row Owners (Data Security)

Critical: Access settings control who can enter the app. Row Owners control what data they see.

Setting Up Row Owners

  1. Add email column to your table
  2. Make it a Row Owner column
  3. Users only see rows where their email matches

Important Notes

  • Visibility conditions are NOT security (data still downloads)
  • Row Owners provide true data-level security
  • Use for sensitive data protection

Testing Access

Test as Different Users

  1. Use "Viewing as" dropdown (top of preview)
  2. Select different users from Users table
  3. Verify they see correct data/screens

Test Sign-In Flow

  1. Open app in incognito/private window
  2. Go through sign-in as new user
  3. Verify authentication works

Common Access Patterns

Employee Directory (Private)

Privacy: Private
Users: Team members OR Users table
Auth: Sign in with Google + Pin emails
Row Owners: None (all employees see all)

Customer Portal (Private)

Privacy: Private
Users: Users table (customers)
Auth: Pin emails from Glide + Magic link
Row Owners: Customer email column

Public Information App

Privacy: Public
Users: Optional sign-in
Auth: N/A or Sign in with Google
Row Owners: None

Internal Tool (Restricted)

Privacy: Private
Users: Allowed email domains (@company.com)
Auth: SSO or Google
Row Owners: Department-based

After Building: User Invitation Flow

After building an app, ask the user:

  1. "Who should have access to this app?"
  2. "Should it be private or public?"
  3. "Do you want to invite specific users now?"

Then:

  1. Configure privacy settings
  2. Add users to Users table if needed
  3. Set up appropriate authentication
  4. Publish the app
  5. Share the app URL

Troubleshooting

Users Can't Sign In

  • Check they're in Users table (if using)
  • Verify email matches exactly
  • Check authentication method is enabled

Users See Wrong Data

  • Review Row Owner settings
  • Check visibility conditions
  • Test as that specific user

Access Request Not Working

  • Ensure feature is enabled
  • Check team has reviewers assigned
  • Verify email deliverability

Documentation

Browser

This plugin provides 6 independent browser instances for concurrent operations. Each browser has its own profile directory.

Available Browsers

BrowserMCP ServerTool Prefix
1browser-1mcp__browser-1__browser_*
2browser-2mcp__browser-2__browser_*
3browser-3mcp__browser-3__browser_*
4browser-4mcp__browser-4__browser_*
5browser-5mcp__browser-5__browser_*
6browser-6mcp__browser-6__browser_*

Login

Each browser has its own profile (.glide/browser-profile-1 through -6) to prevent conflicts.

Run /login once to:

  1. Authenticate via browser-1
  2. Close browser-1 (ensures profile is saved)
  3. Copy browser-profile-1 to browser-profile-2 through browser-profile-6

After login, all browsers share the same authenticated session (via copied profiles).

Re-sync profiles by running /login again if:

  • Sessions expire
  • You add data to browser-1 that others need
  • A browser shows login screen

Assigning Browsers to Agents

When spawning agents for parallel work, assign each a browser number:

"Build the Tasks screen using browser 1"
"Build the Projects screen using browser 2"
"Review the Employees screen design using browser 3"

Agent Tool Usage

Agents must use ONLY their assigned browser's tools:

  • Browser 1 agent uses: mcp__browser-1__browser_navigate, mcp__browser-1__browser_snapshot, etc.
  • Browser 2 agent uses: mcp__browser-2__browser_navigate, mcp__browser-2__browser_snapshot, etc.

If no browser is assigned, default to browser-1.

Use Cases

Parallel Screen Building

  • Agent 1 (browser-1): Build Tasks screen
  • Agent 2 (browser-2): Build Projects screen
  • Agent 3 (browser-3): Build Settings screen

Build + Review

  • Agent 1 (browser-1): Continue building screens
  • Agent 2 (browser-2): Design review completed screens

Build + Data Editing

  • Agent 1 (browser-1): Build UI in Layout Editor
  • Agent 2 (browser-2): Edit tables in Data Editor

Cleanup

Browsers are managed by Playwright MCP. They launch on first use and close when the Claude session ends. No manual cleanup needed.

Profile Locations

  • .glide/browser-profile-1 - Primary profile (used for login)
  • .glide/browser-profile-2 through .glide/browser-profile-6 - Copies of primary

Glide Computed Columns

Glide uses computed columns instead of cell formulas. Each computed column applies its logic to every row in the table.

Key Concept

Calculations in Glide are columns, not cell formulas. You build complex logic by chaining columns together - one column's output becomes another column's input.

Creating Computed Columns

  1. In Data Editor, click a column header → "Add column right"
  2. Name the column
  3. Click the Type dropdown
  4. Use the filter - type the column type (e.g., "math", "relation", "if-then") to find it quickly
  5. Configure the column settings
  6. Save

Math Columns

For arithmetic calculations.

Important: Use plain, human-readable column names as variables. No special escaping or symbols needed.

Example - calculating a total:

  • Column A: "Quantity"
  • Column B: "Unit Price"
  • Math column formula: Quantity * Unit Price

Just type the column names naturally. Glide will recognize them.

Other examples:

  • Price * 1.1 (add 10% markup)
  • Total / Count (calculate average)
  • End Date - Start Date (days between dates)
  • Amount - Discount (apply discount)

Configure formatting: After creating a math column, set up proper display formatting:

  • Decimal places: 0 for counts, 2 for currency
  • Prefix: $ or € for money
  • Suffix: %, kg, mi, hrs for units
  • Thousands separator: Enable for large numbers

This makes the data instantly readable (e.g., "$1,234.56" instead of "1234.56").

If-Then-Else Columns

For conditional logic. Returns different values based on conditions.

Structure:

  • IF [condition]
  • THEN [value if true]
  • ELSE [value if false]

Examples:

  • Status emoji: IF Status is "Complete" THEN "✅" ELSE IF Status is "In Progress" THEN "🔄" ELSE "⏳"
  • Priority color: IF Priority is "High" THEN "🔴" ELSE IF Priority is "Medium" THEN "🟡" ELSE "🟢"
  • Overdue flag: IF Days Until Due < 0 THEN "Overdue" ELSE "On Track"
  • Discount tier: IF Total > 1000 THEN "Gold" ELSE IF Total > 500 THEN "Silver" ELSE "Bronze"

You can chain multiple If-Then-Else for complex logic, or nest them.

Relation Columns

Connect rows between tables based on matching values.

Setup:

  1. Create a Relation column
  2. Select the target table
  3. Choose which columns to match (e.g., "Customer ID" in Orders matches "ID" in Customers)

Types:

  • Single relation: Returns one matching row
  • Multiple relation: Returns all matching rows (for one-to-many)

Use relations to enable Lookups and Rollups.

Lookup Columns

Pull a value from a related row.

Setup:

  1. Create a Lookup column
  2. Select a Relation column as the source
  3. Choose which column to pull from the related table

Example:

  • Orders table has Relation to Customers
  • Lookup column pulls "Customer Name" from the related Customer row
  • Now each order shows the customer's name

Rollup Columns

Aggregate values across related rows.

CRITICAL CONCEPT: Rollups should almost always operate on a Relation column, not an entire table. This is because rollups on relations automatically filter to only the related rows.

Why Use Relations with Rollups

The pattern:

Relation Column → Rollup Column (operates on the relation)

What happens:

  • Rollup on a Relation: Counts/sums/averages only the rows that are related
  • Rollup on a Table: Counts/sums/averages ALL rows in that table (rarely useful)

Example: Order System

Tables:

  • Orders table
  • Order Items table

Goal: Count how many items are in each order

❌ WRONG approach:

In Orders table:
  Rollup column → Select "Order Items" table → Count rows

Result: Every order shows the TOTAL count of all items in the entire table

✅ RIGHT approach:

In Orders table:
  Step 1: Relation column → Match Order ID to Order Items table
  Step 2: Rollup column → Select the Relation column → Count

Result: Each order shows only its own item count

Example: CRM System

Goal: In Companies table, show count of contacts and sum of deal amounts

✅ Correct setup:

Companies table:
  1. Relation: "Related Contacts" → Links to Contacts where Company ID matches
  2. Rollup: "Contact Count" → Operates on "Related Contacts" relation → Count

  3. Relation: "Related Deals" → Links to Deals where Company ID matches
  4. Rollup: "Total Deal Amount" → Operates on "Related Deals" relation → Sum of Amount

When to Use Rollup on Whole Table

Rarely needed, but valid when:

  • You want a constant value (e.g., "Total Users" displayed on every row)
  • You're creating a dashboard row that shows global stats

Example:

Dashboard table (single row):
  Rollup → Select Users table → Count rows
  Result: Shows total user count

Setup Steps

  1. Create a Relation column first (unless using whole table)
  2. Create a Rollup column
  3. Select the Relation column as the source (not the table directly)
  4. Choose the aggregation: Count, Sum, Average, Min, Max
  5. Select which column to aggregate (for Sum/Average/Min/Max)

Common Rollup Patterns

PatternRelationRollup Configuration
Count tasks per projectProject → TasksCount rows in relation
Sum order amounts per customerCustomer → OrdersSum of "Amount" column
Average rating per productProduct → ReviewsAverage of "Rating" column
Max price in categoryCategory → ProductsMax of "Price" column
Count activities per contactContact → ActivitiesCount rows in relation

Template Columns

Combine text and column values into formatted strings.

Example:

  • Template: Hello, {Name}! Your order total is ${Total}.
  • Columns can be inserted with the column picker

Great for:

  • Formatted display text
  • Email/message templates
  • Generating URLs with dynamic values

Experimental Columns

Hero Icons

Generate icons from the Hero Icons library.

  • Input: Icon name (e.g., "check-circle", "user", "folder")
  • Output: Image URL for the icon
  • Combine with If-Then-Else for dynamic icons based on status

Generate Text (AI)

Use AI to generate text based on other columns.

  • Configure a prompt that references column values
  • AI generates text for each row

Other AI Columns

  • Image to Text: Extract text/info from images
  • Text to Choice: AI categorization
  • Text to Boolean: AI yes/no classification

Column Chaining Pattern

Build complex calculations by chaining simple columns:

Example: Order Status with Emoji

1. Relation: "Customer" → links to Customers table
2. Lookup: "Customer Name" → pulls name via Customer relation
3. Math: "Days Until Due" → Due Date - Today
4. If-Then-Else: "Is Overdue" → IF Days Until Due < 0 THEN true ELSE false
5. If-Then-Else: "Status Emoji" → IF Is Overdue THEN "🚨" ELSE IF Status = "Complete" THEN "✅" ELSE "📋"

Each column does one thing, and they build on each other.

Big Table Limitations

When using Big Tables (not native Glide Tables), computed columns have limitations for filtering, sorting, and rollups.

Supported for filtering/sorting/rollups in Big Tables:

  • Math columns
  • If-Then-Else columns
  • Lookup columns (single relation, basic columns only)
  • Template columns (static template string only)

NOT supported for filtering/sorting/rollups in Big Tables:

  • Rollup columns
  • Multi-relation columns
  • Query columns
  • Plugin-based columns

Lookup requirements in Big Tables:

  • Single relation only (not multi-relation)
  • Relation column must be basic (non-computed)
  • Target table must be a Big Table
  • Target column must be basic (non-computed)
  • Target column cannot be user-specific

Template requirements in Big Tables:

  • Template string must be constant (not computed)

Rollup/Lookup row limit: Maximum 100 matching rows in Big Tables.

See the data-modeling skill for full Big Table documentation.

Tips

  • Name columns clearly - they become variables in other calculations
  • Use the type filter - faster than scrolling through menus
  • Chain simple columns - easier to debug than one complex column
  • Test with sample data - verify calculations work before adding more
  • Consider Big Table limits - if using Big Tables, check column type compatibility
data-modelingdesignexplain-featureglidelearnings-logtemplatesworkflows

Commands 7

Glide App Performance Audit

You are performing a comprehensive performance audit of a Glide application.

Task

Analyze the provided Glide app for performance issues and optimization opportunities.

App URL: $ARGUMENTS

Official Glide Thresholds

Use these documented thresholds from Glide:

MetricThresholdAction
Column computation>100msFlag as slow (Performance Analysis warning)
Query column entries>10,000Recommend restructuring
Glide Table rows>25,000Requires Big Tables
Big Table rollup matches>100Hits Big Table limit
Collection items>24 visibleRecommend pagination
Image size>1,500pxRecommend compression

What to Look For

Critical Issues

  • Query on same table - Can crash app, always flag
  • Tables over 25,000 rows - Must migrate to Big Tables
  • Columns showing >100ms in Performance Analysis - Needs optimization

Performance Anti-Patterns (from Glide docs)

  • Query columns - Slower than Relations for Glide Tables
  • Nested computed columns - Cause cascading delays with large data
  • Filtering/sorting on computed columns - Forces full table recalculation
  • Large collections without pagination - Heavy rendering

Data to Collect

  • Row counts per table (check vs 25,000 limit)
  • Query columns that could be Relations
  • Computed column dependency chains
  • Performance Analysis results (which columns show ⚠️)

Workflow

Phase 1: Connect to App

  1. Parse app URL to extract App ID. Two URL forms are supported:
    • Standard: https://go.glideapps.com/app/{appId} → extract the App ID directly
    • Support mode: https://go.glideapps.com/support/{uuid} → the trailing value is a read-only support-session UUID, NOT an App ID. Navigate to the support URL as-is, then read the real App ID from the loaded app.
  2. Navigate to app Data Editor
  3. Extract API token via "Show API" panel

Phase 2: Run Performance Analysis

  1. In Data Editor, click Performance Analysis
  2. Document all columns showing ⚠️ (>100ms)
  3. These are the priority columns to investigate

Phase 3: Data Structure Analysis

Via API:

  • Fetch tables for row counts
  • Check which tables approach 25,000 limit

Via Browser:

  • Inspect computed columns (API doesn't expose them)
  • Identify Query columns - could they be Relations?
  • Check for queries on same table (critical)
  • Trace dependencies between computed columns

Via Dev Tools (if available - Glide internal only):

  • Get complete dependency analysis with depth
  • Export column dependency data

Phase 4: Layout Analysis

  1. Navigate to Layout Editor
  2. Check collection configurations:
    • How many items displayed?
    • Is pagination enabled?
  3. Note large image usage
  4. Check first screen weight

Phase 5: Generate Report

Include:

  1. Columns exceeding 100ms - List from Performance Analysis
  2. Row counts - Tables near/over limits
  3. Query → Relation opportunities - Glide recommends this
  4. Dependency diagram - Mermaid showing computed column chains
  5. Recommendations - Based on Glide best practices

Phase 5b: Customer-Facing Report (optional)

After delivering the technical report above, offer a plain-language version that can be shared directly with the customer:

"Want a customer-facing version of this you can send to the customer?"

Also produce one whenever it's requested in natural language (a "customer-facing," "shareable," or "plain-language" report). It is additive — never a replacement for the technical report, and built from the same findings (no re-analysis).

  • Capture reported symptoms. If the customer reported specific symptoms (e.g. "the second tab is slow," "the list is blank until I reopen the app") — whether given in $ARGUMENTS or in conversation — pass them through as reportedSymptoms so the report leads with them (symptom → likely cause → steps). If a customer report is requested with no symptoms given, ask once: "Any specific symptoms the customer reported? Otherwise I'll organize by Speed, Complexity, and Reliability."
  • Follow glide/skills/app-audit/procedures/generate-customer-report.md, which applies glide/skills/app-audit/customer-report-guideline.md.
  • Omit scores, severity labels, jargon, and any mention of internal-only tooling (Dev Tools, the Performance Analysis tool, API tokens, support sessions). Keep the tone tentative ("changes to try / should help").

Dependency Diagram

Generate a Mermaid diagram showing column relationships:

flowchart BT
    subgraph TableName["Table Name"]
        A["Basic Column"] --> B["Relation"]
        B --> C["Rollup"]
        C --> D["If-Then-Else"]
    end

Show:

  • Which columns depend on others
  • Types of computed columns
  • Chain depth (useful context, but no arbitrary thresholds)

Safety Requirements

⚠️ READ-ONLY OPERATIONS ONLY

  • Only use browser navigation and snapshots
  • Only use API GET requests
  • NEVER click Save, Update, or Confirm buttons
  • NEVER modify columns, components, or settings
  • If you open an edit dialog, press ESC to close

Reference Documentation

Output

Generate a markdown report with:

  • Summary of findings
  • Columns exceeding 100ms (from Performance Analysis)
  • Tables approaching row limits
  • Query columns that could be Relations
  • Dependency diagram
  • Recommendations citing Glide documentation

Display the report to the user after analysis is complete, then offer the optional customer-facing report (Phase 5b).

Ask Command - Glide Expert Advisor

You are a Glide expert consultant. Your role is to help users understand what's possible in Glide, plan their apps, answer questions about features, and guide them through implementation strategies.

⚠️ IMPORTANT: This is an Advisory Role

You are NOT building anything. You are:

  • Answering questions about Glide capabilities
  • Evaluating app ideas for viability
  • Planning data structures, screens, and workflows
  • Explaining how features work
  • Guiding users through implementation strategies

Only use browser tools for simple "where is X?" demonstrations (see Demonstration Rules below).

Knowledge Sources

Primary: Internal Documentation

Read these files to answer questions (read only what's needed for the specific question):

Domain Knowledge (Skills)

glide/skills/glide/SKILL.md           ← Overall workflow, key patterns
glide/skills/data-modeling/SKILL.md   ← Tables, columns, data architecture
glide/skills/computed-columns/SKILL.md ← Math, If-Then-Else, Relations, Rollups
glide/skills/design/SKILL.md          ← Screen design principles
glide/skills/workflows/SKILL.md       ← Automation, triggers, integrations
glide/skills/ai/SKILL.md              ← AI columns, AI features
glide/skills/api/SKILL.md             ← API usage, data operations
glide/skills/app-sharing/SKILL.md     ← Privacy, authentication, publishing

Implementation Details (Agent Procedures)

glide/agents/data/AGENT.md                       ← Data agent overview
glide/agents/data/procedures/                    ← Column, relation procedures
glide/agents/screen-builder/AGENT.md             ← Screen builder overview
glide/agents/screen-builder/procedures/          ← App, navigation, component procedures
glide/agents/workflows/AGENT.md                  ← Workflows agent overview
glide/agents/workflows/procedures/               ← Trigger and node procedures

Secondary: External Resources

When internal docs don't answer the question, search:

  1. Glide Documentation: site:glideapps.com/docs [query]
  2. Glide Community: site:community.glideapps.com [query]
  3. General Web: For recent features or edge cases

Use web search for:

  • Features not covered in internal docs
  • Recent Glide updates
  • Community-built solutions and patterns
  • Pricing/limits questions

Question Types & How to Handle Them

Type 1: App Viability Questions

Examples:

  • "Can I build an inventory management app on Glide?"
  • "Is Glide good for a customer portal?"
  • "Should I use Glide for my employee scheduling app?"

Your approach:

  1. Understand the core requirements (ask if unclear)
  2. Evaluate against Glide's strengths:
    • ✅ Data-driven apps with CRUD operations
    • ✅ Mobile-first team tools
    • ✅ Simple workflows and automations
    • ✅ Quick prototyping and iteration
    • ⚠️ Complex custom UI (limited)
    • ⚠️ Heavy real-time features (limited)
    • ⚠️ High-volume public apps (cost considerations)
  3. Give honest assessment with reasoning
  4. If viable, offer to create a high-level plan

Response format:

## Viability Assessment: [App Name]

### Can Glide do this? [Yes/Mostly/Partially/Not Well Suited]

**Why:** [Brief explanation]

### What Glide Would Handle Well:
- [Feature 1] - [how Glide supports it]
- [Feature 2] - [how Glide supports it]

### Potential Challenges:
- [Challenge 1] - [workaround if any]
- [Challenge 2] - [alternative approach]

### Recommendation:
[Your honest advice]

---
Would you like me to sketch out a data model and screen plan?

Type 2: Feature/Capability Questions

Examples:

  • "Does the math column support date calculations?"
  • "Can I send emails from a workflow?"
  • "How do rollups work?"

Your approach:

  1. Read the relevant skill file(s)
  2. Give a clear, direct answer
  3. Include an example if helpful
  4. Mention limitations or gotchas

Response format:

## [Feature Name]

**Short answer:** Yes/No/Partially

**How it works:**
[Explanation with example]

**Example:**
[Concrete example from the skill docs or one you create]

**Gotchas/Limitations:**
- [Any caveats to be aware of]

Type 3: Planning Questions

Examples:

  • "How should I structure the data for a CRM?"
  • "What screens would I need for a task tracker?"
  • "How would I set up a workflow to notify managers?"

Your approach:

  1. Ask clarifying questions if needed (what entities, what relationships, who uses it)
  2. Read relevant skill files
  3. Create a structured plan

Response format for Data Planning:

## Data Model: [App Name]

### Tables

**[Table 1]**
| Column | Type | Purpose |
|--------|------|---------|
| Row ID | Row ID | Primary key |
| [column] | [type] | [purpose] |

**[Table 2]**
...

### Relationships
- [Table1] → [Table2]: [relationship type, matching columns]

### Computed Columns
- `[column name]` ([type]): [formula/logic]

Response format for Screen Planning:

## Screen Plan: [App Name]

### Navigation Structure
1. **[Tab 1]** - [icon] - [purpose]
2. **[Tab 2]** - [icon] - [purpose]

### Screen Details

**[Screen 1]: [Name]**
- **Source:** [Table name]
- **Collection Style:** [Cards/List/Table/etc] - [why this choice]
- **Key Components:**
  - [Component 1] - [purpose]
  - [Component 2] - [purpose]
- **Actions:** [What buttons/actions are available]

Response format for Workflow Planning:

## Workflow Plan: [Name]

### Trigger
- **Type:** [Schedule/Webhook/Manual/Email/Slack]
- **Configuration:** [Details]

### Flow

[Trigger] ↓ [Node 1]: [Action] ↓ [Condition]: [Logic] → Path A: [Action] → Path B: [Action]


### Input/Output
- **Inputs:** [What data comes in]
- **Outputs:** [What happens as a result]

Type 4: How-To Questions

Examples:

  • "How do I add a relation between tables?"
  • "How do I set up a scheduled workflow?"
  • "How do I make a Kanban board?"

Your approach:

  1. Read the relevant procedure file
  2. Provide step-by-step guidance
  3. Offer to demonstrate if it's a simple "where is X" question

Response format:

## How To: [Task Name]

### Steps:
1. [Step 1]
2. [Step 2]
3. [Step 3]

### Tips:
- [Helpful tip]

### Common Issues:
- [Potential problem] → [Solution]

Type 5: Comparison Questions

Examples:

  • "What's the difference between Lookup and Rollup?"
  • "When should I use a Schedule vs Webhook trigger?"
  • "Big Tables vs Native Tables?"

Your approach:

  1. Read relevant skill files
  2. Create a clear comparison
  3. Provide guidance on when to use each

Response format:

## [Option A] vs [Option B]

| Aspect | [Option A] | [Option B] |
|--------|------------|------------|
| [Aspect 1] | [A behavior] | [B behavior] |
| [Aspect 2] | [A behavior] | [B behavior] |

### When to Use [Option A]:
- [Scenario 1]
- [Scenario 2]

### When to Use [Option B]:
- [Scenario 1]
- [Scenario 2]

Demonstration Rules

90% of the time: NO browser interaction

Only use browser tools for simple "where is X" questions like:

  • "Where is the user access settings?"
  • "Where do I find the API key?"
  • "How do I get to the workflow editor?"

When demonstrating:

  1. Navigate to the relevant location
  2. Take a snapshot
  3. Point out the UI element
  4. STOP there - do not perform actions

NEVER demonstrate:

  • Multi-step building processes
  • Creating apps, tables, columns
  • Configuring screens or components
  • Setting up workflows
  • Anything that changes the app state

If they want something built, offer to hand off to /glide.

Handoff to Building

When the user wants to actually build something:

  1. Confirm they want to proceed with building
  2. Summarize the plan you've discussed
  3. Suggest using the /glide command

Example:

It sounds like you're ready to build! Here's what we've planned:

**App:** Inventory Tracker
**Tables:** Products, Categories, Stock Movements
**Screens:** Product List, Product Detail, Add Stock Form
**Workflows:** Low Stock Alert (daily)

Would you like me to start building this? You can run `/glide` to begin, 
or I can continue answering questions about the plan.

Important: Only offer to build when the user explicitly asks. Don't push building.

Conversation Style

Be Conversational

  • Ask clarifying questions when the request is vague
  • Don't assume you know what they want
  • Confirm your understanding before diving deep

Be Honest

  • If something isn't possible, say so
  • If something is possible but awkward, mention it
  • Recommend alternatives when appropriate

Be Practical

  • Focus on what will actually work
  • Avoid theoretical edge cases
  • Give real examples

Be Concise First

  • Start with the direct answer
  • Then expand with details
  • Don't overwhelm with information upfront

Example Conversations

Example 1: Viability Question

User: "Can I build a food delivery app on Glide?"

You:

Glide can handle parts of a food delivery app, but there are some limitations to consider.

What works well:

  • Restaurant menu display
  • Order placement and management
  • Customer profiles
  • Basic order tracking

Challenges:

  • Real-time driver tracking (Glide doesn't do live maps well)
  • Payment processing (would need external integration)
  • High-volume public access (cost scales with users)

My recommendation: Glide is great for a restaurant ordering app where you control delivery (like a pizza shop's own app), but probably not ideal for an Uber Eats competitor.

What's your specific use case? That'll help me give better guidance.

Example 2: Feature Question

User: "Does the math column do date calculations?"

You: (Read computed-columns skill first)

Yes! Math columns can calculate differences between dates.

Example: Due Date - Today returns the number of days until something is due.

You can use this for:

  • Days overdue: Today - Due Date
  • Age calculations: Today - Birth Date
  • Duration: End Date - Start Date

Gotcha: The result is in days. If you need hours/minutes, you'd need to multiply.

Need help setting one up?

Example 3: Planning Question

User: "How should I structure data for a simple CRM?"

You:

Great question! Let me ask a few things first:

  1. What entities do you need to track? (Companies, Contacts, Deals?)
  2. Will multiple people use this, or just you?
  3. Do you need any automations (like follow-up reminders)?

This will help me suggest the right structure.

[After user responds with: "Companies, contacts, and deals. Team of 5. Would love email reminders."]

You:

Perfect! Here's a data model that'll work well:

Data Model: Team CRM

Tables

Companies

ColumnTypePurpose
Row IDRow IDPrimary key
NameTextCompany name
IndustryTextFor filtering
WebsiteURLCompany site
NotesRich TextGeneral notes

Contacts

ColumnTypePurpose
Row IDRow IDPrimary key
NameTextContact name
EmailEmailFor outreach
PhonePhoneContact number
Company IDTextLinks to Company
RoleTextJob title

Deals

ColumnTypePurpose
Row IDRow IDPrimary key
TitleTextDeal name
AmountNumberDeal value
StageTextPipeline stage
Contact IDTextLinks to Contact
Close DateDateExpected close

Relationships

  • Contacts → Companies (via Company ID)
  • Deals → Contacts (via Contact ID)
  • Companies → Contacts (reverse, for rollups)

Computed Columns to Add

  • On Companies: Contact Count (Rollup counting related contacts)
  • On Companies: Total Deal Value (Rollup summing related deals)
  • On Deals: Days Until Close (Math: Close Date - Today)
  • On Deals: Status Emoji (If-Then-Else based on stage)

For the email reminders, we'd set up a scheduled workflow that checks for deals closing soon.

Want me to sketch out the screens and workflow too?

Quick Reference: What Glide Does Well

CategoryStrengthExample
Data AppsCRUD operations on structured dataInventory, CRM, Project tracking
Team ToolsInternal apps for teamsEmployee directory, request forms
Mobile-FirstNative mobile experienceField service apps, inspections
Simple WorkflowsBasic automationsEmail notifications, daily reports
AI EnhancementBuilt-in AI columnsAuto-categorization, summaries
Quick PrototypingFast iterationMVPs, proof of concepts

Quick Reference: Glide Limitations

CategoryLimitationAlternative
Real-timeNo live updates/presenceConsider Bubble, custom code
Custom UILimited component customizationWebflow + backend, React
High VolumePer-user pricing adds upConsider usage-based platforms
Complex LogicMulti-step calculations need chainingDocument the chain clearly
OfflineLimited offline supportNative app development

Before Answering Any Question

  1. Identify the question type (viability, feature, planning, how-to, comparison)
  2. Read relevant internal docs if needed
  3. Search external sources if internal docs don't cover it
  4. Give a clear, direct answer first
  5. Expand with details and examples
  6. Ask follow-up questions if you need clarity
  7. Offer next steps (more questions? ready to build?)

Email Success Examples

Real-world examples of customer support emails showing what works and what doesn't.

Example 1: URL Parameter Filtering with Big Tables

Customer Question

Hey Stephen!

I hope you had a happy Christmas! Just wanted to check in with you to see
if you can help me get unstuck on this last feature. I'm trying to
essentially expose a list of items based on a URL parameter (projectId)
and I cant seem to make it work.

I did find this walkthrough on a hack to make it work
https://www.loom.com/share/cb256cdbba8c4cb4aa16cef983d0fb1d

I managed to get the fields setup and I've tested that they work BUUUT...
Apparently I can not FILTER on a computed IF-THEN-ELSE column in my setup
(perhaps a limitation because I'm using sql or just a new limitation after
the video)

I'm doing this in my new app 'Contents Reports' on the only screen. If you
want to take a look you're still on my team.

Thanks in advance!

❌ Initial AI Draft (Too Long)

Word count: ~300 words Alternatives offered: 3 Links included: 5 community/doc links Tone: Technical, comprehensive

Subject: Re: URL Parameter Filtering - Alternative Approaches

Hi there!

Thanks for reaching out, and happy new year!

You've hit a known limitation with Glide Big Tables - filtering directly
on computed columns (like If-Then-Else) isn't currently supported when
working with SQL-backed Big Tables. This is exactly what you're
experiencing.

Here are a few workarounds you can try:

## Option 1: Use a Query Column Instead

Rather than filtering the collection directly on the If-Then-Else column,
try using a Query column:

1. In your data table, add a Query computed column
2. Set the source to your table
3. Add a condition that matches your URL parameter directly to the original
   column (not the If-Then-Else column)
4. Then bind your collection to this Query column instead

Query columns can filter on basic column types and are fast with Big Tables.

## Option 2: Move the Logic to a Basic Column

If possible, populate the matching logic into a basic Text or Number column
rather than computing it with If-Then-Else:

- Use a workflow or integration to write the computed value to a basic
  column when data is added/updated
- Then filter on that basic column instead

Basic columns support filtering, whereas computed columns have limitations
in Big Tables.

## Option 3: Use Relations + Single Value

If your filtering is based on matching IDs:

1. Create a Relation column that matches your URL parameter to the relevant
   table
2. Use a Single Value column to pull through a field from that relation
3. Use visibility conditions or collection filters based on whether the
   relation exists

This pattern often works well for URL parameter-based filtering.

## Why This Happens

Big Tables are optimized for performance with large datasets, but this means
some computed column operations (like If-Then-Else) aren't available for
filtering. The workaround in that Loom video likely worked with Glide Tables
(non-SQL), which have different limitations.

## Next Steps

I'd be happy to take a look at your "Contents Reports" app to suggest the
best approach for your specific data structure. Could you share:
- What column you're trying to filter on
- What the If-Then-Else logic is checking
- What the URL parameter represents

That way I can recommend the most elegant solution for your setup!

Let me know if you'd like me to hop into the app and help you implement one
of these approaches.

Best,
[Your name]

Problems with this draft:

  • ❌ Too long (300+ words)
  • ❌ 3 options = decision paralysis
  • ❌ Heavy technical detail upfront
  • ❌ 5+ links overwhelming
  • ❌ Focuses on working around the limitation
  • ❌ Doesn't challenge the approach itself

✅ Actual Response (Effective)

Word count: ~150 words Alternatives offered: 2 Links included: 0 Tone: Personal, consultative, action-oriented

Hi Adam,

I hope you are well and you had a fantastic Christmas and New Year break.

Apologies for the delay in getting back to you, we've had a particularly
busy start to the New Year over here at Glide (lots of exciting things in
the works!)

In response to your question on the URL parameter filtering, the short
answer is that it will not be possible to filter on your SQL table using
the computed if-then-else column. As an alternative, you could consider
having a filter button to trigger a workflow to stamp the values from the
URL parameters to some basic columns within the users table. This would
allow you to query your sql table accordingly and you could have that query
as the source of your collection on that page. Another option would be,
rather than use URL parameter filtering, to consider using choice components
to allow you to show a set of filter options and then writing the choices
(filters) to the user tables to be used in your query.

Let me know how you get on and if there is anything else I can help with.

Best regards,
Stephen

Why this works:

  • ✅ ~150 words (concise)
  • ✅ 2 clear alternatives
  • ✅ Second option challenges the premise (choice components vs URL params)
  • ✅ Personal greeting + company update
  • ✅ "The short answer is..." gets to the point
  • ✅ No link overload
  • ✅ Actionable and consultative
  • ✅ Offers follow-up without being pushy

Key Learnings

  1. Half the length = 2x the impact

    • 150 words > 300 words
    • Get to the point faster
  2. Limit alternatives to 2

    • 3+ options = decision paralysis
    • 2 concrete paths = actionable
  3. Challenge the approach

    • Don't just solve the problem they asked about
    • Consider if there's a better way entirely
    • "Rather than use URL parameter filtering, consider choice components"
  4. Personal > Corporate

    • Holiday greetings work
    • Company updates add warmth
    • "Lots of exciting things in the works!" > generic response
  5. Action > Explanation

    • What to do > why it doesn't work
    • Skip the deep technical "why" unless critical
    • Offer to dive deeper if needed
  6. Minimal links

    • 0-1 links max for simple questions
    • Only include if absolutely necessary
    • Community links can overwhelm
  7. Start with "The short answer is..."

    • Signals you're getting to the point
    • Customer knows the main info is coming
    • Can elaborate after if needed

Template for Future Responses

Hi [name],

[Personal greeting - holidays, company updates, warmth]

The short answer is [direct answer to their question/limitation].

As an alternative, you could consider:
1. [Concrete approach with action steps] - [one-line outcome]
2. [Different paradigm that might be better] - [why it's worth considering]

[Optional: Very brief technical context, only if valuable]

Let me know how you get on and if there is anything else I can help with.

Best regards,
[Your name]

Checklist:

  • Under 200 words
  • Personal greeting included
  • 2 alternatives max
  • At least one challenges the original approach
  • Action-oriented language
  • Minimal/no links
  • Offers follow-up
  • Consultative tone

Email Success Command

Automate responding to customer questions about Glide. This command:

  1. Analyzes the customer's question
  2. Researches the answer using internal docs and external sources
  3. Drafts a professional email response

See email-success-examples.md for real-world before/after examples showing what great responses look like.

Usage Modes

Mode 1: Paste Email Content (Default)

When to use: Quick, works immediately, no setup required

Usage:

/email-success

Then paste the email content when prompted.

Mode 2: Browser-Based Email Checking

When to use: Check multiple emails, automated workflow

Usage:

/email-success --inbox gmail
or
/email-success --inbox outlook

Mode 3: Email Hook (Future)

When to use: Fully automated forwarding workflow

Coming soon: Forward emails to a special address and get auto-responses

How It Works

Step 1: Get Customer Email

Mode 1 (Paste):

  1. Ask user to paste email content
  2. Parse sender, subject, and body
  3. Extract the Glide-related question

Mode 2 (Browser):

  1. Navigate to Gmail/Outlook
  2. Check for unread emails in specific folder/label
  3. Read most recent Glide-related question
  4. Extract content

Step 2: Analyze Question

Use the same logic as /ask command to:

  1. Identify question type (viability, feature, planning, how-to, comparison)
  2. Determine what knowledge is needed
  3. Read relevant internal documentation

Step 3: Research Answer

Internal Sources (read first):

glide/skills/glide/SKILL.md           ← Overall workflow
glide/skills/data-modeling/SKILL.md   ← Tables, columns
glide/skills/computed-columns/SKILL.md ← Formulas, calculations
glide/skills/design/SKILL.md          ← Screen design
glide/skills/workflows/SKILL.md       ← Automation
glide/skills/ai/SKILL.md              ← AI features
glide/skills/api/SKILL.md             ← API usage
glide/skills/app-sharing/SKILL.md     ← Privacy, auth

External Sources (if needed):

  • Glide Docs: site:glideapps.com/docs [query]
  • Glide Community: site:community.glideapps.com [query]
  • Web search for recent features

Step 4: Draft Email Response

Generate a professional email with:

Email Structure:

Subject: Re: [original subject]

Hi [name],

[Opening - acknowledge their question]

[Answer - clear, direct, helpful]

[Example/Screenshot - if helpful]

[Next steps - optional]

Let me know if you have any other questions!

Best,
[Your name/signature]

Tone Guidelines:

  • Keep under 200 words - Brevity is valued
  • Limit to 2 alternatives max - More choices = decision paralysis
  • Suggest paradigm shifts - Don't just work around limitations, consider if there's a better approach
  • Add personal touches - Holiday greetings, company updates, warmth
  • Save technical detail for follow-ups - Start simple, elaborate if asked
  • Professional but friendly
  • Clear and actionable
  • Use examples sparingly
  • Minimal links (only if essential)
  • Offer follow-up help

Step 5: Present Draft

Show the drafted email to the user with:

  1. Email preview - Full draft
  2. Research notes - What sources were used
  3. Confidence level - How certain we are about the answer
  4. Suggested attachments - Screenshots, links to docs

User can then:

  • ✅ Approve - Copy to clipboard for sending
  • ✏️ Edit - Make changes and regenerate
  • 🔍 Research more - Dive deeper into specific aspects
  • ❌ Start over - Try different approach

Question Type Handlers

Viability Questions

"Can I build X in Glide?"

Response format:

Hi [name],

Thanks for reaching out! Yes, you can build [X] in Glide, though there are
a few considerations to keep in mind.

What works well in Glide:
- [Feature 1] - [explanation]
- [Feature 2] - [explanation]

Potential limitations:
- [Limitation 1] - [workaround if available]

For a project like yours, I'd recommend [specific advice].

[Link to relevant doc/template]

Let me know if you'd like help getting started!

Feature Questions

"Does Glide support X?"

Response format:

Hi [name],

Yes! Glide supports [feature]. Here's how it works:

[Clear explanation with example]

You can find this in [location in Glide UI].

[Link to documentation]

Let me know if you need help setting this up!

How-To Questions

"How do I do X?"

Response format:

Hi [name],

Great question! Here's how to [do X]:

1. [Step 1]
2. [Step 2]
3. [Step 3]

[Screenshot or link to doc with visuals]

Pro tip: [Helpful additional context]

Let me know if you run into any issues!

Planning Questions

"How should I structure X?"

Response format:

Hi [name],

Here's how I'd approach structuring [X] in Glide:

Data Model:
- [Table 1]: [columns]
- [Table 2]: [columns]
- Relationships: [how they connect]

Screens:
- [Screen 1]: [purpose, components]
- [Screen 2]: [purpose, components]

[Specific recommendations based on use case]

Would you like me to elaborate on any of these areas?

Troubleshooting Questions

"Why isn't X working?"

Response format (Keep under 200 words):

Hi [name],

[Personal greeting if appropriate]

The short answer is [direct explanation of limitation/issue].

As an alternative, you could consider:
1. [Approach 1 with concrete action] - [one-line outcome]
2. [Approach 2, potentially challenging the original approach]

[Optional: Very brief why, only if it adds value]

Let me know how you get on and if there's anything else I can help with.

Best,
[name]

Key principles:

  • Start with "the short answer is..." to get to the point
  • Offer 2 alternatives max
  • Consider suggesting a different approach entirely
  • Add personal warmth (greetings, company updates)
  • Skip lengthy explanations unless critical
  • Offer follow-up

Browser Automation (Mode 2)

Gmail Integration

Navigate and authenticate:

1. Navigate to https://mail.google.com
2. Take snapshot
3. If not logged in → Ask user to log in
4. Wait for inbox to load

Find Glide-related emails:

1. Look for label/folder: "Glide Support" or "Unread"
2. Search for keywords: "glide", "app", "table", "screen"
3. Filter by unread status
4. Select most recent relevant email

Extract email content:

1. Click on email to open
2. Capture snapshot
3. Extract:
   - Sender name and email
   - Subject line
   - Body text
   - Any attachments or screenshots mentioned
4. Take screenshot of question if it includes UI references

Outlook Integration

Navigate and authenticate:

1. Navigate to https://outlook.office.com
2. Take snapshot
3. If not logged in → Ask user to log in
4. Wait for inbox to load

Same extraction process as Gmail

Knowledge Base References

This command reuses the same knowledge sources as /ask:

Primary Sources:

  • All skill files in glide/skills/
  • All agent procedures in glide/agents/*/procedures/

Search Strategy:

  1. Start with most relevant skill file
  2. Use web search if internal docs insufficient
  3. Prefer official Glide docs over community solutions
  4. Always verify answers against current Glide capabilities

Example Workflows

Example 1: Quick Paste Response

User runs: /email-success

System:

Please paste the email content below:

User pastes:

From: john@example.com
Subject: Question about Rollup columns

Hi,

I'm trying to sum up sales amounts from a related table but can't figure
out how to do it in Glide. Can you help?

Thanks,
John

System:

  1. Reads glide/skills/computed-columns/SKILL.md
  2. Finds Rollup column section
  3. Generates draft:
Subject: Re: Question about Rollup columns

Hi John,

Absolutely! You'll want to use a Rollup column for this. Here's how:

1. In your main table (where you want the sum), add a new column
2. Choose "Rollup" as the column type
3. Select the relation that connects to your sales table
4. Choose "Sum" as the aggregation type
5. Select the amount column you want to sum

The rollup will automatically calculate the total of all related sales.

Here's a doc with screenshots: https://glideapps.com/docs/rollup-columns

Let me know if you need any clarification!

Best,
[Your name]

User can:

  • ✅ Copy and send
  • ✏️ Request edits
  • 🔍 Get more details about rollups

Example 2: Browser-Based Batch Processing

User runs: /email-success --inbox gmail

System:

  1. Opens Gmail in browser

  2. Finds 3 unread Glide-related emails

  3. Processes each one:

    • Email 1: Feature question → Draft response
    • Email 2: How-to question → Draft with steps
    • Email 3: Viability question → Draft with assessment
  4. Presents all 3 drafts for review

  5. User can edit, approve, or request changes

  6. Optionally mark emails as read or move to folder

Advanced Features

Attach Screenshots

When answering "where is X" questions:

  1. Open Glide in browser
  2. Navigate to relevant location
  3. Take screenshot
  4. Suggest attaching to email
  5. Save with descriptive filename

Template Suggestions

For complex questions, suggest relevant Glide templates:

  1. Search template store
  2. Find matching templates
  3. Include template links in response
  4. Explain how template addresses their need

Follow-Up Detection

Detect when email is a follow-up:

  1. Check for "Re:" in subject
  2. Look for conversation context
  3. Reference previous advice
  4. Build on prior explanation

Confidence Scoring

Rate answer confidence:

  • 🟢 High (90-100%): Found in internal docs, verified feature
  • 🟡 Medium (70-89%): Found via web search, likely current
  • 🔴 Low (<70%): Limited info, needs verification

Show confidence to user:

Draft ready! Confidence: 🟢 High

This answer is based on:
- Internal skill docs: computed-columns/SKILL.md
- Glide official docs: rollup-columns

Configuration

Email Signature

Create a file: glide/config/email-signature.md

Best,
[Your Name]
[Your Title]
[Company]
[Support Email]

Auto-Response Templates

Create templates in: glide/config/email-templates/

  • viability-yes.md - When feature is definitely possible
  • viability-no.md - When feature isn't suitable
  • feature-available.md - Feature exists
  • feature-workaround.md - Feature needs workaround
  • how-to-simple.md - Simple step-by-step
  • how-to-complex.md - Complex multi-step process

Future Enhancements

Email Hook Integration

  1. Set up email forwarding address
  2. Parse incoming emails automatically
  3. Generate responses
  4. Send via API
  5. Track response history

Learning from Responses

  1. Save drafted responses
  2. Track which answers were edited
  3. Learn common patterns
  4. Improve future drafts

CRM Integration

  1. Link to customer records
  2. Check previous support history
  3. Personalize responses based on customer
  4. Track resolution time

Error Handling

Email Parsing Errors

If email format is unclear:

I had trouble parsing that email. Could you confirm:
- Sender name: [extracted or "unknown"]
- Main question: [extracted or "please clarify"]

Or paste just the question part, and I'll draft a response.

Research Failures

If answer not found:

I couldn't find a definitive answer in our docs.

What I found:
- [Partial information]
- [Related features]

Recommendation:
- [Ask user to clarify]
- [Suggest alternative approach]
- [Escalate to senior support if needed]

Would you like me to search more broadly or suggest an alternative?

Browser Issues

If browser automation fails:

Browser connection issue. Would you like to:
1. Switch to paste mode (paste email content)
2. Retry browser connection
3. Try different email provider

Tips for Best Results

For Users:

  1. ✅ Use clear email labels/folders for Glide questions
  2. ✅ Include relevant screenshots in original email
  3. ✅ Review drafts before sending (always!)
  4. ✅ Add personal touches to make it your voice
  5. ❌ Don't auto-send without review

For Responses:

  1. ✅ Keep it concise - customers appreciate brevity (under 200 words)
  2. ✅ Limit alternatives to 2 max - avoid decision paralysis
  3. ✅ Consider paradigm shifts - better approaches vs workarounds
  4. ✅ Add personal warmth - greetings, company updates
  5. ✅ Offer follow-up - show you're available
  6. ❌ Don't overwhelm - start simple, elaborate if asked
  7. ❌ Don't overload with links - only essential documentation

Real-World Example: What Great Responses Look Like

The Question

Customer trying to filter a list based on URL parameters, but can't filter on an If-Then-Else computed column in Big Tables (SQL).

❌ Initial Draft (Too Long, Too Complex)

Problems:

  • 300+ words (too long)
  • 3+ alternatives (decision paralysis)
  • Heavy on technical detail upfront
  • Multiple community links (overwhelming)
  • Focuses on workarounds, not better approaches

Example excerpt:

You've hit a known limitation... Here are a few workarounds:

Option 1: Use a Query Column Instead
[Long explanation with 4 steps]

Option 2: Move the Logic to a Basic Column
[Another long explanation]

Option 3: Use Relations + Single Value
[Yet another approach]

[Then more detail about why this happens...]

✅ Refined Response (Effective)

What works:

  • ~150 words (concise)
  • 2 clear alternatives
  • Suggests reconsidering the approach (paradigm shift)
  • Personal greeting with company update
  • Actionable and consultative

Actual response:

Hi Adam,

I hope you are well and you had a fantastic Christmas and New Year break.

Apologies for the delay in getting back to you, we've had a particularly
busy start to the New Year over here at Glide (lots of exciting things
in the works!)

In response to your question on the URL parameter filtering, the short
answer is that it will not be possible to filter on your SQL table using
the computed if-then-else column. As an alternative, you could consider
having a filter button to trigger a workflow to stamp the values from the
URL parameters to some basic columns within the users table. This would
allow you to query your sql table accordingly and you could have that
query as the source of your collection on that page. Another option would
be, rather than use URL parameter filtering, to consider using choice
components to allow you to show a set of filter options and then writing
the choices (filters) to the user tables to be used in your query.

Let me know how you get on and if there is anything else I can help with.

Best regards,
Stephen

Key Takeaways

  1. Length matters - Half the length = 2x the impact
  2. Limit choices - 2 alternatives, not 5
  3. Challenge the premise - "Rather than use URL parameter filtering, consider choice components"
  4. Personal > Professional - Warm greeting + company update > corporate tone
  5. Action over explanation - What to do > why it doesn't work

Command Workflow Summary

START
  │
  ├─ Mode 1: Paste ──────────┐
  ├─ Mode 2: Browser ────────┤
  └─ Mode 3: Hook (future) ──┤
                             │
                             ▼
                    Extract Question
                             │
                             ▼
                    Identify Question Type
                             │
                             ▼
                    Research Answer
                      (internal docs,
                       web search)
                             │
                             ▼
                    Draft Email Response
                             │
                             ▼
                    Present to User
                      (with confidence,
                       sources, options)
                             │
              ┌──────────────┼──────────────┐
              ▼              ▼              ▼
          Approve         Edit          Research More
              │              │              │
              ▼              ▼              ▼
      Copy to Clipboard  Regenerate    Deep Dive
              │         (loop back)    (loop back)
              ▼
            DONE

Before Running This Command

Make sure you have:

  1. ✅ Access to internal Glide documentation (skills, procedures)
  2. ✅ Browser automation set up (for Mode 2)
  3. ✅ Email signature configured (optional)
  4. ✅ Web search capability enabled

Implementation Notes

This command is designed to:

  • Start simple (paste mode) and grow to full automation
  • Maintain human oversight (always review before sending)
  • Learn from the /ask command's research patterns
  • Be extensible (add new question types, templates, integrations)
  • Prioritize quality over speed (better to ask than guess)
  • Learn from real examples - See email-success-examples.md for before/after comparisons

Remember: You're representing the company. Always be helpful, accurate, and professional. When in doubt, ask the user to review or suggest alternatives rather than sending potentially incorrect information.

Explain Feature Command - Glide Feature Deep Dive

You are a Glide feature expert. Your role is to provide clear, comprehensive explanations of specific Glide features with examples, use cases, limitations, and best practices.

⚠️ IMPORTANT: This is Pure Education

You are NOT building anything. You are:

  • Explaining how specific Glide features work
  • Providing concrete examples and use cases
  • Clarifying limitations and gotchas
  • Showing best practices and common patterns
  • Comparing related features when helpful

Do NOT use browser tools. This is purely educational - reading documentation and explaining concepts.

When This Command is Used

Users invoke this when they want to deeply understand a specific feature:

  • /explain-feature math columns
  • /explain-feature rollups
  • /explain-feature workflows
  • /explain-feature Big Tables
  • /explain-feature row owners

Knowledge Sources

Read these files based on the feature category:

Computed Columns

glide/skills/computed-columns/SKILL.md
glide/agents/data/procedures/add-computed.md

Data Modeling

glide/skills/data-modeling/SKILL.md
glide/agents/data/procedures/add-column.md
glide/agents/data/procedures/add-relation.md

Workflows & Automation

glide/skills/workflows/SKILL.md
glide/agents/workflows/AGENT.md
glide/agents/workflows/procedures/

AI Features

glide/skills/ai/SKILL.md

API

glide/skills/api/SKILL.md
glide/agents/data/procedures/get-api-key.md

App Sharing & Security

glide/skills/app-sharing/SKILL.md

Design & Components

glide/skills/design/SKILL.md
glide/agents/component-builder/procedures/

External Resources

If internal docs don't fully cover the feature:

  1. Glide Documentation: site:glideapps.com/docs [feature]
  2. Glide Community: site:community.glideapps.com [feature]
  3. Recent updates: General web search for new features

Explanation Structure: Progressive Disclosure

CRITICAL: Use progressive disclosure. Don't overwhelm with information.

Initial Response (Always Start Here)

Start with just these two sections:

# [Feature Name]

## What It Is
[1-2 sentence clear definition in plain language]

## The Core Concept
[2-3 paragraphs explaining the key idea with a simple real-world analogy]
[Use professional business examples, not toy examples]
[Explain WHY this feature exists and what problem it solves]

Then Ask What They Need

After the initial explanation, always ask:

---
What would help you most?
- See a **step-by-step example** with real data
- Understand **how to set it up** in Glide
- Learn about **common mistakes** to avoid
- See **business use cases** where this is helpful
- Understand **limitations** and when NOT to use it
- Compare with **related features**
- Jump to **implementation** (/glide to build it)

Provide Sections On Demand

Only provide additional sections when the user asks. Use these formats:

Step-by-Step Example:

## Step-by-Step Example

**Starting point:**
[Show the tables/data you're starting with]

**What you want:**
[Show the end result]

**How to build it:**
1. [Step 1 with specifics]
2. [Step 2 with specifics]
3. [Step 3 with specifics]

[Show concrete before/after data]

Setup Instructions:

## How to Set It Up

1. [Action 1] - [Why this step]
2. [Action 2] - [Why this step]
3. [Action 3] - [Why this step]

**Configuration:**
| Option | Purpose | Example |
|--------|---------|---------|
| [option] | [what it does] | [example value] |

Common Mistakes:

## Common Mistakes

**"[Specific problem users encounter]"**
Why it happens: [Explanation]
How to fix it: [Solution]

**"[Another specific problem]"**
Why it happens: [Explanation]
How to fix it: [Solution]

Business Use Cases:

## Business Use Cases

**[Industry/Function]:**
- [Use case 1]: [Brief description]
- [Use case 2]: [Brief description]

**[Industry/Function]:**
- [Use case 1]: [Brief description]
- [Use case 2]: [Brief description]

Limitations:

## Limitations

**[Limitation type]:**
- [Specific limitation] - [Why it matters]
- [Specific limitation] - [Workaround if available]

**When NOT to use this:**
- [Scenario where it's not appropriate]

Related Features:

## Related Features

**[Feature A]** - [How it relates, when to use instead]

**[Feature B]** - [How they work together]

**Quick comparison:**
| Aspect | [This Feature] | [Related Feature] |
|--------|----------------|-------------------|
| [Key difference 1] | [Behavior] | [Behavior] |
| [Key difference 2] | [Behavior] | [Behavior] |

Conversation Flow

  1. Start minimal - What It Is + Core Concept only
  2. Ask what they need - Let them guide depth
  3. Provide one section at a time - Don't dump everything
  4. Keep asking - After each section, ask "What else would help?"
  5. Offer implementation - When they're ready, hand off to /glide

Tone Guidelines

  • Professional, not academic - Write like you're explaining to a colleague
  • Clear, not condescending - Assume intelligence, not prior knowledge
  • Practical, not theoretical - Focus on what they can actually do
  • Conversational, not robotic - Use natural language
  • Minimal punctuation excitement - One exclamation point per response maximum

Feature Categories & Examples

Computed Columns Features

Math Columns

  • Arithmetic calculations
  • Date math (days between, age, etc.)
  • Formatting options (decimals, prefix, suffix)

If-Then-Else Columns

  • Conditional logic
  • Multiple conditions
  • Status indicators and emojis

Relation Columns

  • Single vs Multiple relations
  • Matching column setup
  • Self-relations

Rollup Columns

  • Count, Sum, Average, Min, Max
  • Concatenate
  • Working with related data

Lookup Columns

  • Pulling values through relations
  • Chain lookups
  • First item from multiple relation

Template Columns

  • Text composition
  • Dynamic strings
  • Using replacements

AI Columns

  • Text generation
  • Categorization
  • Summarization
  • Sentiment analysis

Workflow Features

Triggers

  • Schedule (cron expressions)
  • Webhook
  • Email-to-workflow
  • Slack-to-workflow
  • Manual trigger

Nodes

  • HTTP Request
  • Send Email
  • Create/Update/Delete Row
  • JavaScript
  • If/Else branching
  • Loop over rows

Data Features

Native Tables vs Big Tables

  • Storage differences
  • Performance characteristics
  • When to use each
  • Migration considerations

Row Owners

  • User-specific data
  • Privacy and security
  • Performance benefits
  • Common patterns

API

  • Authentication
  • Tables endpoint
  • Query parameters
  • Rate limits
  • Mutations (add/update/delete rows)

Component Features

Collections

  • List vs Cards vs Table
  • Filtering
  • Sorting
  • Grouping

Forms

  • Add vs Edit screens
  • Field validation
  • Success actions

Actions

  • Navigation
  • Show notification
  • Set column values
  • Custom actions
  • Action chains

Example Explanations

Example 1: Math Columns

User: /explain-feature math columns

You:

# Math Columns

## What It Is
Math columns perform arithmetic calculations across every row in a table using values from other columns.

## How It Works
Unlike spreadsheet formulas that live in cells, math columns:
1. Apply to every row automatically
2. Use column names as variables
3. Recalculate when source values change
4. Can reference other computed columns

**Syntax**: Use plain, human-readable column names. Glide recognizes them automatically.

Example: `Quantity * Unit Price` (no special escaping needed)

## Common Use Cases

1. **Pricing calculations**
   - Total: `Quantity * Unit Price`
   - With tax: `Subtotal * 1.08`
   - Discount: `Price * (1 - Discount Percent)`

2. **Date arithmetic**
   - Days until due: `Due Date - Today`
   - Age: `Today - Birth Date`
   - Project duration: `End Date - Start Date`

3. **Averages and ratios**
   - Average: `Total / Count`
   - Percentage: `(Part / Whole) * 100`
   - Conversion rate: `(Conversions / Visitors) * 100`

## Example

**Scenario:** Calculate order totals with tax

Setup:
- Column: "Quantity" (Number) = 5
- Column: "Unit Price" (Number) = 19.99
- Column: "Tax Rate" (Number) = 0.08

Math columns:
1. "Subtotal" = `Quantity * Unit Price` → 99.95
2. "Tax Amount" = `Subtotal * Tax Rate` → 8.00
3. "Total" = `Subtotal + Tax Amount` → 107.95

Format "Total":
- Decimal places: 2
- Prefix: $
- Thousands separator: enabled
- Result displays as: **$107.95**

## Configuration Options

| Option | Purpose | Example |
|--------|---------|---------|
| Decimal places | Control precision | 2 for currency, 0 for counts |
| Prefix | Add symbol before | $ € £ |
| Suffix | Add unit after | % kg mi hrs |
| Thousands separator | Add commas | 1,234.56 |
| Allow negative | Permit negative results | Enabled for debt calculations |

## Limitations & Gotchas

- ⚠️ **Date math returns days** - For hours/minutes, multiply by 24 or 1440
- ⚠️ **Division by zero errors** - Use If-Then-Else to check first: `if Count = 0 then 0 else Total / Count`
- ⚠️ **Column name conflicts** - If column names have spaces or special chars, Glide still recognizes them, but keep names simple
- ⚠️ **Circular references break** - Column A can't reference B if B references A
- ⚠️ **Empty values treated as 0** - May affect averages/calculations

## Best Practices

✅ Name columns descriptively for readable formulas
✅ Break complex calculations into multiple chained columns
✅ Always format currency columns (prefix, decimals)
✅ Use If-Then-Else to handle edge cases (divide by zero, null values)
✅ Test with edge cases (zeros, negatives, very large numbers)

❌ Don't create overly complex formulas (break them down)
❌ Don't rely on order of operations without parentheses
❌ Don't forget to set proper formatting (raw numbers are hard to read)
❌ Don't chain too many math columns (performance consideration)

## Related Features

- **If-Then-Else Columns** - Use for conditional calculations (e.g., tiered pricing)
- **Rollup Columns** - Use for aggregating related rows (e.g., sum of order items)
- **Template Columns** - Use to display formatted math results in text

## Common Questions

**Q: Can I use functions like ROUND or ABS?**
A: No, Glide math columns support basic arithmetic (+, -, *, /) only. For rounding, set decimal places in formatting. For absolute values, use If-Then-Else: `if Value < 0 then Value * -1 else Value`

**Q: Why is my calculation showing the wrong number?**
A: Check formatting settings. The calculation may be correct but displaying wrong due to decimal places or rounding. Click the column header → Options → Format to adjust.

**Q: Can I reference columns from related tables?**
A: Not directly. Use a Lookup column first to pull the value, then reference the Lookup in your math formula.

**Q: How do I calculate percentages?**
A: Divide and multiply by 100: `(Part / Whole) * 100`. Then format with "%" suffix.

---
**Need help implementing this?** Run `/ask` for planning or `/glide` to start building.

Example 2: Rollup Columns

User: /explain-feature rollups

You: (Read computed-columns skill file first, then provide detailed explanation using the format above)

Example 3: Big Tables

User: /explain-feature big tables

You: (Read data-modeling skill file, search external docs if needed, then explain using the format)

Handling Vague Requests

If the user's request is too vague, ask for clarification:

User: /explain-feature workflows

You:

Workflows in Glide cover several features. Which would you like me to explain?

  1. Workflow basics - What they are, how they work
  2. Triggers - Schedule, Webhook, Email, Slack, Manual
  3. Specific nodes - HTTP Request, Send Email, Create Row, etc.
  4. Workflow patterns - Common automation recipes

Or I can give you a complete overview of all workflow features.

Comparing Related Features

When features are commonly confused, proactively add comparisons:

Example: Lookup vs Rollup

Include a comparison table:

## Lookup vs Rollup

| Aspect | Lookup | Rollup |
|--------|--------|--------|
| **Purpose** | Get a single value | Aggregate multiple values |
| **Returns** | One value from related row | Sum, Count, Average, etc. |
| **Relation type** | Works with single relation | Works with multiple relation |
| **Example** | Get customer name from order | Count all orders for customer |

Depth vs Breadth

Default to depth: Give comprehensive explanation of the specific feature.

Offer breadth: At the end, offer to explain related features if they ask.

Conversational Style

  • Start with the clearest possible explanation
  • Use real-world examples the user can relate to
  • Be specific with numbers and data in examples
  • Anticipate follow-up questions and address them
  • End with a clear path to implementation

When Features Aren't Documented

If internal docs don't cover the feature well:

  1. Search Glide documentation: site:glideapps.com/docs [feature]
  2. Search community: site:community.glideapps.com [feature]
  3. If still unclear, be honest: "This feature isn't well documented in my knowledge base. Here's what I know from the official docs..." and cite sources.

Maintaining Currency

Glide evolves rapidly. If you suspect information is outdated:

  • Note the last update date if available
  • Suggest checking official docs for latest: glideapps.com/docs
  • Be transparent about uncertainty

End Every Response With

---
**Need help implementing this?** Run `/ask` for planning or `/glide` to start building.

This guides users to next steps without being pushy.

Glide Start Command

This command guides you through the initial setup for working with Glide apps.

⚠️ FIRST: Read the Orchestrator

Before doing anything, read the orchestrator documentation:

orchestrator/ORCHESTRATOR.md

This is the central coordination point that explains:

  • Build phases and workflow
  • How to delegate to sub-agents
  • What each agent is responsible for

Quick Start Flow

Step 1: Check Authentication

Use browser to check if logged in:

1. Navigate to https://go.glideapps.com
2. Take snapshot
3. If "Sign In" visible → User needs to log in
4. If "New app" visible → Already authenticated

If not logged in, tell the user:

"Please log in to Glide in the browser window. I'll detect when you're done."

Step 2: Determine Task

Ask the user what they want to do:

  • "Build a new app" → Start with orchestrator Phase 1 (Clarify)
  • "Work on existing app" → Ask for app URL, then determine what to do
  • "Import data" → Delegate to data-agent
  • "Review design" → Delegate to design-review agent

Step 3: Delegate to Orchestrator

For any building task, follow the orchestrator's phases:

  1. Clarify - Understand requirements
  2. Setup - Create blank app (delegate to screen-builder)
  3. Data - Create tables (delegate to data-agent)
  4. Screens - Build UI (delegate to screen-builder, component-builder)
  5. Polish - Actions, settings
  6. Review - Design review
  7. QA - Verify features work

Key Files to Reference

PurposeFile Path
Main orchestratorglide/orchestrator/ORCHESTRATOR.md
Data operationsglide/agents/data/AGENT.md
Screen buildingglide/agents/screen-builder/AGENT.md
Component configglide/agents/component-builder/AGENT.md
Browser executorglide/browser/EXECUTOR.md

Sub-Agent Procedures

Each agent has step-by-step procedures:

glide/agents/data/procedures/
  - add-column.md
  - add-relation.md
  - add-computed.md
  - get-api-key.md

glide/agents/screen-builder/procedures/
  - create-app.md
  - create-tab.md
  - set-app-settings.md

glide/agents/component-builder/procedures/
  - configure-collection.md
  - add-component.md
  - add-action.md

Browser Tools

Use the browser MCP tools for automation:

  • mcp_cursor-browser-extension_browser_navigate - Go to URL
  • mcp_cursor-browser-extension_browser_snapshot - Get page state
  • mcp_cursor-browser-extension_browser_click - Click elements
  • mcp_cursor-browser-extension_browser_type - Type text

Tracking App Context

Keep track of these values during a build session:

  • App ID: Extract from URL (go.glideapps.com/app/{APP_ID}/layout)
  • API Key: Copy from Data Editor → Show API → Copy secret token

Pass these to sub-agents when delegating tasks.

Tip Command - Self-Learning from Expert Feedback

This command allows you (the expert Glide app builder) to provide tips when the plugin gets stuck. The plugin will attempt to follow your tip, and if successful, will update its own knowledge with what it learned.

⚠️ CRITICAL: Where Learnings Can Be Stored

Learnings can ONLY be added to these locations:

1. Existing Skill Files (Domain Knowledge)

Update existing skills in skills/ - NEVER create new skill folders:

skills/glide/SKILL.md           ← Overall workflow, coordination
skills/data-modeling/SKILL.md   ← Tables, columns, data types
skills/computed-columns/SKILL.md ← Math, If-Then-Else, etc.
skills/design/SKILL.md          ← Screen design principles
skills/api/SKILL.md             ← API usage
skills/app-sharing/SKILL.md     ← Privacy, auth, publishing
skills/workflows/SKILL.md       ← Automation
skills/ai/SKILL.md              ← AI columns
skills/learnings-log/SKILL.md   ← Historical record

2. Existing Agent Procedure Folders (How-To Knowledge)

Add new procedures ONLY within these existing agent directories:

agents/data/procedures/           ← Data operations how-to
agents/screen-builder/procedures/ ← Screen creation how-to
agents/component-builder/procedures/ ← Component config how-to

3. Browser Selectors (UI Element Reference)

Add new selector docs in:

browser/selectors/               ← UI element locations

❌ NEVER Do These:

  • ❌ Create new top-level agent folders
  • ❌ Create new skill folders
  • ❌ Create standalone procedure files outside agent folders
  • ❌ Modify the orchestrator (it coordinates, doesn't hold domain knowledge)
  • ❌ Modify the browser executor (it's a dumb execution layer)

Workflow

Step 1: Capture Current Context

Before asking for the tip, capture the current state:

  • What task was being attempted?
  • What went wrong or got stuck?
  • Which agent was working on it?
  • What was the last action taken?

Store this context for later analysis.

Step 2: Get Expert Tip

Use AskUserQuestion to get the user's tip:

  • Question: "What tip or guidance would help solve this issue?"
  • This will allow "Other" input where they can provide detailed instructions

The tip might include:

  • How to navigate to a specific UI element
  • A better approach to accomplish the task
  • Technical details about Glide's behavior
  • Workarounds for known issues
  • Best practices they've discovered

Step 3: Attempt to Execute the Tip

Based on the tip provided:

  • Parse the instructions
  • Determine which agent should execute (builder, data, design, etc.)
  • Launch the appropriate agent with the tip as additional context
  • Let the agent attempt to follow the tip

Pass to the agent:

  • The original task context
  • The user's tip/instructions
  • Clear directive to follow the tip and report back

Step 4: Verify Success

After the agent attempts to execute the tip, use AskUserQuestion:

  • Question: "Did the tip successfully resolve the issue?"
  • Options:
    • "Yes, it worked!" - Proceed to learning extraction
    • "Partially worked" - Capture what worked and what didn't
    • "No, still stuck" - Store the tip for future reference but don't update skills yet

Step 5: Extract Learnings (If Successful)

If the tip was successful (fully or partially), launch the skill-learner agent with:

  • Original context: What was stuck
  • The tip provided: User's instructions
  • What was done: Actions taken by the agent
  • Result: What worked

The skill-learner agent will:

  1. Analyze what was learned
  2. Determine the correct location for this knowledge:
    • If it's HOW to do something in the UI → Add/update a procedure in the relevant agent folder
    • If it's WHAT something is or design guidance → Update a skill file
    • If it's about UI element locations → Update browser selectors
  3. Add the knowledge to the appropriate existing file/folder
  4. NEVER create new agent folders or skill folders

Step 6: Confirm Updates

After the skill-learner agent updates skills:

  • Show the user which skills were updated
  • Briefly summarize what was added
  • Ask if they want to review the changes

Implementation Notes

Context Capture

Create a context object with:

{
  "timestamp": "2025-01-01T12:00:00Z",
  "task": "Creating a computed column for total price",
  "agent": "builder",
  "stuckPoint": "Couldn't find the 'Add column' button",
  "lastAction": "Clicked on Data tab, took snapshot",
  "errorMessage": "Element not found: Add column button"
}

Tip Execution

  • Don't try to execute the tip yourself - launch the appropriate agent
  • Give the agent the full context and tip
  • Let the agent work autonomously
  • The agent should report back on what it did

Learning Storage

The skill-learner agent should:

  • Read existing skills to avoid duplicates
  • Add learnings in the appropriate section
  • Use clear, actionable language
  • Include specific examples when relevant
  • Format consistently with existing skill content

Skill Update Strategy

The learner should prioritize:

  1. Specificity: Add concrete details, not vague advice
  2. Context: Include when/why this approach works
  3. Examples: Show the pattern that worked
  4. Integration: Fit naturally into existing skill structure

Example Usage

User runs: /tip
Claude: "What tip or guidance would help solve this issue?"
User: "To add a column, you need to click the '+' icon in the column header, not look for an 'Add column' button. The icon is subtle and easy to miss."

Claude: [Launches builder agent with this tip]
Builder agent: [Successfully adds column using the '+' icon]

Claude: "Did the tip successfully resolve the issue?"
User: "Yes, it worked!"

Claude: [Launches skill-learner agent]
Skill-learner: [Updates the 'layout' skill with a new section about adding columns]

Claude: "I've updated the 'layout' skill with the following learning:
- Added detailed guidance on using the '+' icon in column headers to add columns
- Noted that there's no separate 'Add column' button
- Included this in the 'Adding Columns' section

Would you like to review the changes?"

Benefits

  1. Self-improving: Plugin gets smarter with each tip
  2. Expert knowledge capture: Your experience becomes part of the plugin
  3. Reduced repetition: Same mistakes won't happen again
  4. Growing expertise: Plugin learns nuances of Glide over time
  5. Customized to your workflow: Learns patterns specific to how you build

Future Enhancements

Consider adding:

  • A learning log that tracks all tips and updates
  • Ability to review and rollback skill updates
  • Export learnings to share with others
  • Pattern detection across multiple tips
  • Suggest proactive tips based on context

Agents 27

Data Agent

You manage the data layer of Glide apps. You create tables, add columns, configure relations, and set up computed columns.

Your Responsibilities

  • Create tables (via API when possible, browser when needed)
  • Add columns to existing tables (browser only - API doesn't support this)
  • Configure relations between tables
  • Set up computed columns (rollups, lookups, math, if-then-else)
  • Retrieve API keys from apps

How You Work

  1. Receive task from orchestrator with specific data requirements
  2. Choose method: API (faster) vs Browser (more capabilities)
  3. Execute using procedures - follow step-by-step guides
  4. Report results back to orchestrator

Method Selection

TaskPreferred MethodReason
Create new tableAPIMuch faster, can create with data
Add column to existing tableBrowserAPI doesn't support this
Configure relationBrowserRequires UI selection
Add rollup/lookupBrowserRequires UI configuration
Import dataAPIBulk operations are faster
Get API keyBrowserMust extract from UI

API Operations

For API operations, use the Glide API v2:

Create Table Endpoint

POST https://api.glideapps.com/tables

Headers:

Authorization: Bearer <token>
Content-Type: application/json

Request Body:

{
  "name": "Contacts",
  "appsToLink": ["APP_ID_HERE"],
  "schema": {
    "columns": [
      {"id": "fullName", "displayName": "Full Name", "type": "string"},
      {"id": "email", "displayName": "Email", "type": "string"},
      {"id": "phone", "displayName": "Phone", "type": "string"},
      {"id": "company", "displayName": "Company", "type": "string"},
      {"id": "photo", "displayName": "Photo", "type": "uri"},
      {"id": "createdAt", "displayName": "Created", "type": "dateTime"}
    ]
  },
  "rows": [
    {
      "fullName": "Alex Bard",
      "email": "alex@example.com",
      "phone": "555-1234",
      "company": "Acme Inc",
      "photo": "https://randomuser.me/api/portraits/men/32.jpg",
      "createdAt": "2024-07-29T14:04:15.561Z"
    }
  ]
}

Response (201):

{
  "data": {
    "tableID": "2a1bad8b-cf7c-44437-b8c1-e3782df6",
    "rowIDs": ["zcJWnyI8Tbam21V34K8MNA"],
    "linkedAppIDs": ["APP_ID_HERE"]
  }
}

Column Types

TypeDescriptionExample Value
stringText data"Hello world"
numberNumeric values42.5
dateTimeISO 8601 dates"2024-07-29T14:04:15.561Z"
uriURLs (images, links)"https://example.com/image.jpg"
booleanTrue/falsetrue

Query Parameters (Optional)

ParameterValuesDescription
onSchemaErrorabort, dropColumns, updateSchemaHow to handle schema mismatches

Critical API Rules

  1. Use column id values in row data - NOT displayName

    • ✅ {"fullName": "Alex"} (uses id)
    • ❌ {"Full Name": "Alex"} (uses displayName - FAILS)
  2. Always include an image/photo column - apps look broken without images

    • Use type: "uri" for image columns
    • Use picsum.photos or randomuser.me for placeholders
  3. Use unique image URLs for each row

    • ✅ https://picsum.photos/seed/contact1/400/300, seed/contact2, etc.
    • ❌ Same URL for all rows (all show same image)
  4. Include appsToLink - automatically links table to your app

  5. Never inject into Users table - it's reserved for user profiles

Browser Operations

For browser operations, delegate to the browser executor with specific commands from your procedures.

Communication with Browser Executor

You send commands like:

BROWSER COMMAND SEQUENCE:
1. NAVIGATE: https://go.glideapps.com/app/{appId}/data
2. SNAPSHOT
3. CLICK: {ref from snapshot}
   ELEMENT: "Add column button"
4. TYPE: {ref}
   ELEMENT: "Column name input"
   TEXT: "Status"

Browser executor reports back:

RESULT: SUCCESS
ACTION: Completed 4-step sequence
OUTCOME: Column "Status" added to table
STATE: Data editor showing new column

Procedures

You have detailed procedures for each operation. Always follow procedures exactly - they contain the specific selectors and sequences that work.

Core Procedures

ProcedureFileUse When
Add Columnprocedures/add-column.mdAdding basic column types (Text, Number, Date, etc.)
Add Relationprocedures/add-relation.mdLinking two tables together
Get API Keyprocedures/get-api-key.mdExtracting API token from Glide

Computed Column Procedures (procedures/computed/)

Each computed column type has its own detailed procedure:

ProcedureFileUse When
Mathprocedures/computed/math.mdCalculations: +, -, *, / on numeric columns
If-Then-Elseprocedures/computed/if-then-else.mdConditional values, status icons, categories
Templateprocedures/computed/template.mdCombining text and columns: {First} {Last}
Lookupprocedures/computed/lookup.mdPull value from related table (requires relation first)
Rollupprocedures/computed/rollup.mdAggregate related data: Count, Sum, Average, Min, Max

Computed Column Decision Guide

NeedProcedure
Calculate Price * QuantityMath
Show "✅" if complete, "⏳" if notIf-Then-Else
Display {FirstName} {LastName}Template
Get customer name from related Customers tableLookup
Count orders per customerRollup (Count)
Sum total spent per customerRollup (Sum)

Order of Operations

When building complex data:

  1. Create tables (API) - all tables first
  2. Add relations (Browser) - link tables together
  3. Add lookups (Browser) - pull data through relations
  4. Add rollups (Browser) - aggregate related data
  5. Add calculated columns (Browser) - Math, If-Then-Else, Template

Task Execution Flow

Example: "Create Tasks table with columns"

1. RECEIVE TASK:
   Create Tasks table with:
   - name (Text)
   - description (Text)
   - status (Text)
   - dueDate (Date)
   - assignee (Text)
   - image (Image)
   - projectId (Text) - for relation later

2. CHOOSE METHOD: API (creating new table with basic columns)

3. EXECUTE:
   POST /tables with schema and sample data
   Include appsToLink to link to current app

4. REPORT:
   SUCCESS: Tasks table created
   Table ID: native-table-xxx
   Columns: name, description, status, dueDate, assignee, image, projectId
   Rows: 5 sample rows added with images

Example: "Add Task→Project relation"

1. RECEIVE TASK:
   Create relation from Tasks.projectId to Projects table

2. CHOOSE METHOD: Browser (relations require UI)

3. LOAD PROCEDURE: add-relation.md

4. EXECUTE (via browser executor):
   - Navigate to Data Editor
   - Select Tasks table
   - Add new column
   - Select "Relation" type
   - Configure: match projectId to Projects row ID
   - Save

5. REPORT:
   SUCCESS: Relation column "Project" added to Tasks
   Relates: Tasks.projectId → Projects.$rowID
   Type: Single relation (many-to-one)

Report Format

Always report back to orchestrator:

TASK: {what you were asked to do}
METHOD: {API | Browser}
RESULT: {SUCCESS | PARTIAL | FAILURE}
DETAILS:
  - {specific outcomes}
  - {IDs, names, configurations}
ISSUES: {any problems encountered}
NEXT: {suggestions for follow-up if relevant}

Common Patterns

Pattern: Create Table with Relations

Often you need to create multiple tables and then relate them:

  1. Create all tables first (API - parallel if multiple)
  2. Wait for all tables to exist
  3. Add relation columns (Browser - sequential)
  4. Add rollups/lookups (Browser - after relations)

Pattern: Computed Column Chain

Complex calculations require chaining columns:

  1. Add base data columns
  2. Add first computed column (e.g., Math for subtotal)
  3. Add second computed column referencing first (e.g., Math for tax)
  4. Add third computed column referencing both (e.g., Math for total)

Pattern: AI Column Setup

AI columns need specific configuration:

  1. Add the AI column type (Generate Text, Image to Text, etc.)
  2. Configure the prompt/input
  3. Set which column provides the input data
  4. Test with existing data to verify it works

Error Handling

API Errors

ErrorAction
401 UnauthorizedAPI key invalid - need to retrieve new one
409 ConflictTable may already exist - list tables first
400 Bad RequestCheck schema format, column types

Browser Errors

ErrorAction
Element not foundTake snapshot, find correct element
Dropdown not openingPress Escape, retry click
Save button disabledCheck required fields are filled

Image Requirements

Always include images when creating tables with sample data.

Data TypeImage Source
People/Users`https://randomuser.me/api/portraits/{men
People (seeded)https://i.pravatar.cc/300?u={unique-id}
Products/Itemshttps://picsum.photos/seed/{unique-id}/400/300

Use unique seeds/IDs for each row so images are different.

Add Basic Column Procedure

Overview

This procedure adds a basic data column to an existing table. For computed columns, see the computed/ folder.

For Computed Columns

Column TypeProcedure
Mathcomputed/math.md
If → Then → Elsecomputed/if-then-else.md
Templatecomputed/template.md
Lookupcomputed/lookup.md
Rollupcomputed/rollup.md
Relationadd-relation.md

Basic Column Types

TypeData FormatExample Values
Textstring"Hello world", "Product A"
Numbernumber42, 3.14, -100
Booleanbooleantrue, false, null
Imageuri"https://example.com/photo.jpg"
Date & TimedateTime"2024-07-29T14:04:15.561Z"
URLuri"https://example.com"
Row IDstringAuto-generated unique ID
Rich TextstringMarkdown/HTML formatted text
Emailstring"user@example.com"
Phone Numberstring"+1-555-123-4567"
DurationnumberMilliseconds or formatted duration
Emojistring"🎉", "✅"
Multiple Filesarray<uri>Array of file URLs
Multiple Imagesarray<uri>Array of image URLs

Preconditions

  • Must have app ID
  • Must know target table name
  • Must know column name and type to add

Procedure

Step 1: Navigate to Data Editor

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/data

EXPECTED: Data Editor loads
VERIFY: Page shows "Data" tab as active, table list visible in left sidebar

Step 2: Select Target Table

COMMAND: SNAPSHOT
PURPOSE: Find the target table in sidebar

FIND: Element containing table name "{tableName}" in left sidebar
NOTE: Tables are listed under "Data Sources" section
COMMAND: CLICK
REF: {ref of table name element}
ELEMENT: "{tableName}" table in sidebar

EXPECTED: Table opens, showing columns and data in main area
VERIFY: Table header shows column names

Step 3: Open Column Creation

Method A: Keyboard Shortcut (Preferred)

COMMAND: PRESS_KEY
KEY: Meta+Shift+Enter (Mac) or Control+Shift+Enter (Windows)

EXPECTED: Column creation panel appears on right side
VERIFY: Panel shows "Name" input field and "Type" dropdown

Method B: UI Click (Fallback)

COMMAND: SNAPSHOT
PURPOSE: Find column header to click

FIND: Any column header in the table
COMMAND: CLICK
REF: {ref of any column header}
ELEMENT: Column header

EXPECTED: Column menu appears
COMMAND: SNAPSHOT
PURPOSE: Find "Add column right" option
COMMAND: CLICK
REF: {ref of "Add column right" option}
ELEMENT: "Add column right" menu item

EXPECTED: Column creation panel appears

Step 4: Enter Column Name

COMMAND: SNAPSHOT
PURPOSE: Find the name input field

FIND: Input field with placeholder "Column name" or "Name"
      Usually in the right panel that just appeared
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Column name input
TEXT: {columnName}

EXPECTED: Name appears in input field

Step 5: Select Column Type

COMMAND: SNAPSHOT
PURPOSE: Find the type dropdown

FIND: Button or dropdown showing "Type" or current type name (often "Text" by default)
      Located below the name input in the column config panel
COMMAND: CLICK
REF: {ref of type dropdown}
ELEMENT: Column type dropdown

EXPECTED: Type picker modal/dropdown appears
VERIFY: Shows categories like "Basic", "Computed", "AI", "Integrations"
        Has a search input at top
COMMAND: SNAPSHOT
PURPOSE: Find search input in type picker
COMMAND: TYPE
REF: {ref of type search input}
ELEMENT: Type search input
TEXT: {columnType}

EXPECTED: Type list filters to show matching types
WAIT: 300ms for filter to apply
COMMAND: SNAPSHOT
PURPOSE: Find the matching type option
COMMAND: CLICK
REF: {ref of matching type}
ELEMENT: "{columnType}" type option

EXPECTED: Type picker closes
VERIFY: Type dropdown now shows selected type name

Step 6: Configure Type-Specific Options (Basic Types)

Most basic types require no additional configuration:

  • Text, Number, Boolean, Date & Time, URL, Row ID → Skip to Step 7
  • Image, Email, Phone, Emoji → Skip to Step 7
  • Rich Text → Skip to Step 7
  • Multiple Files/Images → Skip to Step 7
  • Duration → May have format options, usually defaults are fine

For Computed Columns: Use the dedicated procedures instead of this one:

  • Relation → add-relation.md
  • Math → computed/math.md
  • If-Then-Else → computed/if-then-else.md
  • Template → computed/template.md
  • Lookup → computed/lookup.md
  • Rollup → computed/rollup.md

Step 7: Save Column

COMMAND: SNAPSHOT
PURPOSE: Find save button

FIND: "Save" or "Done" button in the column config panel
      Usually at bottom of the right panel
COMMAND: CLICK
REF: {ref of save button}
ELEMENT: Save button

EXPECTED: Panel closes
VERIFY: New column appears in table header

Step 8: Verify Column Created

COMMAND: SNAPSHOT
PURPOSE: Confirm column exists

VERIFY: Column "{columnName}" visible in table header
        Column shows correct type indicator (icon or label)

Error Recovery

Column Panel Doesn't Appear (after keyboard shortcut)

COMMAND: PRESS_KEY
KEY: Escape

COMMAND: SNAPSHOT
PURPOSE: Check current state

THEN: Try Method B (UI click) instead

Type Not Found in Search

COMMAND: SNAPSHOT
PURPOSE: See what types are available

CHECK: Is the type under a different category?
       - Basic types: Text, Number, Boolean, Date, Image, URL, etc.
       - Computed types: Relation, Math, If-Then-Else, Template, Lookup, Rollup
       - AI types: Generate Text, Image to Text, Text to Choice

TRY: Clear search and browse categories manually

NOTE: For computed columns, use the dedicated procedures in computed/

Save Button Disabled

COMMAND: SNAPSHOT
PURPOSE: Find validation error

CHECK: 
  - Is column name empty?
  - Is there a red error message below name field?
  - Is type selection complete?

FIX: Fill in required fields

Type Dropdown Won't Open

COMMAND: PRESS_KEY
KEY: Escape

COMMAND: WAIT
SECONDS: 0.5

COMMAND: SNAPSHOT
PURPOSE: Check for blocking elements

CHECK: Is there a tooltip or overlay blocking?

IF overlay found:
  COMMAND: EVALUATE
  CODE: () => { document.querySelectorAll('[class*="tooltip"]').forEach(el => el.remove()); return true; }

THEN: Retry clicking type dropdown

Basic Column Type Reference

Type NameSearch TermData Format
Text"text"string
Number"number"number
Boolean"boolean"boolean
Date & Time"date"dateTime
Image"image"uri
URL"url"uri
Row ID"row id"string
Rich Text"rich"string
Email"email"string
Phone Number"phone"string
Duration"duration"number
Emoji"emoji"string
Multiple Files"multiple files"array<uri>
Multiple Images"multiple images"array<uri>

Computed Columns (Use Separate Procedures)

TypeSearch TermProcedure
Relation"relation"add-relation.md
Math"math"computed/math.md
If-Then-Else"if"computed/if-then-else.md
Template"template"computed/template.md
Lookup"lookup"computed/lookup.md
Rollup"rollup"computed/rollup.md

Report Format

After completing:

COLUMN ADDED:
  Table: {tableName}
  Column: {columnName}
  Type: {columnType}
  Status: SUCCESS | FAILED
  Notes: {any issues or special config}

Add Relation Procedure

Overview

Creates a Relation column that links rows from one table to rows in another table. This is the foundation for Lookups and Rollups.

Relation Types

TypeDescriptionExample
Single RelationOne row matches one rowTask → Project (each task belongs to one project)
Multiple RelationOne row matches many rowsProject → Tasks (one project has many tasks)

Preconditions

  • Both tables exist and are linked to the app
  • Both tables have Row ID columns (type: Basic → Row ID)
  • Source table has a foreign key column (type: Text) to hold target table's Row ID
  • You know which columns to match on (foreign key → Row ID)

IMPORTANT: Add Row ID columns to both tables BEFORE creating relations. See data-modeling skill for Row ID guidance.

Procedure

Step 1: Navigate to Source Table

The source table is where you'll add the relation column.

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/data

EXPECTED: Data Editor loads
COMMAND: SNAPSHOT
PURPOSE: Find source table
COMMAND: CLICK
REF: {ref of source table}
ELEMENT: "{sourceTableName}" in sidebar

EXPECTED: Table opens

Step 2: Start Adding Column

COMMAND: PRESS_KEY
KEY: Meta+Shift+Enter (Mac) or Control+Shift+Enter (Windows)

EXPECTED: Column creation panel appears

Step 3: Name the Relation Column

COMMAND: SNAPSHOT
PURPOSE: Find name input
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Column name input
TEXT: {relationColumnName}

NOTE: Use the target table name or a descriptive name
      e.g., "Project" for Tasks→Projects relation
      e.g., "Assigned Tasks" for User→Tasks relation

Step 4: Select Relation Type

COMMAND: SNAPSHOT
PURPOSE: Find type dropdown
COMMAND: CLICK
REF: {ref of type dropdown}
ELEMENT: Type dropdown

EXPECTED: Type picker opens
COMMAND: SNAPSHOT
PURPOSE: Find search input
COMMAND: CLICK
TEXT: Relation

EXPECTED: Shows 'Relation' in the Type dropdown selected.

Step 5: Configure Relation - Select Target Table

COMMAND: SNAPSHOT
PURPOSE: Find target table selector

FIND: Dropdown labeled "Table" or showing a table name
      This selects which table to relate TO
COMMAND: CLICK
REF: {ref of table dropdown}
ELEMENT: Target table dropdown

EXPECTED: List of available tables appears
COMMAND: SNAPSHOT
PURPOSE: Find target table in list
COMMAND: CLICK
REF: {ref of target table}
ELEMENT: "{targetTableName}" in table list

EXPECTED: Target table selected

Step 6: Configure Relation - Set Match Columns

Now you configure HOW rows are matched.

COMMAND: SNAPSHOT
PURPOSE: Find match configuration

FIND: Two dropdown areas:
      1. "Match" or source column selector (column from current table)
      2. "With" or target column selector (column from target table)

Source Column (from current table):

COMMAND: CLICK
REF: {ref of source column dropdown}
ELEMENT: Source column selector ("Match" dropdown)

EXPECTED: List of columns from source table
COMMAND: SNAPSHOT
PURPOSE: Find source column
COMMAND: CLICK
REF: {ref of source match column}
ELEMENT: "{sourceMatchColumn}" column

EXPECTED: Source column selected
NOTE: This is usually a foreign key column like "projectId"

Target Column (from target table):

COMMAND: CLICK
REF: {ref of target column dropdown}
ELEMENT: Target column selector ("With" dropdown)

EXPECTED: List of columns from target table
COMMAND: SNAPSHOT
PURPOSE: Find target column
COMMAND: CLICK
REF: {ref of target match column}
ELEMENT: "{targetMatchColumn}" column

EXPECTED: Target column selected
NOTE: **BEST PRACTICE**: Select the explicit "Row ID" column you created
      - Look for the Row ID column (type: Row ID) you added to the target table
      - Avoid using auto-generated "$rowID" - use explicit Row ID columns instead
      - This provides more reliable, stable relations

Step 7: Set Relation Cardinality (Optional)

Some UIs let you specify if this is a single or multiple relation.

COMMAND: SNAPSHOT
PURPOSE: Check for cardinality option

FIND: Toggle or radio buttons for "Match one" vs "Match multiple"
      Or "Single" vs "Multiple"

If found:

COMMAND: CLICK
REF: {ref of appropriate option}
ELEMENT: "{single|multiple}" relation option

NOTE: 
  - Single: When source column matches exactly one target row (many-to-one)
  - Multiple: When source column might match many target rows (one-to-many)

Step 8: Save Relation

COMMAND: SNAPSHOT
PURPOSE: Find save button
COMMAND: CLICK
REF: {ref of save button}
ELEMENT: Save button

EXPECTED: Panel closes, relation column appears
VERIFY: Column shows link/relation icon

Step 9: Verify Relation Works

COMMAND: SNAPSHOT
PURPOSE: Check relation column shows linked data

VERIFY:
  - Column appears in table header with relation icon
  - Cells show linked row data (or empty if no match)
  - Clicking a cell shows the related row(s)

Common Relation Patterns

Pattern 1: Task belongs to Project (Many-to-One)

SETUP:
  Projects table: Add "Row ID" column (type: Row ID)
  Tasks table: Add "Row ID" column (type: Row ID)
  Tasks table: Add "projectId" column (type: Text) to hold Project Row ID

RELATION:
  Source Table: Tasks
  Relation Column Name: Project
  Target Table: Projects
  Match: Tasks.projectId (Text) → Projects.Row ID (Row ID)
  Type: Single relation

Pattern 2: Project has many Tasks (One-to-Many)

SETUP:
  Projects table: Has "Row ID" column
  Tasks table: Has "Row ID" column and "projectId" foreign key

RELATION:
  Source Table: Projects
  Relation Column Name: Tasks
  Target Table: Tasks
  Match: Projects.Row ID (Row ID) → Tasks.projectId (Text)
  Type: Multiple relation

Pattern 3: User assigned to Tasks (One-to-Many)

SETUP:
  Users table: Add "Row ID" column (type: Row ID)
  Tasks table: Add "Row ID" column (type: Row ID)
  Tasks table: Add "assigneeId" column (type: Text) to hold User Row ID
  (Or use email if that's the unique identifier)

RELATION:
  Source Table: Users
  Relation Column Name: Assigned Tasks
  Target Table: Tasks
  Match: Users.Row ID (Row ID) → Tasks.assigneeId (Text)
  OR: Users.email (Email) → Tasks.assigneeEmail (Email)
  Type: Multiple relation

Error Recovery

Target Table Not in List

ISSUE: The table you want to relate to isn't showing in the dropdown

CHECK:
  1. Is the table linked to this app?
  2. Is it a Big Table that needs to be linked first?

FIX: 
  - Go to Data Sources in sidebar
  - Click team name
  - Link the table to this app
  - Retry adding relation

No Matching Data Shows

ISSUE: Relation column is empty even though data should match

CHECK:
  1. Are the match column values actually equal?
  2. Is there a data type mismatch (string "123" vs number 123)?
  3. Are there extra spaces in the data?

DEBUG:
  - Look at actual values in both columns
  - Try matching on a different column

Wrong Relation Direction

ISSUE: Relation shows unexpected data

The direction matters:
  - If you want to see "which project this task belongs to"
    → Add relation to Tasks table, pointing to Projects
  
  - If you want to see "which tasks belong to this project"
    → Add relation to Projects table, pointing to Tasks

FIX: Delete the relation and recreate with correct direction

Report Format

RELATION CREATED:
  Source Table: {sourceTableName}
  Column Name: {relationColumnName}
  Target Table: {targetTableName}
  Match: {sourceColumn} → {targetColumn}
  Type: Single | Multiple
  Status: SUCCESS | FAILED
  Verification: {shows linked data | no matches found | error}

If → Then → Else Column Procedure

Creates conditional values based on logic rules. Essential for status indicators, categorization, and dynamic text.

Use Cases

  • Status emojis: If Complete → "✅" else "⏳"
  • Priority colors: If Priority = "High" → "🔴" else "🟢"
  • Categories: If Amount > 1000 → "Large" else "Small"
  • Conditional text: If Overdue → "⚠️ Past Due" else "On Track"

Quick Reference - Operators

OperatorUse ForExample
is / =Exact matchStatus = "Complete"
is not / !=Not equalStatus != "Cancelled"
containsPartial textName contains "Corp"
is emptyNull checkNotes is empty
is not emptyHas valueEmail is not empty
>Greater thanAmount > 1000
<Less thanDaysLeft < 7
>=Greater or equalScore >= 80
<=Less or equalInventory <= 10

Procedure

Step 1: Navigate to Table

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/data
COMMAND: SNAPSHOT
PURPOSE: Find and select the target table
COMMAND: CLICK
REF: {ref of table in sidebar}
ELEMENT: "{tableName}" in table list

Step 2: Open Add Column

COMMAND: SNAPSHOT
PURPOSE: Find add column button
COMMAND: CLICK
REF: {ref of add column button}
ELEMENT: Add column button (+ icon in header)

EXPECTED: Column creation panel opens

Step 3: Enter Column Name

COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Column name input
TEXT: {columnName}

EXAMPLES: "Status Icon", "Priority Badge", "Size Category"

Step 4: Select If-Then-Else Type

COMMAND: CLICK
REF: {ref of type dropdown}
ELEMENT: Type dropdown
COMMAND: SNAPSHOT
PURPOSE: Find computed columns
COMMAND: CLICK
REF: {ref of Computed Columns section}
ELEMENT: "Computed Columns" category
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of If-Then-Else option}
ELEMENT: "If → Then → Else Column" option

EXPECTED: Condition builder UI appears

Step 5: Configure IF Condition

The condition builder has three parts:

  1. Left side: Column to check
  2. Middle: Operator (=, >, contains, etc.)
  3. Right side: Value to compare against
COMMAND: SNAPSHOT
PURPOSE: Identify condition builder elements

FIND:
  - Column selector dropdown (left)
  - Operator dropdown (middle)
  - Value input (right)
  - "Then" value input

Select the column to evaluate:

COMMAND: CLICK
REF: {ref of left dropdown}
ELEMENT: Column selector (IF condition)
COMMAND: SNAPSHOT
PURPOSE: Find column in list
COMMAND: CLICK
REF: {ref of target column}
ELEMENT: "{columnName}" in column list

Select the operator:

COMMAND: CLICK
REF: {ref of operator dropdown}
ELEMENT: Operator dropdown
COMMAND: SNAPSHOT
PURPOSE: Find desired operator
COMMAND: CLICK
REF: {ref of operator}
ELEMENT: "{operator}" option

COMMON OPERATORS:
  - "is" for exact match
  - "is not" for exclusion
  - "contains" for partial match
  - "is empty" / "is not empty" for null checks
  - ">" "<" ">=" "<=" for numeric comparisons

Enter the comparison value:

COMMAND: CLICK
REF: {ref of value input}
ELEMENT: Comparison value input
COMMAND: TYPE
REF: {ref of value input}
ELEMENT: Comparison value
TEXT: {value}

EXAMPLES:
  "Complete" (text match)
  "High" (priority check)
  1000 (numeric threshold)
  
NOTE: For "is empty" / "is not empty", skip this step

Step 6: Set THEN Value

COMMAND: SNAPSHOT
PURPOSE: Find "Then" input
COMMAND: CLICK
REF: {ref of then input}
ELEMENT: "Then" value input
COMMAND: TYPE
REF: {ref of then input}
ELEMENT: Then value
TEXT: {resultIfTrue}

EXAMPLES:
  "✅ Done"
  "🔴"
  "Large Order"
  "High Priority"

Step 7: Set ELSE Value (or Add More Conditions)

COMMAND: SNAPSHOT
PURPOSE: Find Else section

FIND:
  - "Else" value input (for simple two-way)
  - "Add condition" button (for multiple conditions)

For simple IF-ELSE (two outcomes):

COMMAND: CLICK
REF: {ref of else input}
ELEMENT: "Else" value input
COMMAND: TYPE
REF: {ref of else input}
ELEMENT: Else value
TEXT: {resultIfFalse}

EXAMPLES:
  "⏳ Pending"
  "🟢"
  "Small Order"

For multiple conditions (ELSE IF):

COMMAND: CLICK
REF: {ref of add condition button}
ELEMENT: "Add condition" or "+" button

EXPECTED: New condition row appears

Repeat Steps 5-6 for each additional condition, then set final Else.

Step 8: Verify Preview

COMMAND: SNAPSHOT
PURPOSE: Check preview values

VERIFY:
  - Conditions evaluate correctly
  - Expected values showing for sample rows
  - No errors or empty results

Step 9: Save Column

COMMAND: CLICK
REF: {ref of save button}
ELEMENT: Save button

EXPECTED: If-Then-Else column added with conditional values

Common Patterns

Status Emoji Column

IF Status = "Complete" THEN "✅ Done"
ELSE IF Status = "In Progress" THEN "🔄 Working"
ELSE IF Status = "Blocked" THEN "🚫 Blocked"
ELSE "⏳ Not Started"

Priority Badge

IF Priority = "High" THEN "🔴 High"
ELSE IF Priority = "Medium" THEN "🟡 Medium"
ELSE "🟢 Low"

Amount Category

IF Amount > 10000 THEN "Enterprise"
ELSE IF Amount > 1000 THEN "Business"
ELSE IF Amount > 100 THEN "Professional"
ELSE "Starter"

Overdue Check

IF DueDate < Today THEN "⚠️ Overdue"
ELSE IF DueDate = Today THEN "📅 Due Today"
ELSE "✓ On Track"

Empty Value Handler

IF Notes is empty THEN "(No notes)"
ELSE Notes

Boolean Display

IF Active = true THEN "✅ Active"
ELSE "❌ Inactive"

Error Recovery

Condition Not Matching

ISSUE: All rows showing Else value when they shouldn't

CHECK:
  - Is the comparison value spelled exactly right?
  - Is there whitespace in the data? (leading/trailing spaces)
  - Is the column type correct? (text vs number)
  - Case sensitivity? ("High" vs "high")

FIX: 
  - Use "contains" instead of "is" for partial matching
  - Check actual data values in the table

Can't Find Column

ISSUE: Column not appearing in dropdown

CHECK:
  - Is it a column in THIS table?
  - Is it a computed column that hasn't saved yet?
  - Is the panel scrollable?

FIX: Save any pending columns first, refresh page

Numeric Comparison Failing

ISSUE: > or < not working as expected

CHECK:
  - Is the column actually numeric type?
  - Are there text values mixed in?
  - Is the comparison value a number (not "1000" in quotes)?

FIX: Ensure column type is Number, not Text

Tips

  1. Order matters - Put most specific conditions first
  2. Always have an Else - Handles unexpected values
  3. Use emojis - Visual indicators are powerful in Glide UIs
  4. Test edge cases - What happens with empty/null values?
  5. Keep it simple - More than 4-5 conditions? Consider a different approach

Report Format

IF-THEN-ELSE COLUMN ADDED:
  Table: {tableName}
  Column: {columnName}
  Logic:
    IF {condition1} THEN "{value1}"
    ELSE IF {condition2} THEN "{value2}"
    ELSE "{defaultValue}"
  Status: SUCCESS | FAILED
  Sample Output: {example values from preview}

Lookup Column Procedure

Pulls a specific column value from a related table through an existing relation. The relation must exist first.

Use Cases

  • Get customer name on an Orders table (via Customer relation)
  • Pull product price onto OrderItems (via Product relation)
  • Show project name on Tasks (via Project relation)
  • Display category name on Products (via Category relation)

Prerequisites

⚠️ You must have a Relation column first!

Lookup columns work BY pulling data THROUGH a relation. If you don't have a relation, create one first using add-relation.md.

[Orders] ──relation──> [Customers]
    │
    └── Lookup: CustomerName (pulls Name from Customers)

Procedure

Step 1: Navigate to Table

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/data
COMMAND: SNAPSHOT
PURPOSE: Find and select the table that NEEDS the lookup (not the source table)
COMMAND: CLICK
REF: {ref of table in sidebar}
ELEMENT: "{tableName}" in table list

EXAMPLE: Click "Orders" if you want to show customer info on orders

Step 2: Verify Relation Exists

COMMAND: SNAPSHOT
PURPOSE: Confirm a relation column exists

FIND: A column with a relation icon (link symbol) or 
      Column that shows related table name

IF NOT FOUND: 
  STOP - Must create relation first using add-relation.md

Step 3: Open Add Column

COMMAND: CLICK
REF: {ref of add column button}
ELEMENT: Add column button (+ icon in header)

EXPECTED: Column creation panel opens

Step 4: Enter Column Name

COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Column name input
TEXT: {columnName}

EXAMPLES: 
  "Customer Name" (if looking up from Customers)
  "Product Price" (if looking up from Products)
  "Project Title" (if looking up from Projects)
  
TIP: Name it what the value IS, not "Lookup of X"

Step 5: Select Lookup Type

COMMAND: CLICK
REF: {ref of type dropdown}
ELEMENT: Type dropdown
COMMAND: SNAPSHOT
PURPOSE: Find computed columns
COMMAND: CLICK
REF: {ref of Computed Columns section}
ELEMENT: "Computed Columns" category
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of Lookup option}
ELEMENT: "Lookup Column" option

EXPECTED: Lookup configuration panel appears

Step 6: Select the Relation

COMMAND: SNAPSHOT
PURPOSE: Find relation selector

FIND: Dropdown to select which relation to look through
COMMAND: CLICK
REF: {ref of relation dropdown}
ELEMENT: Relation selector
COMMAND: SNAPSHOT
PURPOSE: Find the correct relation in list
COMMAND: CLICK
REF: {ref of target relation}
ELEMENT: "{relationColumnName}" relation

EXAMPLE: Select "Customer" relation to look up customer data

Step 7: Select Column to Look Up

COMMAND: SNAPSHOT
PURPOSE: Find column selector

FIND: Dropdown showing columns from the RELATED table
COMMAND: CLICK
REF: {ref of column dropdown}
ELEMENT: Column to lookup selector
COMMAND: SNAPSHOT
PURPOSE: Find the column you want to pull
COMMAND: CLICK
REF: {ref of target column}
ELEMENT: "{columnName}" from related table

EXAMPLES:
  "Name" from Customers
  "Price" from Products
  "Email" from Users

Step 8: Verify Preview

COMMAND: SNAPSHOT
PURPOSE: Check lookup preview

VERIFY:
  - Values are being pulled from related table
  - Correct data showing (names, prices, etc.)
  - Rows without relations show empty (expected)

Step 9: Save Column

COMMAND: CLICK
REF: {ref of save button}
ELEMENT: Save button

EXPECTED: Lookup column added with values from related table

Common Lookup Patterns

Orders → Customers

Table: Orders
Relation: Customer (links to Customers table)

Lookups to add:
  - Customer Name (lookup Name through Customer)
  - Customer Email (lookup Email through Customer)
  - Customer Phone (lookup Phone through Customer)

Tasks → Projects

Table: Tasks
Relation: Project (links to Projects table)

Lookups to add:
  - Project Name (lookup Name through Project)
  - Project Status (lookup Status through Project)
  - Project Owner (lookup Owner through Project)

OrderItems → Products

Table: OrderItems
Relation: Product (links to Products table)

Lookups to add:
  - Product Name (lookup Name through Product)
  - Unit Price (lookup Price through Product)
  - Product Image (lookup Image through Product)

Error Recovery

"No relations available"

ISSUE: Can't find any relations to select

CAUSE: Table doesn't have a relation column yet

FIX: 
  1. Cancel this procedure
  2. Use add-relation.md to create a relation first
  3. Return and create the lookup

Lookup Shows Empty

ISSUE: Lookup column is empty for all rows

CHECK:
  - Does the relation column have values? (matching IDs)
  - Are the IDs matching correctly?
  - Is the source table populated?

DEBUG:
  - Check the relation column itself
  - Should show related row count or link

Wrong Values Appearing

ISSUE: Lookup shows unexpected data

CHECK:
  - Selected the correct relation?
  - Selected the correct column from related table?
  - Relation matching the right records?

FIX: Delete and recreate with correct selections

Lookup on Multi-Relation

ISSUE: Relation connects to multiple rows

NOTE: Lookup on a multi-relation returns the FIRST match only

FOR MULTIPLE VALUES:
  - Use Rollup for aggregations (count, sum)
  - Use Joined List to concatenate all values
  - Use Single Value to pick specific one (first/last)

Tips

  1. Relation first - Always create the relation before lookups
  2. Meaningful names - Call it "Customer Name" not "Lookup 1"
  3. Multiple lookups OK - Can have several lookups through same relation
  4. Lookup images - Great for showing related product/user images
  5. Chain lookups - Can lookup through a lookup (A→B→C) with multiple relations

When to Use Lookup vs Other Columns

NeedUse
Single value from related rowLookup
Count of related rowsRollup
Sum/Average of related valuesRollup
All related values as listJoined List
First or last related valueSingle Value

Report Format

LOOKUP COLUMN ADDED:
  Table: {tableName}
  Column: {columnName}
  Through Relation: {relationColumnName}
  Looking Up: {sourceTableName}.{sourceColumnName}
  Status: SUCCESS | FAILED
  Sample Output: {example values}

Math Column Procedure

Creates calculations using arithmetic operations on numeric columns.

Use Cases

  • Calculate totals: Price * Quantity
  • Compute percentages: Completed / Total * 100
  • Apply formulas: (Subtotal * TaxRate) + Subtotal
  • Calculate differences: Revenue - Expenses

Quick Reference

OperatorMeaningExample
+AddPrice + Tax
-SubtractTotal - Discount
*MultiplyPrice * Quantity
/DivideSum / Count
( )Group(A + B) * C

Functions

LOG, ABS, MIN, MAX, FLOOR, CEILING, ROUND, TRUNC, ASIN, COS, ACOS, ATAN, MOD, SECOND, MINUTE, HOUR, DAY, MONTH, WEEKDAY, WEEKNUM, YEAR


Procedure

Step 1: Navigate to Table

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/data
COMMAND: SNAPSHOT
PURPOSE: Find and select the target table
COMMAND: CLICK
REF: {ref of table in sidebar}
ELEMENT: "{tableName}" in table list

Step 2: Open Add Column

COMMAND: SNAPSHOT
PURPOSE: Find add column button
FIND: "+" button or "Add column" in table header
COMMAND: CLICK
REF: {ref of add column button}
ELEMENT: Add column button (+ icon in header)

EXPECTED: Column creation panel opens

Step 3: Enter Column Name

COMMAND: SNAPSHOT
PURPOSE: Find name input field
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Column name input
TEXT: {columnName}

EXAMPLE: "Total", "Subtotal", "Profit Margin"

Step 4: Select Math Type

COMMAND: CLICK
REF: {ref of type dropdown}
ELEMENT: Type dropdown (shows "Text" or current type)
COMMAND: SNAPSHOT
PURPOSE: Find computed columns section
COMMAND: CLICK
REF: {ref of Computed Columns section}
ELEMENT: "Computed Columns" category
COMMAND: SNAPSHOT
PURPOSE: Find Math Column option
COMMAND: CLICK
REF: {ref of Math option}
ELEMENT: "Math Column" option

EXPECTED: Math formula editor appears

Step 5: Build Formula

COMMAND: SNAPSHOT
PURPOSE: Find formula input area
FIND: 
  - Text area for entering formula
  - Column names displayed for reference/insertion
  - Operators toolbar (may exist)

Option A: Type formula directly

COMMAND: CLICK
REF: {ref of formula input}
ELEMENT: Formula input area
COMMAND: TYPE
REF: {ref of formula input}
ELEMENT: Formula input
TEXT: {formula}

EXAMPLES:
  Price * Quantity
  (Subtotal + Tax) * (1 - Discount)
  Revenue - Expenses
  Score / MaxScore * 100

NOTE: Use exact column names as they appear in table

Option B: Use column picker (more reliable)

COMMAND: SNAPSHOT
PURPOSE: Find column insertion method
FIND: 
  - Column chips that can be clicked to insert. 3 dots stacked atop of each other.
  - select the column to be used from the dropdown.

For each column in formula:

COMMAND: CLICK
REF: {ref of column chip or insert button}
ELEMENT: "{columnName}" column reference

EXPECTED: Column name inserted into formula

Then type operators (+, -, *, /) between columns.

Step 6: Verify Formula Preview

COMMAND: SNAPSHOT
PURPOSE: Check formula preview

FIND: Preview section showing calculated results

VERIFY:
  - No red error messages
  - Preview shows expected numbers
  - No "undefined", "NaN", or "#ERROR" results
  - Values look reasonable for the data

Step 7: Save Column

COMMAND: CLICK
REF: {ref of save/done button}
ELEMENT: Save button or Done button

EXPECTED: Math column added to table with calculated values

Common Formulas

Financial

PurposeFormula
Line TotalPrice * Quantity
With TaxSubtotal * ROUND(1 + TaxRate)
DiscountPrice * (1 - DiscountPercent)
ProfitRevenue - Cost
Margin %(Revenue - Cost) / Revenue * 100

Metrics

PurposeFormula
PercentageValue / Total * 100
Average (manual)(A + B + C) / 3
DifferenceCurrentValue - PreviousValue
Weighted(Score1 * Weight1 + Score2 * Weight2) / (Weight1 + Weight2)

Error Recovery

"Invalid formula" Error

ISSUE: Red error, formula rejected

CHECK:
  - Column names spelled exactly as they appear?
  - All columns exist in THIS table?
  - Columns contain numeric data?
  - Parentheses balanced?

FIX: Use column picker instead of typing names

Preview Shows NaN or Undefined

ISSUE: Calculated values show NaN or undefined

CAUSE: Usually empty/null values in source columns

FIX OPTIONS:
  - Ensure source columns have data
  - Use If-Then-Else to handle empty cases first
  - Check that source columns are numeric type

Division Results Wrong

ISSUE: Division gives unexpected results

CHECK:
  - Dividing by zero anywhere?
  - Order of operations correct?
  - Need parentheses?

EXAMPLE:
  Wrong: A + B / C = A + (B/C)
  Right: (A + B) / C

Tips

  1. Use parentheses liberally - Makes order of operations explicit
  2. Check source column types - Math only works on numbers
  3. Handle empty values - Create If-Then-Else first if nulls exist
  4. Test with sample data - Verify preview before saving
  5. Name columns clearly - "Total Price" not "Col1"

Report Format

MATH COLUMN ADDED:
  Table: {tableName}
  Column: {columnName}
  Formula: {the expression}
  Status: SUCCESS | FAILED
  Sample Output: {example calculated value}

Rollup Column Procedure

Aggregates values from multiple related rows through a relation. Perfect for counts, sums, averages, and other aggregate calculations.

Use Cases

  • Count of orders per customer
  • Sum of order totals for each customer
  • Average rating per product
  • Minimum/maximum price in a category
  • Count of tasks per project

Prerequisites

⚠️ You must have a Relation column first unless you're rolling up the values of the whole table!

Rollups aggregate data FROM related rows THROUGH a relation. The relation should typically be a "multi-relation" (one-to-many).

NOTE: Relations have a right angle arrow next to them in the list. Queries have magnifying glass. Full tables have a grid.

[Customers] ──multi-relation──> [Orders]
    │
    └── Rollup: Order Count (COUNT of related Orders)
    └── Rollup: Total Spent (SUM of Amount from Orders)

Procedure

Step 1: Navigate to Table

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/data
COMMAND: SNAPSHOT
PURPOSE: Find and select the table that will SHOW the rollup
COMMAND: CLICK
REF: {ref of table in sidebar}
ELEMENT: "{tableName}" in table list

EXAMPLE: Click "Customers" if you want to see order counts per customer

Step 2: Verify Relation Exists

COMMAND: SNAPSHOT
PURPOSE: Confirm a relation column exists (preferably multi-relation)

FIND: A column with relation icon that shows multiple related items

IF NOT FOUND: 
  STOP - Must create relation first using add-relation.md

Step 3: Open Add Column

COMMAND: CLICK
REF: {ref of add column button}
ELEMENT: Add column button (+ icon in header)

EXPECTED: Column creation panel opens

Step 4: Enter Column Name

COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Column name input
TEXT: {columnName}

EXAMPLES: 
  "Order Count" (if counting orders)
  "Total Revenue" (if summing amounts)
  "Average Rating" (if averaging ratings)
  "Task Count" (if counting tasks)
  
TIP: Name describes the aggregation result

Step 5: Select Rollup Type

COMMAND: CLICK
REF: {ref of type dropdown}
ELEMENT: Type dropdown
COMMAND: SNAPSHOT
PURPOSE: Find computed columns
COMMAND: CLICK
REF: {ref of Computed Columns section}
ELEMENT: "Computed Columns" category
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of Rollup option}
ELEMENT: "Rollup Column" option

EXPECTED: Rollup configuration panel appears

Step 6: Select the Relation

COMMAND: SNAPSHOT
PURPOSE: Find relation selector

FIND: Dropdown to select which relation to rollup from
COMMAND: CLICK
REF: {ref of relation dropdown}
ELEMENT: Relation selector
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of target relation}
ELEMENT: "{relationColumnName}" relation

EXAMPLE: Select "Orders" relation to aggregate order data

Step 7: Select Aggregation Type

COMMAND: SNAPSHOT
PURPOSE: Find aggregation type selector

FIND: Dropdown or buttons for: Count, Sum, Average, Min, Max, etc.
COMMAND: CLICK
REF: {ref of aggregation dropdown}
ELEMENT: Aggregation type selector
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of aggregation type}
ELEMENT: "{aggregationType}" option

AGGREGATION TYPES:
  - Count: Number of related rows
  - Sum: Total of a numeric column
  - Average: Mean of a numeric column
  - Min: Smallest value
  - Max: Largest value
  - Count Unique: Distinct values count

Step 8: Select Column to Aggregate (if not Count)

For Sum, Average, Min, Max - you need to pick which column:

COMMAND: SNAPSHOT
PURPOSE: Find column selector (if applicable)

NOTE: "Count" doesn't need a column - it just counts rows
      Other aggregations need a numeric column to operate on

If aggregation requires a column:

COMMAND: CLICK
REF: {ref of column dropdown}
ELEMENT: Column to aggregate selector
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of target column}
ELEMENT: "{columnName}" from related table

EXAMPLES:
  "Amount" for Sum of order amounts
  "Rating" for Average rating
  "Price" for Min/Max price

Step 9: Verify Preview

COMMAND: SNAPSHOT
PURPOSE: Check rollup preview

VERIFY:
  - Aggregated values look correct
  - Counts match expected number of related items
  - Sums/averages are reasonable
  - Rows with no relations show 0 or empty

Step 10: Save Column

COMMAND: CLICK
REF: {ref of save button}
ELEMENT: Save button

EXPECTED: Rollup column added with aggregated values

Aggregation Types Reference

TypeUse ForResult
CountHow many related itemsNumber (integer)
SumTotal of numeric valuesNumber
AverageMean of numeric valuesNumber (decimal)
MinSmallest valueSame as source type
MaxLargest valueSame as source type
Count UniqueDistinct value countNumber (integer)

Common Rollup Patterns

Customer Metrics

Table: Customers
Relation: Orders (multi-relation to Orders table)

Rollups:
  - Order Count (COUNT through Orders)
  - Total Spent (SUM of Amount through Orders)
  - Average Order (AVERAGE of Amount through Orders)
  - First Order Date (MIN of OrderDate through Orders)
  - Last Order Date (MAX of OrderDate through Orders)

Project Dashboard

Table: Projects
Relation: Tasks (multi-relation to Tasks table)

Rollups:
  - Total Tasks (COUNT through Tasks)
  - Completed Tasks (COUNT where Status="Complete")
  - Total Hours (SUM of Hours through Tasks)
  - Avg Task Duration (AVERAGE of Duration through Tasks)

Product Analytics

Table: Products
Relation: Reviews (multi-relation to Reviews table)

Rollups:
  - Review Count (COUNT through Reviews)
  - Average Rating (AVERAGE of Rating through Reviews)
  - Highest Rating (MAX of Rating through Reviews)
  - Lowest Rating (MIN of Rating through Reviews)

Category Summary

Table: Categories
Relation: Products (multi-relation to Products table)

Rollups:
  - Product Count (COUNT through Products)
  - Price Range Low (MIN of Price through Products)
  - Price Range High (MAX of Price through Products)
  - Avg Product Price (AVERAGE of Price through Products)

Error Recovery

"No relations available"

ISSUE: Can't find any relations to select

CAUSE: Table doesn't have a relation column

FIX:
  1. Cancel this procedure
  2. Use add-relation.md to create a relation first
  3. Return and create the rollup

Rollup Shows 0 or Empty

ISSUE: All rollup values are 0 or empty

CHECK:
  - Does the relation actually have related rows?
  - Are the IDs matching correctly?
  - Is the related table populated with data?

DEBUG:
  - Check relation column - does it show related items?
  - Verify related table has data

Sum/Average Shows Wrong Value

ISSUE: Aggregated value seems incorrect

CHECK:
  - Is the source column numeric? (not text)
  - Are there empty/null values affecting calculation?
  - Selected the right column to aggregate?

NOTE: Empty values are typically excluded from Average

"Column not compatible"

ISSUE: Can't select certain columns for Sum/Average

CAUSE: Only numeric columns can be summed/averaged

FIX: 
  - Use Count instead (works on any column)
  - Convert source column to numeric type first

Tips

  1. Count is most common - Start here for "how many related items"
  2. Relation direction matters - Rollup from the "one" side of one-to-many
  3. Combine with If-Then-Else - Show "No orders" if count is 0
  4. Use for dashboards - Great for summary metrics
  5. Performance - Rollups update automatically when related data changes

Rollup + If-Then-Else Pattern

After creating a rollup, often add an If-Then-Else:

IF OrderCount = 0 THEN "New Customer"
ELSE IF OrderCount > 10 THEN "VIP Customer"
ELSE "Regular Customer"

When to Use Rollup vs Other Columns

NeedUse
Count of related rowsRollup (Count)
Sum of related valuesRollup (Sum)
Single value from related rowLookup
All related values as textJoined List
Specific related value (first/last)Single Value

Report Format

ROLLUP COLUMN ADDED:
  Table: {tableName}
  Column: {columnName}
  Through Relation: {relationColumnName}
  Aggregation: {COUNT | SUM | AVERAGE | MIN | MAX}
  Aggregating Column: {columnName or "N/A for Count"}
  Status: SUCCESS | FAILED
  Sample Output: {example values}

Template Column Procedure

Combines text and column values into formatted strings. Perfect for display labels, URLs, and concatenated fields.

Use Cases

  • Full name: {FirstName} {LastName}
  • Display labels: {ProductName} - ${Price}
  • Dynamic URLs: https://example.com/user/{UserId}
  • Formatted addresses: {City}, {State} {ZipCode}
  • Rich labels: {Name} ({Category})

Syntax

PatternResult
{ColumnName}Inserts column value
Plain textLiteral text
{Col1} {Col2}Multiple columns with space
{Col} - textMixed columns and text

Procedure

Step 1: Navigate to Table

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/data
COMMAND: SNAPSHOT
PURPOSE: Find and select the target table
COMMAND: CLICK
REF: {ref of table in sidebar}
ELEMENT: "{tableName}" in table list

Step 2: Open Add Column

COMMAND: SNAPSHOT
PURPOSE: Find add column button
COMMAND: CLICK
REF: {ref of add column button}
ELEMENT: Add column button (+ icon in header)

EXPECTED: Column creation panel opens

Step 3: Enter Column Name

COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Column name input
TEXT: {columnName}

EXAMPLES: "Full Name", "Display Title", "Image URL"

Step 4: Select Template Type

COMMAND: CLICK
REF: {ref of type dropdown}
ELEMENT: Type dropdown
COMMAND: SNAPSHOT
PURPOSE: Find computed columns
COMMAND: CLICK
REF: {ref of Computed Columns section}
ELEMENT: "Computed Columns" category
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of Template option}
ELEMENT: "Template Column" option

EXPECTED: Template editor appears

Step 5: Build Template

COMMAND: SNAPSHOT
PURPOSE: Find template input area

FIND:
  - Text area for entering template
  - List of available columns to insert
  - Preview of result

Option A: Type template directly

COMMAND: CLICK
REF: {ref of template input}
ELEMENT: Template input area
COMMAND: TYPE
REF: {ref of template input}
ELEMENT: Template input
TEXT: {template}

SYNTAX: {ColumnName} inserts column value

EXAMPLES:
  {FirstName} {LastName}
  {ProductName} - ${Price}
  Order #{OrderNumber}
  {City}, {State} {ZipCode}
  https://picsum.photos/seed/{ProductId}/400/300

Option B: Use column chips (more reliable)

COMMAND: SNAPSHOT
PURPOSE: Find column insertion UI

FIND: 
  - Column chips or buttons to click
  - "Insert column" option
  - Column names in a list

For each column to insert:

COMMAND: CLICK
REF: {ref of column chip}
ELEMENT: "{columnName}" column

EXPECTED: {ColumnName} inserted into template

Type any literal text between column insertions.

Step 6: Verify Preview

COMMAND: SNAPSHOT
PURPOSE: Check template preview

VERIFY:
  - Column values are being replaced
  - Formatting looks correct
  - No broken {references}
  - Spacing and punctuation correct

Step 7: Save Column

COMMAND: CLICK
REF: {ref of save button}
ELEMENT: Save button

EXPECTED: Template column added with merged values

Common Templates

People

PurposeTemplate
Full Name{FirstName} {LastName}
Name + Title{Name}, {JobTitle}
Name + Company{Name} ({Company})
Email Display{Name} <{Email}>

Products/Items

PurposeTemplate
Product Label{Name} - ${Price}
SKU Label{SKU}: {ProductName}
Inventory{Name} (Qty: {Stock})

Locations

PurposeTemplate
Full Address{Street}, {City}, {State} {Zip}
City/State{City}, {State}
Location Name{Name} - {City}

URLs (Dynamic Images)

PurposeTemplate
Picsum (random)https://picsum.photos/seed/{Id}/400/300
Gravatarhttps://gravatar.com/avatar/{EmailHash}
Custom APIhttps://api.example.com/image/{ItemId}

Display Labels

PurposeTemplate
Status Badge{StatusEmoji} {StatusText}
Date LabelDue: {DueDate}
Count Label{Count} items
Reference#{ReferenceNumber}

Error Recovery

{ColumnName} Shows Literally

ISSUE: Template shows "{FirstName}" instead of "John"

CHECK:
  - Column name spelled exactly right?
  - Case matches? ({firstName} vs {FirstName})
  - Column exists in this table?
  - Curly braces correct? Not (FirstName) or [FirstName]

FIX: Use column picker instead of typing

Empty Results

ISSUE: Template produces empty string

CHECK:
  - Do source columns have data?
  - Are all referenced columns populated?

NOTE: If any column is empty, that part will be blank
TIP: Use If-Then-Else to handle empty cases first

Special Characters Breaking Template

ISSUE: Template not working with special characters

CHECK:
  - Column names with spaces? Use exact name including spaces
  - Columns with special chars? Might need escaping

FIX: Usually the column picker handles this automatically

Tips

  1. Use column picker when available - Avoids typos in column names
  2. Check the preview - Make sure values substitute correctly before saving
  3. Handle empty values - Template will have gaps if columns are empty
  4. Watch spacing - {First} {Last} has space, {First}{Last} doesn't
  5. For URLs - Use unique IDs in seeds for different images per row

Image URL Best Practices

For generating unique images per row:

✅ Good: https://picsum.photos/seed/{ProductId}/400/300
   Each product gets a different image based on its ID

❌ Bad: https://picsum.photos/400/300
   Same random image for all rows

For people avatars:

https://randomuser.me/api/portraits/{gender}/{number}.jpg
https://i.pravatar.cc/300?u={UserId}

Report Format

TEMPLATE COLUMN ADDED:
  Table: {tableName}
  Column: {columnName}
  Template: {the template pattern}
  Status: SUCCESS | FAILED
  Sample Output: "{example merged value}"

Get API Key Procedure

Overview

Retrieves the API token from a Glide app. This token is needed for all API operations (creating tables, adding rows, etc.).

When to Use

  • Before any data-agent API operations
  • When setting up a new app
  • If stored API key has expired or is invalid

Procedure

Step 1: Navigate to Data Editor

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/data

EXPECTED: Data Editor loads
VERIFY: "Data" tab is active, table list visible

Step 2: Select Any Table

We need a table selected to access the API panel.

COMMAND: SNAPSHOT
PURPOSE: Find a table to select

FIND: Any table in the left sidebar
      "Users" table always exists in new apps
COMMAND: CLICK
REF: {ref of table, e.g., Users}
ELEMENT: "{tableName}" table

EXPECTED: Table opens in main area

Step 3: Open API Panel

COMMAND: SNAPSHOT
PURPOSE: Find "Show API" button

FIND: "Show API" button
      Usually in the toolbar above the table
      Or in a menu/dropdown
COMMAND: CLICK
REF: {ref of Show API button}
ELEMENT: "Show API" button

EXPECTED: API panel/modal appears
VERIFY: Shows code examples and token

Step 4: Locate the Token

COMMAND: SNAPSHOT
PURPOSE: Find the API token in the panel

FIND: The panel typically shows:
      1. Code examples (curl, JavaScript)
      2. A "secret token" or API key
      3. May have a "Copy" button next to it

LOOK FOR:
  - Text starting with "Bearer " followed by a long string
  - A masked/hidden token with a "Show" or "Copy" button
  - An input field containing the token

Step 5: Extract/Copy Token

If there's a copy button:

COMMAND: CLICK
REF: {ref of copy button near token}
ELEMENT: "Copy" or "Copy token" button

EXPECTED: Token copied to clipboard
NOTE: May need to read from clipboard or find token in UI

If token is visible in text:

COMMAND: SNAPSHOT
PURPOSE: Read the token value

FIND: The actual token string
      Usually looks like: a long alphanumeric string
      Format varies but typically 30+ characters

If token is in a code example:

Look for pattern:

Authorization: Bearer {TOKEN_HERE}

or

-H "Authorization: Bearer {TOKEN_HERE}"

Extract the token portion.

Step 6: Use Token

Once you have the token:

  1. Keep it in memory for the current session
  2. Pass it to API calls with Authorization: Bearer {token}
  3. Token is now available for all data operations

Step 7: Close API Panel

COMMAND: PRESS_KEY
KEY: Escape

Or:

COMMAND: CLICK
REF: {ref of close button}
ELEMENT: Close button on API panel

Verification

Test the token works:

curl -X GET "https://api.glideapps.com/tables" \
  -H "Authorization: Bearer {TOKEN}"

Should return list of tables (or empty list for new app).

Error Recovery

"Show API" Button Not Found

ISSUE: Can't find the Show API button

CHECK:
  1. Is a table selected? (button may only appear when table is open)
  2. Look in different locations:
     - Top toolbar
     - Table header area
     - Right-click menu on table
     - "..." overflow menu

TRY: Select a different table, look again

Token Appears Masked

ISSUE: Token shows as asterisks or dots

FIND: "Show" or "Reveal" button near the token
CLICK: The reveal button
THEN: Token should become visible

API Panel Won't Open

ISSUE: Nothing happens when clicking Show API

TRY:
  1. Refresh the page
  2. Navigate directly to Data Editor
  3. Try a different table
  4. Check if there's a popup blocker

Token Doesn't Work (401 Error)

ISSUE: API calls return 401 Unauthorized

CHECK:
  1. Token copied correctly? (no extra spaces)
  2. Token from correct app?
  3. Is this a Big Table? (API v2 only works with Big Tables)

TRY: Get a fresh token and try again

Important Notes

  1. API v2 only works with Big Tables - Native tables can't be accessed via API
  2. Token is per-team, not per-app - Same token works for all Big Tables in the team
  3. Keep token secure - Don't commit to version control
  4. Token may expire - If API calls start failing, get a fresh token

Report Format

API KEY RETRIEVED:
  App ID: {appId}
  Token: {first 8 chars}...{last 4 chars} (masked for security)
  Status: SUCCESS | FAILED
  Verified: Yes | No

Screen Builder Agent (UI Stack)

You build the entire UI layer of Glide apps: apps, tabs, screens, navigation, collections, components, and actions.

Your Responsibilities

App Level

  • Create new blank apps
  • Configure app settings (name, colors, theme)

Navigation Level

  • Add tabs/screens from data tables
  • Configure tab labels and icons
  • Set up navigation structure (tabs vs menu)
  • Create custom screens

Component Level

  • Configure collections (Card, List, Table, Kanban, etc.)
  • Add components to screens (Title, Text, Image, Button, etc.)
  • Set up data bindings for components
  • Add actions to buttons and components

What You Don't Do

  • Create or modify data structure (that's data-agent)
  • Design review and scoring (that's design-review agent)

How You Work

  1. Receive task from orchestrator - e.g., "Create Tasks tab with Card collection"
  2. Load relevant procedure - from the appropriate subdirectory
  3. Execute via browser executor - send step-by-step commands
  4. Report results back to orchestrator

Procedures

App Procedures (procedures/app/)

ProcedureFileUse When
Create Appapp/create-app.mdStarting a new blank app
Set App Settingsapp/set-app-settings.mdName, icon, colors, theme

Navigation Procedures (procedures/navigation/)

ProcedureFileUse When
Create Tabnavigation/create-tab.mdAdding a new navigation tab from a table

Component Procedures (procedures/components/)

ProcedureFileUse When
Configure Collectioncomponents/configure-collection.mdSetting collection style (Card, List, Table, etc.)
Add Componentcomponents/add-component.mdAdding any component to a screen
Add Actioncomponents/add-action.mdAdding actions to buttons, items, etc.

Key Concepts

Screen Types

TypeDescriptionWhen to Use
Screen from dataCollection screen backed by a tableMain entity screens (Tasks, Products, Users)
Custom screenBlank screen to build freelyDashboards, home pages, custom layouts
Form screenData entry formStandalone add/edit flows

Navigation Structure

Glide apps have two navigation areas:

  1. Navigation (Tab Bar) - Main tabs at bottom (mobile) or left/top (desktop)

    • Limited to 3-5 screens for good UX
    • Most important screens go here
  2. Menu (Slide-out) - Secondary screens in hamburger menu

    • For less frequent screens
    • Settings, Profile, Help

Collection Styles

StyleBest For
CardVisual items, images, browsing
ListSimple scanning, quick selection
TableComparing data, many columns (desktop)
KanbanStatus-based workflows
CalendarDate-based items
ChecklistTasks with checkboxes

Tab Labels & Icons

Labels:

  • Keep short: 1-2 words maximum
  • Good: "Tasks", "Team", "Settings"
  • Bad: "My Task List", "Team Member Directory"

Icons:

  • ⚠️ Skip emoji picker (causes token overflow)
  • Leave default icons - users can change manually later

Task Execution Flow

Example: "Create a new blank app called 'Inventory'"

1. RECEIVE TASK:
   Create new app named "Inventory"

2. LOAD PROCEDURE: app/create-app.md

3. EXECUTE via browser executor:
   - Navigate to go.glideapps.com
   - Click "New app"
   - Select "Blank"
   - Click "Create app"
   - Wait for editor to load
   - Set app name to "Inventory"

4. REPORT:
   SUCCESS: App "Inventory" created
   App ID: abc123xyz
   URL: go.glideapps.com/app/abc123xyz/layout

Example: "Create Tasks tab with Card collection"

1. RECEIVE TASK:
   Create tab for Tasks table with Card style

2. LOAD PROCEDURES:
   - navigation/create-tab.md
   - components/configure-collection.md

3. EXECUTE via browser executor:
   a) Create the tab:
      - Navigate to Layout Editor
      - Click "+" in Navigation section
      - Select "Screen from data"
      - Choose "Tasks" table
      - Set label to "Tasks"
   
   b) Configure collection:
      - Select collection component
      - Change style to "Card"
      - Set Title field to "name"
      - Set Image field to "image"

4. REPORT:
   SUCCESS: Tab "Tasks" created with Card collection
   Source: Tasks table
   Collection Style: Card
   Fields: Title=name, Image=image

Example: "Add Edit and Delete buttons to detail screen"

1. RECEIVE TASK:
   Add Edit and Delete buttons to Tasks detail screen

2. LOAD PROCEDURE: components/add-action.md

3. EXECUTE via browser executor:
   a) Navigate to detail screen (click an item in collection)
   b) Add Button component
   c) Configure Edit action (Show Form Screen)
   d) Add another Button
   e) Configure Delete action (Delete Row with confirmation)

4. REPORT:
   SUCCESS: Edit and Delete buttons added
   Screen: Tasks detail
   Actions: Edit (form), Delete (with confirmation)

Report Format

TASK: {what you were asked to do}
RESULT: {SUCCESS | PARTIAL | FAILURE}
DETAILS:
  - App ID: {if relevant}
  - Screen/Tab: {name}
  - Collection Style: {if relevant}
  - Components Added: {list}
  - Actions Configured: {list}
ISSUES: {any problems}
NEXT: {suggestions for follow-up}

Common Patterns

Pattern: New App Setup

  1. Create blank app (app/create-app.md)
  2. Set app name (short, 2 words max)
  3. Skip icon (causes token issues)
  4. Set accent color (optional)
  5. Report app ID for subsequent operations

Pattern: Complete Tab Setup

  1. Create tab from data (navigation/create-tab.md)
  2. Configure collection style (components/configure-collection.md)
  3. Add components to detail screen (components/add-component.md)
  4. Add actions/buttons (components/add-action.md)

Pattern: Dashboard + Entity Screens

  1. Create Custom screen for dashboard (put first)
  2. Create data screens for each entity
  3. Configure each collection appropriately
  4. Order: Dashboard → Primary entities → Settings

Error Handling

ErrorCauseAction
Table not in listTable not linked to appLink table first via Data Editor
Can't create tabApp not loadedNavigate to correct app URL
Emoji picker overflowToken limit exceededSkip emoji picker, use defaults
Component not foundWrong screen typeNavigate to correct screen first
Action not savingIncomplete configurationFill all required fields

Navigation Icons Reference

⚠️ Skip emoji picker to avoid token overflow.

Common default icons work fine. If user wants specific icons, they can change manually in Settings.

Create App Procedure

Overview

Creates a new blank Glide app. Always use Blank template - never import files.

Procedure

Step 1: Navigate to Dashboard

COMMAND: NAVIGATE
URL: https://go.glideapps.com

EXPECTED: Glide dashboard loads
VERIFY: Shows app gallery, "New app" button visible

Step 2: Check Authentication

COMMAND: SNAPSHOT
PURPOSE: Verify logged in

CHECK: 
  - If "Sign In" button visible → User needs to log in manually
  - If "New app" button visible → Proceed to Step 3

If not logged in:

REPORT: BLOCKED
REASON: User must log in to Glide
ACTION: Prompt user to sign in, then retry

Step 3: Click New App

COMMAND: SNAPSHOT
PURPOSE: Find New App button

FIND: "New app" button or card
      Usually prominent on dashboard
      May show as "+ New app" or just "New app"
COMMAND: CLICK
REF: {ref of New app button}
ELEMENT: "New app" button

EXPECTED: App template selection modal appears

Step 4: Select Blank Template

COMMAND: SNAPSHOT
PURPOSE: Find template options

FIND: Template selection UI showing options like:
      - "Blank" (what we want)
      - "Import a file" (NEVER use this)
      - Various templates
COMMAND: CLICK
REF: {ref of Blank option}
ELEMENT: "Blank" template option

EXPECTED: Blank option is selected/highlighted

Step 5: Create the App

COMMAND: SNAPSHOT
PURPOSE: Find Create button

FIND: "Create app" or "Create" button
      Usually at bottom of modal
COMMAND: CLICK
REF: {ref of Create button}
ELEMENT: "Create app" button

EXPECTED: Modal closes, new app loads in editor
WAIT: May take 2-5 seconds for app to initialize

Step 6: Wait for Editor to Load

COMMAND: WAIT_FOR_TEXT
TEXT: Layout

EXPECTED: Layout tab appears, indicating editor is ready

ALTERNATIVE TEXT: "Data" or "Settings" - any main nav tab
COMMAND: SNAPSHOT
PURPOSE: Confirm app loaded

VERIFY:
  - Main editor UI visible
  - Navigation tabs (Data, Layout, Settings) present
  - Preview area shows empty app

Step 7: Extract App ID

COMMAND: EVALUATE
CODE: () => window.location.href

EXPECTED: URL like "https://go.glideapps.com/app/{APP_ID}/layout"

Parse the APP_ID from the URL for future operations.

Step 8: Set App Name

Set the app name (skip the emoji icon - it causes UI issues):

COMMAND: CLICK
REF: {ref of Settings tab}
ELEMENT: "Settings" tab in main navigation

EXPECTED: Settings page loads
COMMAND: SNAPSHOT
PURPOSE: Find name input

FIND: "Name" or "Title" input field in Settings
      Usually in "Name & Icon" section at top
COMMAND: CLICK
REF: {ref of name input}
ELEMENT: App name input
COMMAND: PRESS_KEY
KEY: Meta+A
PURPOSE: Select all existing text
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: App name input
TEXT: {appName}

RULES:
  - 2 words maximum
  - No company name
  - No punctuation
  - Good: "Tasks", "Inventory", "CRM", "Team"
  - Bad: "Acme Task Manager!", "My Company's Inventory System"

App name saves automatically - no save button needed.

⚠️ SKIP THE EMOJI PICKER - Don't try to change the app icon. The emoji picker causes the page state to exceed token limits. Leave the default icon.

Verification

COMMAND: SNAPSHOT
PURPOSE: Final verification

VERIFY:
  - App exists and is editable
  - Can navigate between Data, Layout, Settings tabs
  - App name shows correctly (if set)

Error Recovery

"New app" Button Not Found

ISSUE: Dashboard doesn't show new app option

CHECK:
  1. Are you on the correct URL? (go.glideapps.com)
  2. Is the page fully loaded?
  3. Are you logged in to the correct team?

TRY: Refresh page, or navigate directly to go.glideapps.com

Template Modal Doesn't Appear

ISSUE: Clicking New app doesn't open modal

CHECK:
  1. Is there a popup blocker?
  2. Is another modal already open?

TRY:
  COMMAND: PRESS_KEY
  KEY: Escape
  
  Then retry clicking New app

App Creation Fails

ISSUE: Create button doesn't work or errors

CHECK:
  1. Is there an error message displayed?
  2. Is the account over app limit?
  3. Network connectivity issues?

TRY: Refresh and retry, or check Glide status

Editor Doesn't Load After Creation

ISSUE: Stuck on loading state

WAIT: Up to 10 seconds (new apps can be slow)

IF still stuck:
  COMMAND: NAVIGATE
  URL: https://go.glideapps.com
  
  Find the new app in dashboard and click to open

Important Notes

  1. NEVER use "Import a file" - Always use Blank and add data via API
  2. App names must be short - Enforce 2 word maximum
  3. Save the App ID - Needed for all future operations
  4. New apps have a Users table - This is normal and expected

Report Format

APP CREATED:
  Name: {appName}
  App ID: {appId}
  URL: https://go.glideapps.com/app/{appId}/layout
  Status: SUCCESS | FAILED
  Default Tables: Users

Set App Settings Procedure

Overview

Configures the app's basic settings: name, icon, accent color, and layout style.

Procedure

Step 1: Navigate to Settings

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/settings

EXPECTED: Settings page loads
VERIFY: Shows sections like "Name & Icon", "Appearance", "Access"

Step 2: Set App Name

COMMAND: SNAPSHOT
PURPOSE: Find Name & Icon section

FIND: "Name & Icon" section
      Input field for app name
COMMAND: CLICK
REF: {ref of name input}
ELEMENT: App name input
COMMAND: PRESS_KEY
KEY: Meta+A (select all existing text)
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: App name input
TEXT: {appName}

RULES:
  - Maximum 2 words
  - No company name (app lives in company's team)
  - No punctuation at end
  - Good: "Inventory", "Task Tracker", "Team Directory"
  - Bad: "Acme Corp Inventory System!", "My Task Tracker."

Name saves automatically.

Step 3: Skip App Icon

⚠️ DO NOT attempt to change the app icon.

The emoji picker causes the page state to exceed token limits (170k+ characters). Leave the default icon.

If the user specifically asks for a custom icon later, they can:

  1. Upload a custom image manually
  2. Or change it themselves in Settings

For now, proceed to the next step.

Step 4: Set Accent Color (Optional)

COMMAND: SNAPSHOT
PURPOSE: Find Appearance section

FIND: "Appearance" section
      Color picker or color options
COMMAND: CLICK
REF: {ref of color picker/option}
ELEMENT: Accent color selector

EXPECTED: Color options appear

If color picker input:

COMMAND: TYPE
REF: {ref of color input}
ELEMENT: Color input
TEXT: {hexColor}

EXAMPLE: #3B82F6 (blue), #10B981 (green), #F59E0B (amber)

If color swatches:

COMMAND: CLICK
REF: {ref of desired color swatch}
ELEMENT: {color name} color option

Step 5: Set Layout Style (Optional)

COMMAND: SNAPSHOT
PURPOSE: Find layout options

FIND: "Layout" setting with options:
      - "Left" (sidebar navigation on left)
      - "Top" (navigation at top)
COMMAND: CLICK
REF: {ref of desired layout option}
ELEMENT: "{Left|Top}" layout option

EXPECTED: Layout style updated

Step 6: Set Theme Style (Optional)

COMMAND: SNAPSHOT
PURPOSE: Find theme/style options

FIND: Style options like:
      - "Light" (light background)
      - "Deep" (dark/deep colors)
      - "Accent" (uses accent color prominently)
COMMAND: CLICK
REF: {ref of desired style}
ELEMENT: "{style}" theme option

EXPECTED: Theme style updated

Step 7: Verify Settings

COMMAND: SNAPSHOT
PURPOSE: Confirm all settings applied

VERIFY:
  - App name shows correctly
  - App icon is the selected emoji
  - Colors/theme look right in preview

Error Recovery

Icon Click Opens File Upload

ISSUE: Clicking icon area opens file upload instead of emoji picker

FIX: Click the icon IMAGE itself, not the "Upload" button/text
     The clickable emoji is usually smaller and shows current icon

Emoji Picker Won't Open

TRY:
  1. Press Escape to close any overlays
  2. Click directly on the current emoji/icon
  3. Refresh page and retry

Color Not Applying

CHECK:
  1. Is the hex code valid? (#RRGGBB format)
  2. Did you press Enter after typing?
  
TRY: Use preset color swatches instead of custom hex

Settings Not Saving

NOTE: Most settings auto-save in Glide

IF not saving:
  1. Try clicking outside the input field
  2. Refresh and check if changes persisted
  3. May need to wait a moment for sync

Report Format

APP SETTINGS CONFIGURED:
  Name: {appName}
  Icon: {emoji}
  Accent Color: {color}
  Layout: {Left | Top}
  Theme: {Light | Deep | Accent}
  Status: SUCCESS | PARTIAL | FAILED
  Issues: {any problems}

Add Action Procedure

Overview

Adds actions to components. Actions can navigate to screens, modify data, open URLs, send messages, and more.

Action Types

CategoryActions
NavigationShow New Screen, Show Form Screen, Go to Tab
DataAdd Row, Set Values, Delete Row
CommunicationCompose Email, Compose SMS, Phone Call
OtherOpen Link, Copy to Clipboard, Show Notification

Where Actions Can Be Added

  • Button components - Primary use case
  • Collection items - On tap/click
  • Form submit - After form submission
  • Action Row - List-style action items
  • Image/components - On tap

Procedure

Step 1: Navigate to Correct Screen

(Follow screen navigation from add-component.md)

Step 2: Select Component to Add Action To

COMMAND: SNAPSHOT
PURPOSE: Find target component

FIND: Component that should have the action
      (Button, Action Row, collection item, etc.)
COMMAND: CLICK
REF: {ref of component}
ELEMENT: "{componentName}" component

EXPECTED: Component selected, right panel shows settings

Step 3: Find Actions Section

COMMAND: SNAPSHOT
PURPOSE: Find actions configuration

FIND: "Actions" section or "On Click" / "On Tap" option
      Usually in right panel configuration
      May be a tab or expandable section
COMMAND: CLICK
REF: {ref of Actions section}
ELEMENT: Actions section or tab

EXPECTED: Actions configuration area shown

Step 4: Add New Action

COMMAND: SNAPSHOT
PURPOSE: Find add action button

FIND: "Add action" button or "+" in actions area
COMMAND: CLICK
REF: {ref of add action button}
ELEMENT: Add action button

EXPECTED: Action type selector appears

Step 5: Select Action Type

COMMAND: SNAPSHOT
PURPOSE: Find action type options

FIND: List or menu of action types
COMMAND: CLICK
REF: {ref of desired action type}
ELEMENT: "{actionType}" action

EXPECTED: Action added, configuration options appear

Step 6: Configure the Action

Configuration depends on action type:

Show New Screen
COMMAND: SNAPSHOT
PURPOSE: Find screen configuration

FIND: Screen source/type selector
COMMAND: CLICK
REF: {ref of screen source}
ELEMENT: Screen source selector

Options:

  • This item - Detail view of current row
  • Another table - Different data source
  • Current screen - Stay on same screen
Set Values (Update Data)
COMMAND: SNAPSHOT
PURPOSE: Find value configuration

FIND: Column and value selectors
COMMAND: CLICK
REF: {ref of column selector}
ELEMENT: Column to set
COMMAND: CLICK
REF: {ref of target column}
ELEMENT: "{columnName}" column
COMMAND: SNAPSHOT
PURPOSE: Find value input

Set the value:

COMMAND: TYPE
REF: {ref of value input}
ELEMENT: Value input
TEXT: {newValue}

OR select from options if it's a column reference
Delete Row
Usually no additional configuration needed.
May have confirmation toggle.
Open Link
COMMAND: SNAPSHOT
PURPOSE: Find URL configuration
COMMAND: TYPE
REF: {ref of URL input}
ELEMENT: URL input
TEXT: {url}

OR bind to a URL column
Compose Email
COMMAND: SNAPSHOT
PURPOSE: Find email configuration

Configure:

  • To: Email column or specific address
  • Subject: Text or template
  • Body: Text or template
COMMAND: CLICK
REF: {ref of "To" field}
ELEMENT: Email "To" field
COMMAND: CLICK
REF: {ref of email column}
ELEMENT: "{emailColumn}" column

Step 7: Configure Action Appearance (for Buttons)

COMMAND: SNAPSHOT
PURPOSE: Find button text/icon options

FIND: "Label" or "Title" input for button text
      Icon selector
COMMAND: TYPE
REF: {ref of label input}
ELEMENT: Action/Button label
TEXT: {buttonLabel}

EXAMPLES: "Save", "Delete", "Send Email", "Mark Complete"

Step 8: Order Multiple Actions

If multiple actions on same component:

COMMAND: SNAPSHOT
PURPOSE: See action order

NOTE: Top action in list = Leftmost button in UI

To reorder:

COMMAND: DRAG
FROM_REF: {ref of action to move}
FROM_ELEMENT: "{actionName}" action
TO_REF: {ref of target position}
TO_ELEMENT: Position {above|below} "{otherAction}"

EXPECTED: Actions reordered

Step 9: Verify Action

COMMAND: SNAPSHOT
PURPOSE: Confirm action configured

VERIFY:
  - Action appears in actions list
  - Button shows correct label in preview
  - Configuration is complete (no warnings)

Common Action Patterns

Edit Button

Action Type: Show Form Screen
Configuration: Edit form for current row
Label: "Edit"

Delete with Confirmation

Action Type: Delete Row
Configuration: Target current row
Options: Enable confirmation dialog
Label: "Delete"

Mark as Complete

Action Type: Set Values
Column: status
Value: "Complete"
Label: "Mark Complete" or "✓ Done"

Send Email

Action Type: Compose Email
To: {email column}
Subject: "Regarding: {item name}"
Body: Template text
Label: "Send Email" or "Contact"

Navigate to Related

Action Type: Show New Screen
Source: Related item (via relation column)
Label: "View Project" or "See Details"

Error Recovery

Action Type Not Available

ISSUE: Desired action not in list

CHECK:
  1. Some actions are plan-specific (Business/Enterprise)
  2. Some actions only available in certain contexts
  3. Check for similar action with different name

Action Not Triggering

ISSUE: Button exists but action doesn't work

CHECK:
  1. Is action configuration complete?
  2. Is there a validation error?
  3. For data actions: is target column writeable?
  4. Test in published app (preview may differ)

Wrong Button Order

ISSUE: Buttons appear in wrong order

FIX: Drag actions in list to reorder
     First action = leftmost button

Set Values Not Saving

ISSUE: Set Values action doesn't update data

CHECK:
  1. Correct column selected?
  2. Value is valid for column type?
  3. User has write permission?
  4. Is it a computed column? (can't write to computed)

Report Format

ACTION ADDED:
  Component: {buttonName or componentName}
  Screen: {screenName}
  Action Type: {actionType}
  Configuration: {key settings}
  Label: {button label if applicable}
  Status: SUCCESS | FAILED

Add Component Procedure

Overview

Adds a component to a screen and configures its basic settings. Works for any component type.

Important: Screen Navigation

You must be on the correct screen before adding components:

Screen TypeHow to Navigate
CollectionSelect tab in Navigation
DetailClick an item in the preview
EditClick Edit button on detail screen
AddClick Add button on collection screen

Procedure

Step 1: Navigate to Correct Screen

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/layout

EXPECTED: Layout Editor loads

For Collection Screen:

COMMAND: CLICK
REF: {ref of tab in Navigation}
ELEMENT: "{tabName}" tab

EXPECTED: Collection screen shown

For Detail Screen:

COMMAND: CLICK
REF: {ref of tab in Navigation}
ELEMENT: "{tabName}" tab
COMMAND: SNAPSHOT
PURPOSE: Find an item to click in preview
COMMAND: CLICK
REF: {ref of any item in collection preview}
ELEMENT: Any item in collection

EXPECTED: Preview navigates to detail screen
VERIFY: Left sidebar shows detail screen components

For Edit Screen: (First navigate to detail screen, then:)

COMMAND: SNAPSHOT
PURPOSE: Find Edit button in preview
COMMAND: CLICK
REF: {ref of Edit button}
ELEMENT: Edit button in preview

EXPECTED: Edit form screen shown

For Add Screen: (From collection screen:)

COMMAND: SNAPSHOT
PURPOSE: Find Add button in preview
COMMAND: CLICK
REF: {ref of Add button}
ELEMENT: Add/+ button in preview

EXPECTED: Add form screen shown

Step 2: Open Component Picker

COMMAND: SNAPSHOT
PURPOSE: Find add component button

FIND: "+" button in Components section of left sidebar
      May say "Add component" or just show "+"
COMMAND: CLICK
REF: {ref of add component button}
ELEMENT: Add component button

EXPECTED: Component picker appears
VERIFY: Shows categories like Title, Collections, Text, etc.

Step 3: Find the Component

COMMAND: SNAPSHOT
PURPOSE: Find search or component list

FIND: Search input at top of component picker
      Or browse categories

Using Search:

COMMAND: TYPE
REF: {ref of search input}
ELEMENT: Component search
TEXT: {componentName}

EXPECTED: Components filtered to matches
COMMAND: SNAPSHOT
PURPOSE: Find the component in results

Or Browse Categories:

COMMAND: CLICK
REF: {ref of category}
ELEMENT: "{categoryName}" category

EXPECTED: Shows components in that category

Step 4: Add the Component

COMMAND: CLICK
REF: {ref of component}
ELEMENT: "{componentName}" component

EXPECTED: 
  - Component added to screen
  - Component appears in left sidebar component list
  - Component shows in preview
  - Right panel shows component configuration

Step 5: Configure the Component

Configuration varies by component type. Common patterns:

Bind to Data Column
COMMAND: SNAPSHOT
PURPOSE: Find data binding options

FIND: Dropdown showing column options or "Data" field
COMMAND: CLICK
REF: {ref of data dropdown}
ELEMENT: Data/Column selector
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of target column}
ELEMENT: "{columnName}" column

EXPECTED: Component bound to column
Set Label/Title
COMMAND: SNAPSHOT
PURPOSE: Find label input

FIND: "Label" or "Title" input field
COMMAND: TYPE
REF: {ref of label input}
ELEMENT: Label input
TEXT: {labelText}
Configure Style Options
COMMAND: SNAPSHOT
PURPOSE: Find style options

FIND: Style toggles, dropdowns, or radio buttons
      May be in "Options" tab of right panel
COMMAND: CLICK
REF: {ref of style option}
ELEMENT: "{optionName}" option

EXPECTED: Style applied

Step 6: Position the Component (Optional)

Components can be reordered in the left sidebar:

COMMAND: DRAG
FROM_REF: {ref of component in sidebar}
FROM_ELEMENT: "{componentName}" component
TO_REF: {ref of target position}
TO_ELEMENT: Position after "{otherComponent}"

EXPECTED: Component moves to new position

Step 7: Verify Component Added

COMMAND: SNAPSHOT
PURPOSE: Confirm component exists and is configured

VERIFY:
  - Component appears in left sidebar
  - Component shows in preview
  - Data binding shows correct data

Component-Specific Configuration

Title Components (Profile, Cover, Image)

Configure:
- Image: Column with image URL
- Title: Main text (name, title)
- Subtitle: Secondary text (role, description)

Big Numbers

Configure:
- Data: Column with numeric value
- Label: What the number represents
- Format: Number format options

Contact

Configure:
- Email: Column with email address
- Phone: Column with phone number
(Creates tap-to-call/email buttons)

Inline Collection

Configure:
- Data: Relation column (must be a relation!)
- Style: Card, List, Table, etc.
- Title/fields: What to show per item

Progress

Configure:
- Data: Number column (0-100 or 0-1)
- May need to set min/max values

Container

Configure:
- Columns: Number of columns (1, 2, 3, 4)
- Add components INSIDE the container

Error Recovery

Component Not Found

ISSUE: Component doesn't appear in picker

CHECK:
  1. Correct spelling?
  2. Try category browsing
  3. Some components are Beta/Business only

ALTERNATIVES:
  "Big Numbers" → search "big"
  "Rich Text" → search "rich"
  "Inline Collection" → search "inline" or "collection"

Can't Add Component

ISSUE: Component won't add to screen

CHECK:
  1. Are you on the right screen type?
  2. Some components only work on certain screens
  3. Is there a parent container selected?

Data Binding Empty

ISSUE: No columns show in data selector

CHECK:
  1. Is this screen backed by a table?
  2. Does the table have columns?
  3. For Inline Collection: need a Relation column

Component in Wrong Position

FIX: Drag component in sidebar to reorder
     Or delete and re-add in correct position

Deleting Components

To remove a component:

COMMAND: SNAPSHOT
PURPOSE: Find component to delete

FIND: Component in left sidebar
COMMAND: CLICK
REF: {ref of component}
ELEMENT: "{componentName}" component

EXPECTED: Component selected
COMMAND: PRESS_KEY
KEY: Backspace (or Delete)

EXPECTED: Component removed

ALTERNATIVE: Right-click → Delete

Report Format

COMPONENT ADDED:
  Screen: {collection | detail | edit | add} on {tabName}
  Component: {componentName}
  Data Binding: {column or relation bound to}
  Configuration: {key settings}
  Status: SUCCESS | FAILED

Configure Collection Procedure

Overview

Changes a collection's style (Card, List, Table, etc.) and configures which columns/fields are displayed.

Collection Styles

StyleBest For
CardVisual items, images, browsing
ListSimple scanning, quick selection
TableComparing data, numbers, many columns
Data GridInline editing
ChecklistTasks with checkboxes
CalendarDate-based items
KanbanStatus workflows

Procedure

Step 1: Navigate to Layout Editor

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/layout

EXPECTED: Layout Editor loads

Step 2: Select the Tab

COMMAND: SNAPSHOT
PURPOSE: Find target tab in Navigation section

FIND: "{tabName}" in left sidebar under Navigation or Menu
COMMAND: CLICK
REF: {ref of tab}
ELEMENT: "{tabName}" tab

EXPECTED: Tab selected, collection screen shown in preview
VERIFY: Left sidebar shows Components for this screen

Step 3: Select the Collection Component

COMMAND: SNAPSHOT
PURPOSE: Find the collection component

FIND: In left sidebar Components list:
      - Component named "Collection" or the table name
      - Or click directly on the collection in preview
COMMAND: CLICK
REF: {ref of collection component}
ELEMENT: Collection component

EXPECTED: Collection selected
VERIFY: Right panel shows collection configuration options

Step 4: Change Collection Style

COMMAND: SNAPSHOT
PURPOSE: Find style selector

FIND: "Style" dropdown or style options
      May show current style (e.g., "Card", "List")
      Usually near top of right panel
COMMAND: CLICK
REF: {ref of style dropdown}
ELEMENT: Collection style selector

EXPECTED: Style options appear
COMMAND: SNAPSHOT
PURPOSE: Find desired style option
COMMAND: CLICK
REF: {ref of desired style}
ELEMENT: "{styleName}" style option

EXPECTED: Collection style changes
VERIFY: Preview updates to show new style

Step 5: Configure Displayed Fields/Columns

The configuration depends on collection style:

For Card Style:
COMMAND: SNAPSHOT
PURPOSE: Find card configuration options

FIND: Options like:
      - "Title" - main text field
      - "Subtitle" - secondary text
      - "Image" - image column
      - "Details" - additional info

For each field:

COMMAND: CLICK
REF: {ref of field dropdown}
ELEMENT: "{fieldName}" field selector
COMMAND: SNAPSHOT
PURPOSE: Find column options
COMMAND: CLICK
REF: {ref of desired column}
ELEMENT: "{columnName}" column

EXPECTED: Field bound to selected column
For List Style:
COMMAND: SNAPSHOT
PURPOSE: Find list configuration

FIND: Options like:
      - "Title" - main text
      - "Subtitle" - secondary text  
      - "Image" - thumbnail

Configure as above for Card.

For Table Style:
COMMAND: SNAPSHOT
PURPOSE: Find column configuration

FIND: "Columns" section
      - List of visible columns
      - Option to add/remove columns
      - Column order controls

To add a column:

COMMAND: CLICK
REF: {ref of "Add column" button}
ELEMENT: Add column button

EXPECTED: Column picker appears
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of column to add}
ELEMENT: "{columnName}" column

EXPECTED: Column added to table

To remove a column:

COMMAND: SNAPSHOT
PURPOSE: Find column to remove

FIND: Column in the list with "x" or remove button
COMMAND: CLICK
REF: {ref of remove button for column}
ELEMENT: Remove "{columnName}" column

EXPECTED: Column removed from table

To reorder columns:

COMMAND: DRAG
FROM_REF: {ref of column to move}
FROM_ELEMENT: "{columnName}" column
TO_REF: {ref of target position}
TO_ELEMENT: Position after "{otherColumn}"

EXPECTED: Column order changed

Step 6: Configure Additional Options

COMMAND: SNAPSHOT
PURPOSE: Find additional options

LOOK FOR:
  - "Show search" toggle
  - "Show filter" toggle
  - "Show add button" toggle
  - Row action settings
  - Sorting options

Configure as needed:

COMMAND: CLICK
REF: {ref of option toggle}
ELEMENT: "{optionName}" toggle

EXPECTED: Option enabled/disabled

Step 7: Verify Configuration

COMMAND: SNAPSHOT
PURPOSE: Confirm collection is configured correctly

VERIFY:
  - Collection shows correct style in preview
  - Configured columns/fields are visible
  - Data displays correctly
  - On desktop view (switch if needed)

Switching to Desktop View

For better review of Table collections:

COMMAND: SNAPSHOT
PURPOSE: Find device switcher

FIND: Device icons in preview toolbar (phone/tablet/desktop)
COMMAND: CLICK
REF: {ref of desktop icon}
ELEMENT: Desktop preview button

EXPECTED: Preview shows desktop-width layout

Error Recovery

Style Dropdown Won't Open

TRY:
  1. Make sure collection component is selected
  2. Press Escape and reselect collection
  3. Look for style options in different location

Column Not Available

ISSUE: Column doesn't appear in selection

CHECK:
  1. Does column exist in the source table?
  2. Is it a computed column that hasn't saved?
  3. Is it in the correct table?

FIX: Go to Data Editor and verify column exists

Preview Not Updating

TRY:
  1. Click elsewhere then back on collection
  2. Refresh the page
  3. Check if changes saved

Table Columns Cut Off

ISSUE: Table columns don't all fit

CHECK: Are you in Desktop view?
       Mobile preview will truncate columns

TRY:
  1. Switch to Desktop preview
  2. Remove less important columns
  3. Use column width settings if available

Style-Specific Tips

Card

  • Always bind an Image field if data has images
  • Title should be the main identifier (name, title)
  • Keep subtitle short - it may truncate

List

  • Best for simple 2-3 field items
  • Consider adding image for visual interest
  • Good for quick selection/navigation

Table

  • Best on desktop - hard to use on mobile
  • Show 4-6 columns maximum
  • Put most important columns first
  • Consider adding status emoji column

Kanban

  • Requires a column to group by (status, category)
  • Configure the "Group by" field
  • Each group becomes a Kanban column

Calendar

  • Requires a date column
  • Configure which date field to use
  • Items show on their date

Report Format

COLLECTION CONFIGURED:
  Tab: {tabName}
  Style: {Card | List | Table | ...}
  Fields/Columns: {list of visible fields}
  Options: {enabled options like search, filter}
  Status: SUCCESS | FAILED
  Notes: {any issues}

Create Tab Procedure

Overview

Creates a new tab in the app navigation, backed by a data table. This creates a screen that shows a collection of items from the table.

Procedure

Step 1: Navigate to Layout Editor

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/layout

EXPECTED: Layout Editor loads
VERIFY: Left sidebar shows Navigation and Menu sections

Step 2: Find the Add Button

COMMAND: SNAPSHOT
PURPOSE: Find the Navigation section and add button

FIND: In left sidebar:
      - Section labeled "Navigation" or "Tabs"
      - A "+" button to add new screens
      
NOTE: There may be two sections:
      - "Navigation" (main tabs)
      - "Menu" (slide-out menu)
      
      We usually want "Navigation" for main screens

Step 3: Click Add (+) Button

COMMAND: CLICK
REF: {ref of + button in Navigation section}
ELEMENT: Add screen button in Navigation

EXPECTED: Screen type selection menu appears

Step 4: Select "Screen from data"

COMMAND: SNAPSHOT
PURPOSE: Find screen type options

FIND: Menu showing options like:
      - "Screen from data" (what we want)
      - "Custom screen"
      - "Form screen"
COMMAND: CLICK
REF: {ref of "Screen from data" option}
ELEMENT: "Screen from data" option

EXPECTED: Table selection UI appears

Step 5: Select Source Table

COMMAND: SNAPSHOT
PURPOSE: Find table list

FIND: List of available tables
      Should show all tables linked to this app
COMMAND: CLICK
REF: {ref of target table}
ELEMENT: "{tableName}" in table list

EXPECTED: 
  - Table selected
  - New tab created in Navigation
  - Preview shows collection of items from table

Step 6: Configure Tab Label

COMMAND: SNAPSHOT
PURPOSE: Find tab configuration panel

FIND: Right panel showing tab settings
      Look for "Label" or "Name" input field
      May also show icon selector
COMMAND: CLICK
REF: {ref of label input}
ELEMENT: Tab label input

Select all existing text first:

COMMAND: PRESS_KEY
KEY: Meta+A (Mac) or Control+A (Windows)
COMMAND: TYPE
REF: {ref of label input}
ELEMENT: Tab label input
TEXT: {tabLabel}

RULES:
  - 1-2 words maximum
  - Clear and descriptive
  - Good: "Tasks", "Team", "Orders"
  - Bad: "All Tasks List", "Team Members"

Step 7: Skip Tab Icon (Optional)

⚠️ SKIP the emoji picker for tab icons.

The emoji picker causes page state to exceed token limits. Leave the default icon.

The default icons are usually acceptable. If needed, icons can be changed manually later.

Proceed directly to Step 8 (verification).

Step 8: Verify Tab Created

COMMAND: SNAPSHOT
PURPOSE: Confirm tab exists and is configured

VERIFY:
  - Tab appears in Navigation list in sidebar
  - Tab shows correct label
  - Tab shows correct icon
  - Preview shows collection from table

Creating Tab in Menu Instead

If the screen should be in the Menu (not main Navigation):

In Step 3, click the "+" in the Menu section instead of Navigation.

The rest of the procedure is the same.

Error Recovery

Table Not in List

ISSUE: Target table doesn't appear in table selection

CAUSE: Table not linked to this app

FIX:
  1. Go to Data Editor (Data tab)
  2. Click team name in Data Sources
  3. Link the table to this app
  4. Return to Layout and retry

Emoji Picker Issues

ISSUE: Emoji picker causes errors or page state too large

SOLUTION: Skip the emoji picker entirely.
          Leave default icons - they work fine.
          Users can change icons manually if needed.

Preview Shows Empty Collection

ISSUE: Tab created but preview shows no items

CHECK:
  1. Does the table have any data?
  2. Is the data visible to current user?
  3. Are there row owner restrictions?

NOTE: If table is empty, this is expected
      Add sample data to see the collection

Wrong Collection Style

ISSUE: Collection doesn't look right

NOTE: This procedure creates the tab with default collection style
      Collection style configuration is handled by configure-collection.md
      
REPORT: Tab created, collection style needs configuration

Tab in Wrong Position

ISSUE: Tab appeared in Menu instead of Navigation (or vice versa)

FIX: Can drag tabs between Navigation and Menu
  1. Find the tab in sidebar
  2. Drag it to the correct section
  
Or: Delete and recreate in correct section

Report Format

TAB CREATED:
  Label: {tabLabel}
  Icon: {icon/emoji}
  Source Table: {tableName}
  Position: Navigation | Menu
  Status: SUCCESS | FAILED
  Notes: {any issues, e.g., "needs collection style config"}

Skill Learner Agent

You extract learnings from successful expert tips and update the plugin's knowledge base.

⚠️ CRITICAL CONSTRAINTS - READ FIRST

You can ONLY add knowledge to these existing locations:

✅ ALLOWED Locations

1. Existing Skill Files (WHAT something is, design guidance):

${CLAUDE_PLUGIN_ROOT}/skills/glide/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/data-modeling/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/computed-columns/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/design/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/api/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/app-sharing/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/workflows/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/ai/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/learnings-log/SKILL.md

2. Existing Agent Procedure Folders (HOW to do UI operations):

${CLAUDE_PLUGIN_ROOT}/agents/data/procedures/           ← Data operations
${CLAUDE_PLUGIN_ROOT}/agents/screen-builder/procedures/ ← Screen creation
${CLAUDE_PLUGIN_ROOT}/agents/component-builder/procedures/ ← Component config

3. Browser Selectors (UI element locations):

${CLAUDE_PLUGIN_ROOT}/browser/selectors/

❌ FORBIDDEN - Never Do These

  • ❌ Create new skill folders - Only update existing skills
  • ❌ Create new agent folders - Only add procedures to existing agents
  • ❌ Create top-level files - Knowledge must go in existing structure
  • ❌ Modify orchestrator/ORCHESTRATOR.md - It coordinates, doesn't hold knowledge
  • ❌ Modify browser/EXECUTOR.md - It's a dumb execution layer
  • ❌ Create agents outside the 3 agent folders - data, screen-builder, component-builder ONLY

Your Mission

When an expert Glide builder provides a tip that successfully solves a problem, you:

  1. Analyze what was learned
  2. Determine the correct location (skill, procedure, or selector)
  3. Read the current content
  4. Intelligently merge the new learning
  5. Update the appropriate file(s)
  6. Add an entry to the learnings log

Input You'll Receive

You'll be given:

  • Original context: What task was stuck and why
  • The expert tip: Instructions the user provided
  • What was executed: Actions taken to implement the tip
  • Result: Confirmation that it worked

Decision: Procedure vs Skill vs Selector

First, determine WHAT KIND of knowledge this is:

Add a PROCEDURE (agents/*/procedures/) when:

  • Tip describes step-by-step browser actions
  • Tip is about HOW to click/navigate/interact with Glide UI
  • Tip includes specific UI sequences (click this, then type that)
  • Tip fixes a browser automation failure

Example procedure tips:

  • "To add a column, press Cmd+Shift+Enter instead of clicking"
  • "You need to click the column header first, then the + icon appears"
  • "After selecting the type, wait 500ms before clicking Save"

Put in the right agent's procedures folder:

  • Data/column/table operations → agents/data/procedures/
  • Screen/tab/navigation → agents/screen-builder/procedures/
  • Component/form/action → agents/component-builder/procedures/

Update a SKILL (skills/*/SKILL.md) when:

  • Tip describes what something is or when to use it
  • Tip is about design decisions or best practices
  • Tip explains concepts or architecture
  • Tip is about API behavior or data modeling patterns

Example skill tips:

  • "Use Table collection for data-heavy screens, Cards for visual browsing"
  • "AI columns run on every row, so be careful with large tables"
  • "Relations must be created after both tables exist"

Update SELECTORS (browser/selectors/) when:

  • Tip identifies where a UI element is located
  • Tip describes how to find a specific button/input/panel
  • Tip is about element naming in Glide's UI

Example selector tips:

  • "The Add column button is in the Data Editor toolbar, not the sidebar"
  • "The type picker is a modal that appears after clicking the Type dropdown"

Locating and Editing Files

IMPORTANT: All files are within the plugin's directory structure. Use ${CLAUDE_PLUGIN_ROOT} to reference the plugin root.

Skill File Paths

All skills are in: ${CLAUDE_PLUGIN_ROOT}/skills/{skill-name}/SKILL.md

${CLAUDE_PLUGIN_ROOT}/skills/glide/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/data-modeling/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/computed-columns/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/design/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/ai/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/api/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/app-sharing/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/workflows/SKILL.md
${CLAUDE_PLUGIN_ROOT}/skills/learnings-log/SKILL.md

Procedure File Paths (For UI How-To Knowledge)

Data Agent Procedures:

${CLAUDE_PLUGIN_ROOT}/agents/data/procedures/add-column.md
${CLAUDE_PLUGIN_ROOT}/agents/data/procedures/add-relation.md
${CLAUDE_PLUGIN_ROOT}/agents/data/procedures/add-computed.md
${CLAUDE_PLUGIN_ROOT}/agents/data/procedures/get-api-key.md
${CLAUDE_PLUGIN_ROOT}/agents/data/procedures/{new-procedure}.md  ← Add new here

Screen Builder Procedures:

${CLAUDE_PLUGIN_ROOT}/agents/screen-builder/procedures/create-app.md
${CLAUDE_PLUGIN_ROOT}/agents/screen-builder/procedures/create-tab.md
${CLAUDE_PLUGIN_ROOT}/agents/screen-builder/procedures/set-app-settings.md
${CLAUDE_PLUGIN_ROOT}/agents/screen-builder/procedures/{new-procedure}.md  ← Add new here

Component Builder Procedures:

${CLAUDE_PLUGIN_ROOT}/agents/component-builder/procedures/configure-collection.md
${CLAUDE_PLUGIN_ROOT}/agents/component-builder/procedures/add-component.md
${CLAUDE_PLUGIN_ROOT}/agents/component-builder/procedures/add-action.md
${CLAUDE_PLUGIN_ROOT}/agents/component-builder/procedures/{new-procedure}.md  ← Add new here

Browser Selector Paths

${CLAUDE_PLUGIN_ROOT}/browser/selectors/navigation.md
${CLAUDE_PLUGIN_ROOT}/browser/selectors/data-editor.md
${CLAUDE_PLUGIN_ROOT}/browser/selectors/components.md
${CLAUDE_PLUGIN_ROOT}/browser/selectors/{new-area}.md  ← Add new here

How to Edit Skills

Reading a skill file:

Read tool → file_path: ${CLAUDE_PLUGIN_ROOT}/skills/design/SKILL.md

Editing a skill file:

Edit tool →
  file_path: ${CLAUDE_PLUGIN_ROOT}/skills/design/SKILL.md
  old_string: [exact text to replace]
  new_string: [new text with learning added]

How to Add/Edit Procedures

Reading an existing procedure:

Read tool → file_path: ${CLAUDE_PLUGIN_ROOT}/agents/data/procedures/add-column.md

Editing an existing procedure:

Edit tool →
  file_path: ${CLAUDE_PLUGIN_ROOT}/agents/data/procedures/add-column.md
  old_string: [exact text to replace]
  new_string: [updated steps]

Creating a NEW procedure (use Write tool):

Write tool →
  file_path: ${CLAUDE_PLUGIN_ROOT}/agents/{agent}/procedures/{name}.md
  content: [full procedure content using template below]

New Procedure Template:

---
name: {procedure-name}
description: {what this procedure accomplishes}
preconditions:
  - {what must be true before starting}
---

# {Procedure Title}

## Overview
{Brief description of what this does}

## Procedure

### Step 1: {First Action}
\`\`\`
COMMAND: {NAVIGATE|SNAPSHOT|CLICK|TYPE|etc}
{parameters}

EXPECTED: {what should happen}
VERIFY: {how to confirm it worked}
\`\`\`

### Step 2: {Next Action}
...

## Error Recovery

### {Error Scenario}
\`\`\`
ISSUE: {what went wrong}
CHECK: {what to verify}
FIX: {how to recover}
\`\`\`

## Report Format
\`\`\`
{WHAT}_COMPLETED:
  {key}: {value}
  Status: SUCCESS | FAILED
\`\`\`

⚠️ ONLY create procedures in these folders:

  • agents/data/procedures/
  • agents/screen-builder/procedures/
  • agents/component-builder/procedures/

The learnings log:

Read/Edit → file_path: ${CLAUDE_PLUGIN_ROOT}/skills/learnings-log/SKILL.md

Example: Adding to Layout Skill

  1. Read the file:

    • Use Read tool with path: ${CLAUDE_PLUGIN_ROOT}/skills/layout/SKILL.md
  2. Find the right section:

    • Look for "## Adding Columns" or similar
  3. Use Edit tool:

    • file_path: ${CLAUDE_PLUGIN_ROOT}/skills/layout/SKILL.md
    • old_string: [existing section content you want to enhance]
    • new_string: [existing content + your new learning]

Critical: Always use ${CLAUDE_PLUGIN_ROOT} - never hardcode paths. This ensures the edits work regardless of where the plugin is installed.

Your Process

Step 1: Analyze the Learning

Extract the key knowledge from the tip:

  • What was the problem/misunderstanding?
  • What was the correct approach?
  • Why does it work this way?
  • When should this approach be used?
  • Are there edge cases or caveats?

Step 2: Determine Target Skill(s)

Analyze the tip content to determine which skill file(s) should be updated.

Decision process:

  1. Identify the core topic - What is this tip primarily about?
  2. Check the mapping table - Which skill(s) cover this topic?
  3. Consider cross-cutting concerns - Does it apply to multiple areas?

Knowledge Location Reference:

Skills (WHAT/WHY - Concepts & Design Guidance)

Topic AreaSkill File Path
Overall workflow, agent coordination${CLAUDE_PLUGIN_ROOT}/skills/glide/SKILL.md
Tables, columns, data structure${CLAUDE_PLUGIN_ROOT}/skills/data-modeling/SKILL.md
Math, If-Then-Else, Relations, Rollups${CLAUDE_PLUGIN_ROOT}/skills/computed-columns/SKILL.md
Screen design principles, component selection${CLAUDE_PLUGIN_ROOT}/skills/design/SKILL.md
AI columns, AI features${CLAUDE_PLUGIN_ROOT}/skills/ai/SKILL.md
Glide API, data import/export${CLAUDE_PLUGIN_ROOT}/skills/api/SKILL.md
Privacy, authentication, publishing${CLAUDE_PLUGIN_ROOT}/skills/app-sharing/SKILL.md
Workflows, automation, triggers${CLAUDE_PLUGIN_ROOT}/skills/workflows/SKILL.md

Procedures (HOW - Step-by-Step UI Operations)

Topic AreaProcedure Location
Adding/editing columnsagents/data/procedures/
Creating relations, rollups, lookupsagents/data/procedures/
Computed column configurationagents/data/procedures/
API key retrievalagents/data/procedures/
Creating appsagents/screen-builder/procedures/
Creating tabs/screensagents/screen-builder/procedures/
App settings (name, icon, colors)agents/screen-builder/procedures/
Collection configurationagents/component-builder/procedures/
Adding componentsagents/component-builder/procedures/
Form configurationagents/component-builder/procedures/
Action configurationagents/component-builder/procedures/

Selectors (WHERE - UI Element Locations)

AreaSelector File
Main nav, dashboard, app creationbrowser/selectors/navigation.md
Tables, columns, API panelbrowser/selectors/data-editor.md
Component picker, configurationbrowser/selectors/components.md

Examples of determination:

Example 1: UI Navigation Tip

Tip: "Click the '+' icon in the column header to add columns, there's no 'Add column' button"
Analysis:
- Primary topic: UI navigation in Glide Builder
- Specific to: Column management interface
- Decision: Update layout/SKILL.md (covers screens, UI components, navigation)

Example 2: API Behavior Tip

Tip: "Glide API rate limits table creation to 1 per 2 seconds"
Analysis:
- Primary topic: API behavior and constraints
- Decision: Update api/SKILL.md (covers Glide API usage)

Example 3: Workflow Pattern Tip

Tip: "Query returns objects, use Set Column to extract fields before passing to Email node"
Analysis:
- Primary topic: Workflow node usage patterns
- Decision: Update workflows/SKILL.md (covers workflow automation)

Example 4: Multi-Skill Tip

Tip: "To calculate complex formulas, chain multiple computed columns together"
Analysis:
- Primary topic: Computed column architecture
- Also relates to: General data modeling approach
- Decision: Update BOTH:
  1. computed-columns/SKILL.md (the main technique)
  2. data-modeling/SKILL.md (conceptual explanation)

Example 5: Emoji Picker (Cross-Cutting)

Tip: "Always use emoji search, never browse categories - it's more reliable"
Analysis:
- Used in: App icon selection, emoji field inputs, component icons
- Appears in: App creation flow, field configuration
- Decision: Update BOTH:
  1. glide/SKILL.md (in "Creating New App" section for app icons)
  2. layout/SKILL.md (general emoji picker usage pattern)

Decision Guidelines:

  • If tip is about WHAT to do: Usually glide/SKILL.md (workflow, strategy)
  • If tip is about HOW the UI works: Usually layout/SKILL.md (UI interactions)
  • If tip is about API behavior: Usually api/SKILL.md
  • If tip is about data structure: Usually data-modeling/SKILL.md
  • If tip is about calculations: Usually computed-columns/SKILL.md
  • If tip is about automation: Usually workflows/SKILL.md

Multiple skills: Update all relevant skills when the learning applies to multiple contexts. It's better to add to 2-3 skills than to have knowledge hidden in just one.

Step 3: Read Current Skill Content

Use the Read tool to read the entire target skill file(s).

Example: If updating the layout skill, use:

Read tool:
  file_path: ${CLAUDE_PLUGIN_ROOT}/skills/layout/SKILL.md

Analyze the contents:

  • Does similar information already exist?
  • Where does this new learning fit best?
  • What section should it be added to?
  • Should it enhance existing content or create a new section?

Note: Read the ENTIRE file (don't use offset/limit) so you understand the full structure before making changes.

Step 4: Craft the Update

Write the new content following these principles:

Specificity: Be concrete and actionable

  • Bad: "Be careful when adding columns"
  • Good: "To add a column, click the '+' icon in the column header (not a separate 'Add column' button)"

Context: Explain when/why this matters

  • Include the scenario where this applies
  • Note any conditions or prerequisites
  • Mention what happens if you don't follow this approach

Examples: Show, don't just tell

  • Include specific steps
  • Show the pattern that works
  • Reference specific UI elements or API calls

Integration: Match the existing style

  • Use the same formatting (headers, lists, tables)
  • Follow the existing structure
  • Maintain consistent tone
  • Don't duplicate existing content

Step 5: Update the Skill File

Use the Edit tool to add the new learning to the skill file.

Placement strategies:

  1. Enhance existing section: If there's already a section covering this topic, add to it

    ## Adding Columns
    
    [Existing content about columns...]
    
    **Finding the add column control:**
    - Click the '+' icon in any column header
    - The icon is subtle (light gray) and appears on hover
    - There is no separate "Add column" button in the toolbar
    
  2. Create new section: If it's a new topic

    ## Working with the Emoji Picker
    
    When selecting app icons or emoji fields:
    - Always use the search box (don't browse categories)
    - Type the emoji name (e.g., "rocket", "checkmark")
    - Click the result - don't use keyboard navigation
    
    This is much faster than scrolling through categories.
    
  3. Add to tips/troubleshooting: Create or enhance a troubleshooting section

    ## Common Issues
    
    ### Element Not Found Errors
    - Glide's UI uses subtle icons that only appear on hover
    - Take a snapshot after hovering to see all interactive elements
    - Wait for animations to complete before taking snapshots
    
  4. Update existing examples: Improve clarity of existing examples

    ## Example: Creating a Computed Column
    
    1. Navigate to Data tab
    2. Hover over the column header where you want to add a column
    3. Click the '+' icon that appears (NOT a menu button)
    4. Select column type from dropdown
    5. Configure and save
    

Step 6: Validate the Update

After updating, verify:

  • The file is valid markdown
  • The new content fits naturally with existing content
  • No duplicate information was added
  • Formatting is consistent
  • Examples are clear and specific

Step 7: Update the Learnings Log

After updating skill files, add an entry to the learnings log.

File path: ${CLAUDE_PLUGIN_ROOT}/skills/learnings-log/SKILL.md

Steps:

  1. Read the learnings log:

    Read tool:
      file_path: ${CLAUDE_PLUGIN_ROOT}/skills/learnings-log/SKILL.md
    
  2. Find the "Learning Entries" section

  3. Add your entry using Edit tool:

    Edit tool:
      file_path: ${CLAUDE_PLUGIN_ROOT}/skills/learnings-log/SKILL.md
      old_string: [text just after "## Learning Entries" heading]
      new_string: [existing text + your new log entry]
    
  4. Include in your log entry:

    • Date (YYYY-MM-DD format)
    • Brief title
    • Context (what was stuck)
    • The user's tip (in their own words)
    • Skills updated (with sections and what was added)
    • Key learning (one-sentence summary)
    • Impact (why this matters)

Example log entry:

### 2025-01-15: Adding Columns via Header Icon

**Context**: Builder agent couldn't find "Add column" button when trying to add columns to a table.

**Tip Provided**:
> "Click the '+' icon in the column header. There's no separate 'Add column' button."

**Skills Updated**:
- `layout/SKILL.md` - Section: "Adding Columns"
  - Added: Step-by-step process using '+' icon
  - Added: Troubleshooting note about icon visibility

**Key Learning**: Column addition in Glide uses a subtle hover-revealed '+' icon in column headers, not a labeled button.

**Impact**: Prevents confusion and failed attempts to find a non-existent button. Makes column addition reliable.

---

Step 8: Report Back

Summarize what you did:

  • Which skill file(s) you updated
  • What section(s) you modified or created
  • Brief description of what was added
  • Confirmation that learnings log was updated
  • Any observations about related areas that might need updates

Examples

Example 1: UI Navigation Tip → UPDATE PROCEDURE

Input:

  • Context: Stuck trying to add a column, couldn't find "Add column" button
  • Tip: "Click the '+' icon in the column header"
  • Result: Successfully added column

Your Analysis:

  • Learning: Column addition uses a subtle icon, not a labeled button
  • This is HOW to do something in UI → UPDATE PROCEDURE
  • Target: agents/data/procedures/add-column.md

Your Update to Procedure:

### Step 3: Open Column Creation

**Method A: Keyboard Shortcut (Preferred)**
...

**Method B: UI Click (Fallback)**

\`\`\`
COMMAND: SNAPSHOT
PURPOSE: Find column header to click

FIND: Any column header in the table
NOTE: Hover to reveal the '+' icon - there is NO separate "Add column" button
\`\`\`

\`\`\`
COMMAND: HOVER
REF: {ref of column header}
ELEMENT: Column header

EXPECTED: '+' icon appears on hover (light gray, easy to miss)
\`\`\`

\`\`\`
COMMAND: CLICK
REF: {ref of '+' icon}
ELEMENT: Add column icon (+)

EXPECTED: Column creation panel appears
\`\`\`

Example 2: API Behavior Tip → UPDATE SKILL

Input:

  • Context: API call failing when creating multiple tables
  • Tip: "You need to wait 2 seconds between table creation API calls or you'll get rate limited"
  • Result: Successfully created all tables with delays

Your Analysis:

  • Learning: Glide API has rate limiting on table creation
  • This is WHAT/WHY behavior → UPDATE SKILL
  • Target: skills/api/SKILL.md
  • Section: "Rate Limiting" or "Best Practices"

Your Update to Skill:

## Rate Limiting

The Glide API enforces rate limits to protect service stability:

### Table Creation Rate Limit
- **Limit**: Max 1 table creation per 2 seconds
- **Behavior**: Requests faster than this will return 429 error
- **Solution**: Add 2-second delay between table creation calls

**Example pattern:**
\`\`\`javascript
for (const table of tables) {
  await createTable(table);
  await sleep(2000); // Wait 2 seconds before next creation
}
\`\`\`

Example 3: New UI Operation → CREATE NEW PROCEDURE

Input:

  • Context: Needed to configure a Kanban board, no procedure exists
  • Tip: "In the collection config, click Style, choose Kanban, then you need to set the 'Group by' column to the status field"
  • Result: Kanban board working

Your Analysis:

  • Learning: Step-by-step Kanban configuration
  • This is HOW to do something new → CREATE NEW PROCEDURE
  • Target: agents/component-builder/procedures/configure-kanban.md (NEW FILE)

Create New Procedure File:

---
name: configure-kanban
description: Configure a collection as a Kanban board
preconditions:
  - Collection exists on screen
  - Table has a status/category column to group by
---

# Configure Kanban Procedure

## Overview
Configures a collection to display as a Kanban board with drag-and-drop columns.

## Procedure

### Step 1: Select Collection
\`\`\`
COMMAND: CLICK
REF: {ref of collection component}
ELEMENT: Collection component

EXPECTED: Collection selected, config panel visible
\`\`\`

### Step 2: Change Style to Kanban
\`\`\`
COMMAND: SNAPSHOT
PURPOSE: Find style selector
\`\`\`

\`\`\`
COMMAND: CLICK
REF: {ref of style dropdown}
ELEMENT: Style selector
\`\`\`

\`\`\`
COMMAND: CLICK
REF: {ref of Kanban option}
ELEMENT: "Kanban" style

EXPECTED: Style changes, Group by option appears
\`\`\`

### Step 3: Configure Group By Column
\`\`\`
COMMAND: SNAPSHOT
PURPOSE: Find Group by setting

FIND: "Group by" dropdown - THIS IS REQUIRED for Kanban
\`\`\`

\`\`\`
COMMAND: CLICK
REF: {ref of group by dropdown}
ELEMENT: Group by selector
\`\`\`

\`\`\`
COMMAND: CLICK
REF: {ref of status column}
ELEMENT: "{statusColumn}" column

EXPECTED: Kanban columns appear based on column values
\`\`\`

## Error Recovery

### Kanban Shows Empty
\`\`\`
ISSUE: No columns appear in Kanban

CHECK: Is "Group by" column set?
FIX: Must select a column with discrete values (status, category)
\`\`\`

## Report Format
\`\`\`
KANBAN CONFIGURED:
  Collection: {name}
  Group By: {column}
  Status: SUCCESS | FAILED
\`\`\`

Example 3: Workflow Pattern Tip

Input:

  • Context: Query results weren't working in Send Email node
  • Tip: "You need to use Set Column to extract the email field from the query results first"
  • Result: Emails sent successfully after extracting column

Your Analysis:

  • Learning: Query returns objects, but Email node needs simple array
  • Target skill: workflows/SKILL.md
  • Section: Enhance "Query → Extract Column → Loop Pattern"

Your Update:

## Advanced Patterns

### Query → Extract Column → Loop Pattern

**Critical concept**: Query nodes return arrays of objects, but most action nodes (Email, API) need simple value arrays.

**Why this is necessary:**
- Query output: `[{id: 1, email: "a@x.com", name: "Alice"}, ...]`
- Email node expects: `["a@x.com", "b@x.com", "c@x.com"]`
- **Without Set Column, the Email node receives objects and will fail**

**The pattern:**

Query Node → Get users where status = "Active" Output: [{id: 1, email: "a@x.com", name: "Alice"}, ...] ↓ Set Column Node → Extract "email" field Output: ["a@x.com", "b@x.com", "c@x.com"] ↓ Send Email Node → To: {extracted emails} ✅ Now it works!


**Common mistake**: Skipping the Set Column step
- ❌ Query → Send Email (fails - objects sent instead of strings)
- ✅ Query → Set Column → Send Email (works - simple array)

Quality Standards

For PROCEDURES (HOW-TO), Do Add:

  • Exact browser commands (CLICK, TYPE, SNAPSHOT, etc.)
  • Element finding strategies (what to look for)
  • Expected outcomes after each step
  • Wait times when needed
  • Error recovery steps
  • Verification steps

For SKILLS (WHAT/WHY), Do Add:

  • Concept explanations
  • When to use different approaches
  • Design guidance and best practices
  • API behaviors and limits
  • Architecture patterns

For SELECTORS (WHERE), Do Add:

  • Element descriptions and locations
  • Finding strategies
  • Common variations

Don't Add (Anywhere):

  • Vague advice ("be careful", "make sure")
  • Obvious information already documented
  • One-off edge cases unlikely to recur
  • User-specific preferences
  • Temporary workarounds for bugs that will be fixed
  • Redundant information
  • New agent folders (only use data, screen-builder, component-builder)
  • New skill folders (only update existing skills)

Advanced: Cross-Skill Patterns

Sometimes a tip reveals a pattern that applies across multiple skills:

Example: "Always use search, never browse categories" applies to:

  • Emoji picker (app icons)
  • Component selection
  • Color palette selection
  • Font selection

In this case:

  1. Add specific guidance to each relevant skill
  2. Consider creating a new "UI Navigation Patterns" section in the main glide skill
  3. Cross-reference between skills

Learning Accumulation

Over time, skills will grow with tips. Monitor for:

  • Sections getting too long: Consider splitting into subsections
  • Duplicate patterns: Consolidate similar tips
  • Contradictions: Newer learnings should override older ones
  • Structure drift: Maintain consistent organization

Your Success Criteria

A successful skill update:

  1. ✅ Adds genuinely new, specific knowledge
  2. ✅ Fits naturally into existing structure
  3. ✅ Uses clear, actionable language
  4. ✅ Includes concrete examples
  5. ✅ Will help prevent the same issue in the future
  6. ✅ Maintains consistent formatting and tone

Remember: You're building institutional knowledge that makes the entire plugin more effective. Each tip you integrate makes every future Glide app build smoother.

Final Checklist Before Saving

Before saving any changes, verify:

  1. ✅ Correct location?

    • HOW-TO knowledge → Procedure in agent folder
    • WHAT/WHY knowledge → Skill file
    • WHERE knowledge → Selector file
  2. ✅ Allowed folder?

    • Procedures ONLY in: agents/data/, agents/screen-builder/, agents/component-builder/
    • Skills ONLY in existing skills/*/ folders
    • Selectors ONLY in browser/selectors/
  3. ✅ NOT modifying forbidden files?

    • ❌ orchestrator/ORCHESTRATOR.md
    • ❌ browser/EXECUTOR.md
    • ❌ Any new top-level folders
  4. ✅ Learnings log updated?

    • Entry added to skills/learnings-log/SKILL.md

Workflows Agent

You build and configure Glide workflows - automations that respond to triggers and perform actions.

Workflow Types

Client-Side (App Interactions)

TypeTriggerRuns On
App InteractionUser action (button click, screen open)User's device

App Interactions are created via the screen-builder's add-action.md procedure. They can trigger server-side workflows using the "Trigger Workflow" action.

Server-Side Workflows

TypeTriggerKey Feature
ScheduleTime-based (daily, weekly, hourly)Runs automatically on schedule
WebhookHTTP request to endpointReceives external data
ManualTriggered by App InteractionInput variables from app
EmailIncoming email to addressParses email content
SlackSlack eventSlack integration required

Server-Side Capabilities

Server-side workflows have features not available in App Interactions:

Loops

  • Iterate over table rows
  • Can filter which rows to process
  • Access current row data in each iteration

Conditions (Branches)

  • Create multiple paths based on criteria
  • Evaluated left-to-right - first match wins
  • Other branches to the right are NOT evaluated after a match

Your Responsibilities

  • Create new workflows with appropriate trigger types
  • Configure trigger settings (schedule times, webhook URLs, etc.)
  • Add and configure workflow nodes
  • Set up loops and conditions for complex logic
  • Parse incoming data with Query JSON nodes

Procedures

Trigger Procedures (procedures/triggers/)

ProcedureFileUse When
Create Scheduletriggers/create-schedule.mdTime-based automation
Create Webhooktriggers/create-webhook.mdExternal API integration
Create Manualtriggers/create-manual.mdApp-triggered automation
Create Emailtriggers/create-email.mdEmail-triggered automation
Create Slacktriggers/create-slack.mdSlack integration

Node Procedures (procedures/nodes/)

ProcedureFileUse When
Add Loopnodes/add-loop.mdIterate over table rows
Add Conditionnodes/add-condition.mdBranch based on criteria
Add Query JSONnodes/add-query-json.mdParse webhook/API data
Trigger Workflownodes/trigger-workflow.mdLink app action to workflow

How You Work

  1. Receive task from orchestrator - e.g., "Create a daily report workflow"
  2. Determine workflow type - Schedule for time-based, Webhook for API, etc.
  3. Load relevant procedures - Create trigger, then add nodes
  4. Execute via browser executor - Navigate to Workflows, build the flow
  5. Report results back to orchestrator

Navigation

Workflows are found in the main Glide navigation:

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/workflows

EXPECTED: Workflow editor loads
VERIFY: Shows workflow list or empty state

Creating a New Workflow

COMMAND: SNAPSHOT
PURPOSE: Find create workflow button

FIND: "New workflow" or "+" button
COMMAND: CLICK
REF: {ref of new workflow button}
ELEMENT: New workflow button

EXPECTED: Workflow type selection appears

Workflow Type Selection

After clicking New Workflow, you must select the trigger type:

UI OptionTypeProperties Panel Shows
ScheduleServer-sideSchedule settings (frequency, time, days)
WebhookServer-sideWebhook URL to copy
ManualServer-sideInput variables to define
On EmailServer-sideEmail address to receive at
SlackServer-sideSlack integration settings

Key Concepts

Variables

Each workflow type has different available variables:

TypeAvailable Variables
ScheduleCurrent time, user context
WebhookRequest body, headers, query parameters
ManualDefined input variables
EmailSubject, body, from, to, attachments, etc.
SlackChannel, user, message, event data

Node Types

Common nodes available in workflows:

CategoryNodes
DataAdd Row, Update Row, Delete Row, Query JSON
LogicCondition, Loop, Wait
CommunicationSend Email, Send SMS, Push Notification
IntegrationHTTP Request, Trigger Workflow, Slack Message
UtilitySet Variable, Generate PDF, AI Generate

Task Execution Flow

Example: "Create a daily summary email workflow"

1. RECEIVE TASK:
   Create workflow that sends daily summary at 9am

2. DETERMINE TYPE: Schedule (time-based)

3. LOAD PROCEDURES:
   - triggers/create-schedule.md
   - (nodes for email sending)

4. EXECUTE:
   a) Navigate to Workflows
   b) Create new Schedule workflow
   c) Configure: Every Day at 9:00 AM
   d) Add nodes: Query data → Send Email
   e) Configure email content

5. REPORT:
   SUCCESS: Daily summary workflow created
   Schedule: Every day at 9:00 AM
   Actions: Query Orders table → Send summary email

Example: "Create webhook for external system"

1. RECEIVE TASK:
   Create webhook to receive order data from Shopify

2. DETERMINE TYPE: Webhook (external trigger)

3. LOAD PROCEDURES:
   - triggers/create-webhook.md
   - nodes/add-query-json.md

4. EXECUTE:
   a) Navigate to Workflows
   b) Create new Webhook workflow
   c) Copy webhook URL for user
   d) Add Query JSON nodes to parse order data
   e) Add row to Orders table with parsed data

5. REPORT:
   SUCCESS: Webhook workflow created
   Webhook URL: https://api.glideapps.com/webhooks/xxx
   Parses: orderId, customerName, items, total
   Creates: Row in Orders table

Report Format

WORKFLOW CREATED:
  Name: {workflowName}
  Type: {Schedule | Webhook | Manual | Email | Slack}
  Trigger Config: {schedule details / URL / variables / email}
  Nodes: {list of nodes added}
  Status: SUCCESS | FAILED
  Notes: {any issues or special config}

Error Handling

ErrorCauseAction
Workflow not savingMissing required configCheck all nodes have required inputs
Webhook URL not showingWorkflow not created yetCreate workflow first, then copy URL
Loop not iteratingNo table selectedConfigure table in loop properties
Condition never matchesWrong evaluation orderCheck left-to-right order
Slack not availableIntegration not linkedUser must link Slack integration first

Integration Notes

Webhook Best Practices

  • Always add Query JSON nodes to parse incoming data
  • Target "The request body" for most payloads
  • Use JSONata syntax for extraction: orderId or customer.name

Manual Workflow Best Practices

  • Define clear input variables in properties panel
  • Name variables descriptively: orderId, customerEmail, not var1
  • These variables can be passed from App Interactions

Loop Best Practices

  • Always filter the table to avoid processing all rows
  • Use variables to filter (e.g., only rows where status = "Pending")
  • Be mindful of execution time with large tables

Add Condition Node Procedure

Overview

Adds a Condition node (also called a branch) to create different execution paths based on criteria. Conditions are evaluated left-to-right - the first matching condition is executed, and others are skipped.

Key Concept: Left-to-Right Evaluation

Condition Node
    ├── Path 1 (checked first)
    ├── Path 2 (checked if Path 1 fails)
    ├── Path 3 (checked if Path 1 & 2 fail)
    └── Else (if no conditions match)

Important: Once a condition matches, paths to the right are NOT evaluated.

Procedure

Step 1: Ensure in Workflow Editor

COMMAND: SNAPSHOT
PURPOSE: Verify in workflow canvas

VERIFY:
  - Workflow editor is open
  - Canvas shows existing nodes

Step 2: Add Condition Node

COMMAND: SNAPSHOT
PURPOSE: Find add node option

FIND: 
  - "+" button on canvas
  - Connection point from existing node
COMMAND: CLICK
REF: {ref of add node button}
ELEMENT: Add node button (+)

EXPECTED: Node picker appears

Step 3: Find Condition in Picker

COMMAND: SNAPSHOT
PURPOSE: Find Condition node

FIND:
  - Search input
  - "Logic" or "Control" category
  - "Condition" or "Branch" or "If" option

Using search:

COMMAND: TYPE
REF: {ref of search input}
ELEMENT: Node search
TEXT: condition

EXPECTED: Condition node appears
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of Condition node}
ELEMENT: "Condition" node option

EXPECTED: Condition node added with multiple paths

Step 4: Configure First Condition (Leftmost Path)

The leftmost path is checked first.

COMMAND: SNAPSHOT
PURPOSE: Find condition configuration

FIND:
  - First branch/path configuration
  - "If" condition input
  - May click on the path itself to configure
COMMAND: CLICK
REF: {ref of first path or condition config}
ELEMENT: First condition path

EXPECTED: Condition editor appears in right panel

Set the condition:

COMMAND: SNAPSHOT
PURPOSE: Find condition builder

FIND:
  - Column/variable selector
  - Operator dropdown
  - Value input

Select what to check:

COMMAND: CLICK
REF: {ref of data selector}
ELEMENT: Data to check
COMMAND: CLICK
REF: {ref of column/variable}
ELEMENT: "{dataSource}" 

EXAMPLES: 
  - Column from trigger data
  - Variable from previous node
  - Input variable (for Manual workflows)

Select operator:

COMMAND: CLICK
REF: {ref of operator dropdown}
ELEMENT: Condition operator
COMMAND: CLICK
REF: {ref of operator}
ELEMENT: "{operator}"

OPERATORS:
  - is / equals
  - is not / not equals
  - contains
  - is empty / is not empty
  - greater than / less than
  - greater than or equal / less than or equal

Set comparison value:

COMMAND: TYPE or SELECT
REF: {ref of value input}
ELEMENT: Comparison value
TEXT: {value}

EXAMPLES: "Approved", "Complete", 100, true

Step 5: Add Nodes to First Path

COMMAND: SNAPSHOT
PURPOSE: Find add node in first path

FIND: 
  - "+" button inside/below first condition path
  - Drop zone for the "true" case
COMMAND: CLICK
REF: {ref of add node in path}
ELEMENT: Add node to first path

EXPECTED: Node picker appears

Add the nodes that should execute when this condition is true.

Step 6: Add More Conditions (Additional Paths)

To add more conditions (Else If):

COMMAND: SNAPSHOT
PURPOSE: Find add condition/path button

FIND:
  - "Add path" or "Add condition" button
  - "+" at the condition level (not inside a path)
COMMAND: CLICK
REF: {ref of add path button}
ELEMENT: Add condition path

EXPECTED: New condition path added to the RIGHT

Configure this new condition the same way as Step 4.

Remember: This condition is only checked if the one(s) to its left failed!

Step 7: Configure Else Path (Optional)

The Else path executes when NO conditions match.

COMMAND: SNAPSHOT
PURPOSE: Find Else path

FIND:
  - "Else" or "Default" path (usually rightmost)
  - May be automatically present or need to enable

Add nodes to the Else path for fallback behavior.

Step 8: Order Matters - Verify Condition Order

COMMAND: SNAPSHOT
PURPOSE: Review condition order (left to right)

VERIFY conditions are ordered correctly:
  1. Most specific conditions FIRST (leftmost)
  2. More general conditions later
  3. Else/default LAST (rightmost)

Example - Good order:

1. status = "Urgent"     → Handle urgent immediately
2. status = "High"       → Handle high priority
3. status = "Normal"     → Standard processing
4. Else                  → Log unknown status

Example - Bad order:

1. status contains ""    → This matches EVERYTHING! (too broad)
2. status = "Urgent"     → Never reached!

Step 9: Verify Configuration

COMMAND: SNAPSHOT
PURPOSE: Confirm condition setup

VERIFY:
  - Conditions are in correct left-to-right order
  - Each path has the right nodes
  - Else path handles unexpected cases
  - No overlapping conditions that could cause confusion

Condition Patterns

Status-Based Routing

Path 1: status = "Approved" → Update row, notify user
Path 2: status = "Rejected" → Send rejection email
Path 3: status = "Pending"  → Add to review queue
Else:   Log unknown status

Amount Thresholds

Path 1: amount > 10000     → Require approval
Path 2: amount > 1000      → Manager notification
Path 3: amount > 0         → Auto-approve
Else:   Handle zero/negative

User Type Routing

Path 1: userRole = "Admin"  → Full access flow
Path 2: userRole = "Manager" → Limited flow
Path 3: userRole = "User"   → Basic flow
Else:   Deny access

Error Handling

Path 1: success = true     → Continue normal flow
Path 2: errorType = "rate_limit" → Wait and retry
Path 3: errorType = "auth"  → Refresh token
Else:   Log error and alert

Multiple Conditions in One Path

Some condition nodes allow AND/OR logic within a single path:

COMMAND: SNAPSHOT
PURPOSE: Find "AND" or "OR" option

FIND:
  - "Add condition" within a path (not a new path)
  - AND/OR toggle

Example - All must be true (AND):

status = "Approved" AND amount > 100 AND isActive = true

Example - Any can be true (OR):

priority = "High" OR priority = "Urgent"

Error Recovery

Condition Never Matches

ISSUE: Always going to Else path

CHECK:
  - Is the data type correct? (string vs number)
  - Are values spelled exactly right?
  - Is the operator correct? (= vs contains)
  - Is the data actually reaching the condition?

DEBUG: Add a logging node before condition to see values

Wrong Path Executing

ISSUE: Going to unexpected path

CHECK:
  - Remember: left-to-right, first match wins
  - Is there a broader condition to the left catching it?
  - Are conditions overlapping?

FIX: Reorder conditions, most specific first

Can't Add More Paths

ISSUE: No option to add additional conditions

CHECK:
  - Is there a limit on number of paths?
  - Look for "+" at the condition node level, not inside a path

TRY: Nest another condition node inside a path

Best Practices

  1. Order specifically - Most specific conditions first
  2. Always have Else - Handle unexpected cases
  3. Don't overlap - Conditions should be mutually exclusive when possible
  4. Document logic - Name paths descriptively
  5. Test each path - Verify all paths work as expected

Report Format

CONDITION NODE ADDED:
  Workflow: {workflowName}
  Paths (left to right):
    1. IF {condition} → {nodes}
    2. ELSE IF {condition} → {nodes}
    3. ELSE → {nodes}
  Status: SUCCESS | FAILED
  Notes: {any issues}

Add Loop Node Procedure

Overview

Adds a Loop node to a server-side workflow. Loops iterate over rows in a table and execute child nodes for each row.

⚠️ Server-Side Only - Loops are only available in server-side workflows (Schedule, Webhook, Manual, Email, Slack). They are NOT available in App Interactions.

Loop Capabilities

  • Select a table to iterate over
  • Filter which rows to process
  • Access current row data in each iteration
  • Nest other nodes inside the loop

Procedure

Step 1: Ensure in Workflow Editor

COMMAND: SNAPSHOT
PURPOSE: Verify in workflow canvas

VERIFY:
  - Workflow editor is open
  - This is a server-side workflow
  - Canvas shows trigger node and any existing nodes

Step 2: Add Loop Node

COMMAND: SNAPSHOT
PURPOSE: Find add node option

FIND: 
  - "+" button on canvas or between nodes
  - Node palette/picker
  - Drag point from existing node

Method A: Click add button

COMMAND: CLICK
REF: {ref of add node button}
ELEMENT: Add node button (+)

EXPECTED: Node picker appears

Method B: Drag from existing node

COMMAND: DRAG
FROM_REF: {ref of node output connector}
FROM_ELEMENT: Node output
TO_REF: {ref of empty canvas area}
TO_ELEMENT: Canvas

EXPECTED: Node picker appears

Step 3: Find Loop in Picker

COMMAND: SNAPSHOT
PURPOSE: Find Loop node option

FIND: 
  - Search input
  - Categories (may be under "Logic" or "Control")
  - "Loop" or "For Each" option

Using search:

COMMAND: TYPE
REF: {ref of search input}
ELEMENT: Node search
TEXT: loop

EXPECTED: Loop node appears in results
COMMAND: SNAPSHOT
PURPOSE: Find Loop node
COMMAND: CLICK
REF: {ref of Loop node}
ELEMENT: "Loop" node option

EXPECTED: Loop node added to canvas

Step 4: Select Table to Loop Over

COMMAND: SNAPSHOT
PURPOSE: Find table selector in Loop configuration

FIND: 
  - Right panel with Loop properties
  - Table/source dropdown
  - May be labeled "Table", "Source", or "Data"
COMMAND: CLICK
REF: {ref of table dropdown}
ELEMENT: Table selector
COMMAND: SNAPSHOT
PURPOSE: Find target table
COMMAND: CLICK
REF: {ref of target table}
ELEMENT: "{tableName}" table

EXPECTED: Table selected, loop will iterate over its rows

Step 5: Configure Row Filter (Important!)

⚠️ Always filter loops to avoid processing entire tables.

COMMAND: SNAPSHOT
PURPOSE: Find filter configuration

FIND:
  - "Filter" or "Conditions" section
  - "Add filter" button
  - Filter rules area
COMMAND: CLICK
REF: {ref of add filter button}
ELEMENT: Add filter button

EXPECTED: Filter configuration appears

Configure filter condition:

COMMAND: SNAPSHOT
PURPOSE: Find filter column/value inputs
COMMAND: CLICK
REF: {ref of column dropdown}
ELEMENT: Filter column selector
COMMAND: CLICK
REF: {ref of column}
ELEMENT: "{columnName}" column

EXAMPLE: "status" column
COMMAND: CLICK
REF: {ref of operator dropdown}
ELEMENT: Filter operator
COMMAND: CLICK
REF: {ref of operator}
ELEMENT: "{operator}" 

OPERATORS: is, is not, contains, is empty, greater than, etc.
COMMAND: TYPE or SELECT
REF: {ref of value input}
ELEMENT: Filter value
TEXT: {value}

EXAMPLE: "Pending" to only process pending items

Step 6: Add Nodes Inside Loop

Nodes placed inside the loop execute for each row.

COMMAND: SNAPSHOT
PURPOSE: Find loop body / inner area

FIND: 
  - Loop node may expand to show inner area
  - "+" button inside the loop
  - Drop zone for child nodes
COMMAND: CLICK
REF: {ref of add node inside loop}
ELEMENT: Add node inside loop

EXPECTED: Node picker appears

Add nodes as needed (Update Row, Send Email, etc.). These nodes can reference:

  • Current row data - Columns from the row being processed
  • Loop variables - Index, count, etc.

Step 7: Using Current Row Data

When configuring nodes inside the loop:

COMMAND: SNAPSHOT
PURPOSE: Find data binding in inner node

FIND: Data/variable selector in node properties
COMMAND: CLICK
REF: {ref of data selector}
ELEMENT: Data source selector
COMMAND: SNAPSHOT
PURPOSE: Find loop row variables

FIND:
  - "Current row" or loop context
  - Columns from the selected table
  - Loop iteration info
COMMAND: CLICK
REF: {ref of current row column}
ELEMENT: Current row → {columnName}

EXPECTED: Node uses data from current iteration's row

Step 8: Verify Loop Configuration

COMMAND: SNAPSHOT
PURPOSE: Confirm loop setup

VERIFY:
  - Table is selected
  - Filter is configured (not processing all rows!)
  - Child nodes are inside the loop
  - Data bindings use current row context

Common Loop Patterns

Update All Matching Rows

Loop: Over "Orders" table
Filter: status = "Pending" AND createdDate < 7 days ago

Inside Loop:
  - Update Row: Set status = "Expired"

Send Notification to Each User

Loop: Over "Users" table
Filter: notifications = true

Inside Loop:
  - Send Email: To = Current row → email
                Subject = "Weekly Update"

Sync Data to External System

Loop: Over "Products" table
Filter: syncStatus = "Pending"

Inside Loop:
  - HTTP Request: POST to external API with product data
  - Update Row: Set syncStatus = "Complete"

Calculate Aggregates (Advanced)

Loop: Over "LineItems" table
Filter: orderId = {workflow variable}

Inside Loop:
  - Set Variable: total = total + Current row → amount
  
After Loop:
  - Update Order row with calculated total

Error Recovery

Loop Not Available

ISSUE: Can't find Loop node option

CHECK:
  - Is this a server-side workflow? (not App Interaction)
  - Look under "Logic" or "Control Flow" category

NOTE: Loops are only in Schedule, Webhook, Manual, Email, Slack workflows

Table Not Appearing

ISSUE: Target table not in dropdown

CHECK:
  - Does the table exist?
  - Is the table linked to this app?

TRY: Refresh page, or check Data Editor

Loop Timing Out

ISSUE: Workflow fails or times out

CHECK:
  - Is the filter too broad? (processing too many rows)
  - Are there nested loops? (exponential complexity)
  - Are inner nodes making slow external calls?

FIX: Add more restrictive filters
     Limit rows processed per run

Can't Access Row Data

ISSUE: Current row columns not showing

CHECK:
  - Is the table selected in the loop?
  - Are you inside the loop node, not outside?

TRY: Click on a node inside the loop, then check data bindings

Best Practices

  1. Always filter - Never loop over entire tables
  2. Test with few rows - Add LIMIT 5 equivalent filter first
  3. Watch execution time - Loops with external calls are slow
  4. Consider batching - For large datasets, process in chunks
  5. Log progress - Add logging nodes to track iterations

Report Format

LOOP NODE ADDED:
  Workflow: {workflowName}
  Loop Over: {tableName}
  Filter: {filter description}
  Child Nodes: {list of nodes inside loop}
  Status: SUCCESS | FAILED
  Notes: {any issues}

Add Query JSON Node Procedure

Overview

Adds a Query JSON node to extract specific values from JSON data using JSONata syntax. Essential for webhook workflows that receive JSON payloads.

When to Use

SourceUse Query JSON For
Webhook bodyParse incoming API payloads
HTTP ResponseExtract data from API calls
Email bodyParse structured email content
Any JSONNavigate nested objects

JSONata Quick Reference

NeedJSONata SyntaxInputOutput
Simple fieldfieldName{"name": "John"}"John"
Nested fieldcustomer.name{"customer": {"name": "John"}}"John"
Array first itemitems[0]{"items": ["a", "b"]}"a"
Array count$count(items){"items": [1, 2, 3]}3
Array sum$sum(items.price){"items": [{price: 10}, {price: 20}]}30

Procedure

Step 1: Ensure in Workflow Editor

COMMAND: SNAPSHOT
PURPOSE: Verify in workflow canvas

VERIFY:
  - Workflow editor is open
  - Trigger node exists (typically Webhook for JSON parsing)

Step 2: Add Query JSON Node

COMMAND: SNAPSHOT
PURPOSE: Find add node option

FIND:
  - "+" button on canvas
  - Connection from trigger or previous node
COMMAND: CLICK
REF: {ref of add node button}
ELEMENT: Add node button (+)

EXPECTED: Node picker appears

Step 3: Find Query JSON in Picker

COMMAND: SNAPSHOT
PURPOSE: Find Query JSON node

FIND:
  - Search input
  - "Data" category
  - "Query JSON" or "Parse JSON" option

Using search:

COMMAND: TYPE
REF: {ref of search input}
ELEMENT: Node search
TEXT: query json

EXPECTED: Query JSON node appears
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of Query JSON node}
ELEMENT: "Query JSON" node option

EXPECTED: Query JSON node added to canvas

Step 4: Select JSON Source

COMMAND: SNAPSHOT
PURPOSE: Find source selector in node config

FIND:
  - "Source" or "Data" dropdown in right panel
  - Input field for JSON source
COMMAND: CLICK
REF: {ref of source dropdown}
ELEMENT: JSON source selector
COMMAND: SNAPSHOT
PURPOSE: Find available sources

For Webhook workflows:

COMMAND: CLICK
REF: {ref of request body option}
ELEMENT: "The request body"

EXPECTED: Source set to incoming webhook payload

For HTTP Response:

COMMAND: CLICK
REF: {ref of http response option}
ELEMENT: HTTP Response body or previous node output

Step 5: Enter JSONata Query

COMMAND: SNAPSHOT
PURPOSE: Find JSONata query input

FIND:
  - Query input field
  - May be labeled "Query", "Expression", or "JSONata"
  - Usually below the source selector
COMMAND: CLICK
REF: {ref of query input}
ELEMENT: JSONata query input
COMMAND: TYPE
REF: {ref of query input}
ELEMENT: JSONata expression
TEXT: {jsonataQuery}

EXAMPLES:
  orderId
  customer.email
  items[0].name
  $count(lineItems)
  $sum(items.quantity)

Step 6: Name the Output Variable

COMMAND: SNAPSHOT
PURPOSE: Find output name field

FIND:
  - "Name" or "Output" or "Variable name" field
  - This is how you'll reference this value later
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Output variable name
TEXT: {variableName}

EXAMPLES:
  orderId
  customerEmail
  itemCount
  
RULES:
  - Use camelCase
  - Be descriptive
  - Match the data it contains

Step 7: Add More Query JSON Nodes

For each piece of data you need to extract, add another Query JSON node.

Example for order payload:

{
  "id": 12345,
  "customer": {
    "name": "John Doe",
    "email": "john@example.com"
  },
  "items": [
    {"sku": "ABC", "qty": 2, "price": 29.99}
  ],
  "total": 59.98
}

Nodes to add:

Node #SourceQueryOutput Name
1Request bodyidorderId
2Request bodycustomer.namecustomerName
3Request bodycustomer.emailcustomerEmail
4Request bodytotalorderTotal
5Request body$count(items)itemCount

Step 8: Use Extracted Values

After Query JSON nodes, the extracted values are available as variables.

In subsequent nodes (Add Row, Send Email, etc.):

COMMAND: SNAPSHOT
PURPOSE: Find data binding in another node
COMMAND: CLICK
REF: {ref of data selector}
ELEMENT: Data source
COMMAND: SNAPSHOT
PURPOSE: Find Query JSON outputs

FIND:
  - Variables from Query JSON nodes
  - Named by the output variable names you set
COMMAND: CLICK
REF: {ref of query output variable}
ELEMENT: "{variableName}" from Query JSON

EXPECTED: Node uses the extracted JSON value

Step 9: Verify Configuration

COMMAND: SNAPSHOT
PURPOSE: Confirm Query JSON setup

VERIFY:
  - All needed data points have Query JSON nodes
  - Sources are correct (request body, etc.)
  - JSONata queries are valid
  - Output names are descriptive

JSONata Syntax Guide

Basic Access

PatternExampleDescription
fieldnameTop-level field
parent.childcustomer.emailNested field
arr[0]items[0]First array element
arr[-1]items[-1]Last array element
arr[*].fielditems[*].nameAll 'name' from array

Functions

FunctionExampleResult
$count()$count(items)Number of items
$sum()$sum(items.price)Total of prices
$average()$average(scores)Average value
$string()$string(id)Convert to string
$number()$number(qty)Convert to number
$now()$now()Current timestamp
$lowercase()$lowercase(name)Lowercase string
$uppercase()$uppercase(code)Uppercase string
$trim()$trim(input)Remove whitespace

Conditional

PatternExampleDescription
Ternarystatus = "active" ? "Yes" : "No"If-else inline
Defaultname ? name : "Unknown"Fallback if null

Filtering Arrays

items[price > 100]          # Items over $100
items[status = "active"]    # Active items only
items[qty > 0].name         # Names of in-stock items

Common Patterns

Webhook from Shopify

{"order": {"id": 123, "customer": {"email": "..."}}}

Queries:

  • order.id
  • order.customer.email

Webhook from Stripe

{"data": {"object": {"id": "...", "amount": 9999}}}

Queries:

  • data.object.id
  • data.object.amount

Webhook from Zapier

{"fields": {"Name": "John", "Email": "john@..."}}

Queries:

  • fields.Name
  • fields.Email

Error Recovery

Query Returns Empty

ISSUE: Query JSON output is empty/null

CHECK:
  - Is the JSONata path correct?
  - Does the field exist in the payload?
  - Is there a typo in the field name?

DEBUG:
  - Log the raw request body to see actual structure
  - Try a simpler query like just `$` to see entire payload

Invalid JSONata Syntax

ISSUE: Error in query expression

CHECK:
  - Field names should not have quotes for simple access
  - Function names start with $
  - Array indices use square brackets

EXAMPLES of common fixes:
  Wrong: "customer.name"
  Right: customer.name
  
  Wrong: count(items)
  Right: $count(items)

Nested Path Not Working

ISSUE: Nested access returns nothing

CHECK:
  - Is the parent object null?
  - Are you using . for objects and [] for arrays?

EXAMPLE:
  If items is an array: items[0].name
  If items is an object: items.name

Report Format

QUERY JSON NODE(S) ADDED:
  Workflow: {workflowName}
  Source: {request body | HTTP response | etc.}
  Queries:
    - {variableName}: {jsonataQuery}
    - {variableName}: {jsonataQuery}
  Status: SUCCESS | FAILED
  Notes: {any issues}

Trigger Workflow Action Procedure

Overview

Connects an App Interaction (client-side button/action) to a Manual server-side workflow. This bridges the gap between user actions and server-side processing.

The Connection

App Screen                Server-Side
┌─────────────┐          ┌─────────────┐
│   Button    │   ───>   │   Manual    │
│   Click     │  passes  │  Workflow   │
│             │  data    │             │
└─────────────┘          └─────────────┘

Prerequisites

Before adding this action:

  1. Manual workflow must exist - Create it first with defined input variables
  2. Screen must exist - The screen where the button/action lives
  3. Know what data to pass - Match screen data to workflow input variables

Procedure

Step 1: Navigate to Layout Editor

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/layout

EXPECTED: Layout Editor loads

Step 2: Navigate to Target Screen

Go to the screen where you want to add the trigger.

COMMAND: SNAPSHOT
PURPOSE: Find target screen

FIND: The tab/screen in Navigation sidebar
COMMAND: CLICK
REF: {ref of screen}
ELEMENT: "{screenName}" screen

EXPECTED: Screen shown in preview

Step 3: Select or Add Button Component

If button exists:

COMMAND: CLICK
REF: {ref of button component}
ELEMENT: "{buttonName}" component

EXPECTED: Button selected, config in right panel

If need to add button: Follow screen-builder/procedures/components/add-component.md to add a Button first.

Step 4: Find Actions Configuration

COMMAND: SNAPSHOT
PURPOSE: Find actions section

FIND:
  - "Actions" section in right panel
  - "On Click" or "On Tap" configuration
  - Existing actions list
COMMAND: CLICK
REF: {ref of Actions section}
ELEMENT: Actions section

EXPECTED: Actions configuration visible

Step 5: Add Trigger Workflow Action

COMMAND: SNAPSHOT
PURPOSE: Find add action button
COMMAND: CLICK
REF: {ref of add action button}
ELEMENT: Add action button

EXPECTED: Action type picker appears
COMMAND: SNAPSHOT
PURPOSE: Find Trigger Workflow option

FIND:
  - Search input
  - May be under "Integrations" or "Workflows" category
  - "Trigger Workflow" option

Using search:

COMMAND: TYPE
REF: {ref of search input}
ELEMENT: Action search
TEXT: trigger workflow
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of Trigger Workflow option}
ELEMENT: "Trigger Workflow" action

EXPECTED: Action added, configuration appears

Step 6: Select Target Workflow

COMMAND: SNAPSHOT
PURPOSE: Find workflow selector

FIND:
  - Workflow dropdown
  - List of available Manual workflows
COMMAND: CLICK
REF: {ref of workflow dropdown}
ELEMENT: Workflow selector
COMMAND: SNAPSHOT
PURPOSE: Find target workflow

FIND: Manual workflows list (only Manual type shown)
COMMAND: CLICK
REF: {ref of target workflow}
ELEMENT: "{workflowName}" workflow

EXPECTED: Workflow selected, input variables appear

Step 7: Map Input Variables

After selecting the workflow, its input variables appear. Map screen data to each variable.

COMMAND: SNAPSHOT
PURPOSE: Find input variable mappings

FIND:
  - List of input variables defined in the workflow
  - Data source selector for each variable

For each input variable:

COMMAND: CLICK
REF: {ref of variable data selector}
ELEMENT: "{variableName}" input mapping
COMMAND: SNAPSHOT
PURPOSE: Find screen data to map

FIND:
  - Current row columns (if on detail screen)
  - Screen values
  - User properties
COMMAND: CLICK
REF: {ref of data source}
ELEMENT: "{columnName}" or data source

EXPECTED: Variable mapped to screen data

Repeat for each input variable.

Step 8: Configure Button Label (Optional)

COMMAND: SNAPSHOT
PURPOSE: Find button label input
COMMAND: TYPE
REF: {ref of label input}
ELEMENT: Button label
TEXT: {buttonLabel}

EXAMPLES: "Process Order", "Send Notification", "Generate Report"

Step 9: Verify Configuration

COMMAND: SNAPSHOT
PURPOSE: Confirm trigger setup

VERIFY:
  - Correct workflow is selected
  - All input variables are mapped
  - Mappings point to correct data
  - Button label is appropriate

Example Mapping

Workflow: "Process Order" Input variables:

  • orderId
  • customerEmail
  • orderTotal

Screen: Order Detail Available columns:

  • ID
  • Customer Email
  • Total

Mapping:

Workflow VariableScreen Data
orderIdCurrent row → ID
customerEmailCurrent row → Customer Email
orderTotalCurrent row → Total

Common Patterns

From Detail Screen

Button: "Mark Complete"
Workflow: "Update Status"
Mapping:
  - itemId = Current row → ID
  - newStatus = "Complete" (static value)
  - userId = Current user → ID

From Collection Screen

Button: "Export All" (screen-level action)
Workflow: "Generate Export"
Mapping:
  - exportType = "full"
  - requestedBy = Current user → Email

With User Input

Button: "Submit Request"
Workflow: "Create Request"
Mapping:
  - title = Text Entry component value
  - description = Text Entry component value
  - requester = Current user → ID

Error Recovery

Workflow Not Appearing

ISSUE: Can't find workflow in dropdown

CHECK:
  - Is the workflow a Manual type? (not Schedule/Webhook)
  - Is the workflow saved?
  - Are you in the correct app?

TRY: Refresh page, or go to Workflows and verify it exists as Manual type

Input Variables Missing

ISSUE: No variables to map after selecting workflow

CHECK:
  - Does the workflow have input variables defined?
  - Were they saved?

FIX: Go to Workflows, edit the Manual workflow, add input variables

Can't Map to Screen Data

ISSUE: Data source not available for mapping

CHECK:
  - Are you on a data-backed screen?
  - Does the column exist in this table?
  - Is it a computed column (may need base column)?

TRY: Check what data is actually available on this screen

Action Not Executing

ISSUE: Button clicks but nothing happens

CHECK:
  - Is the workflow published/active?
  - Are all required mappings filled?
  - Check workflow run history for errors

DEBUG:
  - Go to Workflows
  - Check run history for the workflow
  - Look for error messages

Best Practices

  1. Name workflows clearly - "Process Order" not "Workflow 1"
  2. Map all variables - Empty variables may cause issues
  3. Validate data types - Number variable needs number data
  4. Test with real data - Use preview mode to test action
  5. Add visual feedback - Show notification after triggering

Visual Feedback

After triggering a workflow, consider adding:

  1. Show Notification action - "Processing your request..."
  2. Navigate back - Return to list view
  3. Refresh data - Update screen to show changes

Report Format

TRIGGER WORKFLOW ACTION ADDED:
  Screen: {screenName}
  Component: {buttonName}
  Triggers: {workflowName}
  Mappings:
    - {variableName} ← {dataSource}
    - {variableName} ← {dataSource}
  Button Label: {label}
  Status: SUCCESS | FAILED
  Notes: {any issues}

Create Email Workflow Procedure

Overview

Creates a server-side workflow triggered when an email is received at a Glide-provided email address. All parts of the email become available as variables.

Available Variables

VariableDescriptionExample
FromSender email addressjohn@example.com
From NameSender display nameJohn Doe
ToRecipient address (the Glide address)abc123@workflows.glideapps.com
SubjectEmail subject lineNew Order #12345
BodyPlain text bodyOrder details...
HTML BodyHTML formatted body<p>Order details...</p>
DateWhen email was receivedTimestamp
AttachmentsFile attachmentsURLs to attachments
Reply-ToReply address if differentsupport@example.com
CCCC recipientsEmail addresses

Procedure

Step 1: Navigate to Workflows

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/workflows

EXPECTED: Workflow editor loads

Step 2: Create New Workflow

COMMAND: SNAPSHOT
PURPOSE: Find new workflow button
COMMAND: CLICK
REF: {ref of new workflow button}
ELEMENT: New workflow button

EXPECTED: Workflow type selection appears

Step 3: Select Email Type

COMMAND: SNAPSHOT
PURPOSE: Find workflow type options
COMMAND: CLICK
REF: {ref of Email option}
ELEMENT: "On Email" or "Email" trigger type

EXPECTED: New email workflow created
VERIFY: Right panel shows email address for receiving

Step 4: Name the Workflow

COMMAND: SNAPSHOT
PURPOSE: Find workflow name input
COMMAND: CLICK
REF: {ref of name input}
ELEMENT: Workflow name input
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Workflow name
TEXT: {workflowName}

EXAMPLES: "Email Lead Capture", "Support Ticket Creator", "Order Parser"

Step 5: Copy Receiving Email Address

COMMAND: SNAPSHOT
PURPOSE: Find email address in properties panel

FIND:
  - Email address displayed in right panel
  - Copy button or selectable text
  - Usually format: {unique-id}@workflows.glideapps.com

Copy the email address:

COMMAND: CLICK
REF: {ref of copy button or email field}
ELEMENT: Copy email address button

Or select and copy manually.

Step 6: Extract Email Address

COMMAND: EVALUATE
CODE: async () => {
  try {
    const email = await navigator.clipboard.readText();
    return { inboundEmail: email };
  } catch (err) {
    return { error: err.message };
  }
}

EXPECTED: JSON with inboundEmail
SAVE: Store this address to provide to user/external system

Step 7: Add Workflow Nodes

Now add nodes to process the incoming email.

Common patterns:

Create Support Ticket from Email
  1. Add Row to "Tickets" table
    • Title = Subject
    • Description = Body
    • Requester = From
    • Status = "New"
Parse Order from Email
  1. Query JSON on Body (if structured)
  2. Add Row to "Orders" table
Forward to Team
  1. Send Email node
    • To = team distribution email
    • Subject = "Fwd: " + Subject
    • Body = Body

Step 8: Using Email Variables in Nodes

When configuring nodes, email variables are available as data sources:

COMMAND: SNAPSHOT
PURPOSE: Find data binding in node configuration

FIND: Data/variable selector in node properties
COMMAND: CLICK
REF: {ref of data selector}
ELEMENT: Data source selector
COMMAND: SNAPSHOT
PURPOSE: Find email variables

FIND: Email trigger variables:
  - From
  - Subject
  - Body
  - (all others listed above)
COMMAND: CLICK
REF: {ref of desired variable}
ELEMENT: "{variableName}" email variable

EXPECTED: Node now uses that email data

Step 9: Verify Configuration

COMMAND: SNAPSHOT
PURPOSE: Confirm email workflow setup

VERIFY:
  - Workflow name is set
  - Email address is visible and copied
  - Nodes are configured with email variables

Use Cases

Lead Capture

  • Receive: Contact form submissions forwarded via email
  • Parse: Name, email, message from subject/body
  • Action: Create row in Leads table, notify sales team

Support Tickets

  • Receive: Customer support emails
  • Parse: Subject as title, body as description
  • Action: Create ticket, send auto-reply

Email-to-Table

  • Receive: Reports or updates from external systems
  • Parse: Extract key data from body
  • Action: Log to appropriate table

Notification Relay

  • Receive: Alerts from external monitoring
  • Parse: Alert type, severity
  • Action: Push notification to admins, log event

Parsing Email Content

If Body Contains Structured Data

Use Query JSON or string parsing:

Example - Email body with key:value pairs:

Order ID: 12345
Customer: John Doe
Total: $99.99

Use Template columns or string operations in Glide to extract.

If Body is Natural Text

Consider using AI-powered parsing:

  1. Add AI node (Generate Text)
  2. Prompt: "Extract the order number from this text: {Body}"
  3. Use result in subsequent nodes

Error Recovery

Email Address Not Appearing

ISSUE: No email address in properties panel

CHECK:
  - Is this an Email type workflow?
  - Is the workflow saved?

TRY: Refresh page and check again

Workflow Not Triggering on Email

ISSUE: Sent email but workflow didn't run

CHECK:
  - Is the email sent to exact address? (case matters)
  - Is the sender's email on a blocklist?
  - Did the email get marked as spam?

TRY: Send test email from different sender

Attachments Not Accessible

ISSUE: Can't access email attachments

CHECK:
  - Does the email have attachments?
  - Are attachments within size limits?

NOTE: Attachments are provided as URLs, not direct files

Report Format

EMAIL WORKFLOW CREATED:
  Name: {workflowName}
  Inbound Email: {email address}
  Variables Used: {list of email variables bound in nodes}
  Nodes Added: {list}
  Status: SUCCESS | FAILED
  
USER ACTION REQUIRED:
  Send emails to: {inbound email address}
  Or configure external system to forward to this address.

Create Manual Workflow Procedure

Overview

Creates a server-side workflow that is triggered by an App Interaction using the "Trigger Workflow" action. Allows passing data from the app to the workflow via input variables.

Key Concept

Manual workflows bridge client-side actions to server-side processing:

App Interaction (client) → Trigger Workflow → Manual Workflow (server)
                          passes variables

Procedure

Step 1: Navigate to Workflows

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/workflows

EXPECTED: Workflow editor loads

Step 2: Create New Workflow

COMMAND: SNAPSHOT
PURPOSE: Find new workflow button
COMMAND: CLICK
REF: {ref of new workflow button}
ELEMENT: New workflow button

EXPECTED: Workflow type selection appears

Step 3: Select Manual Type

COMMAND: SNAPSHOT
PURPOSE: Find workflow type options
COMMAND: CLICK
REF: {ref of Manual option}
ELEMENT: "Manual" trigger type

EXPECTED: New manual workflow created
VERIFY: Right panel shows input variable configuration

Step 4: Name the Workflow

COMMAND: SNAPSHOT
PURPOSE: Find workflow name input
COMMAND: CLICK
REF: {ref of name input}
ELEMENT: Workflow name input
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Workflow name
TEXT: {workflowName}

EXAMPLES: "Process Order", "Send Welcome Email", "Generate Report"

Step 5: Define Input Variables

Input variables are the data passed from the App Interaction.

COMMAND: SNAPSHOT
PURPOSE: Find input variables section

FIND: "Input Variables" or "Parameters" section in right panel
      "Add variable" or "+" button

Add a variable:

COMMAND: CLICK
REF: {ref of add variable button}
ELEMENT: Add input variable button

EXPECTED: New variable row appears
COMMAND: SNAPSHOT
PURPOSE: Find variable name and type inputs

Set variable name:

COMMAND: TYPE
REF: {ref of variable name input}
ELEMENT: Variable name input
TEXT: {variableName}

NAMING RULES:
  - Use camelCase: orderId, customerEmail, productName
  - Be descriptive: use "customerId" not "id" or "var1"
  - Match what will be passed from app

Set variable type (if available):

COMMAND: CLICK
REF: {ref of type dropdown}
ELEMENT: Variable type selector
COMMAND: CLICK
REF: {ref of type option}
ELEMENT: "{type}" option

TYPES: Text, Number, Date, Boolean, etc.

Repeat for each input variable needed.

Step 6: Common Input Variable Patterns

Use CaseVariables to Define
Order ProcessingorderId, customerId, orderTotal
User NotificationuserId, message, notificationType
Report GenerationreportType, startDate, endDate
Approval FlowrequestId, approverId, action
Data SyncrecordId, sourceTable, operation

Step 7: Verify Input Variables

COMMAND: SNAPSHOT
PURPOSE: Confirm all variables are defined

VERIFY:
  - All needed variables are listed
  - Names are correct and descriptive
  - Types are appropriate (if set)

Step 8: Use Variables in Workflow Nodes

When adding nodes to the workflow, these input variables are available as data sources.

In any node's data binding:

FIND: Variable/data selector
SELECT: One of the defined input variables

EXAMPLE: In "Send Email" node, bind "To" field to customerEmail variable

Connecting from App Interaction

After creating the Manual workflow, an App Interaction must be configured to trigger it:

In screen-builder (components/add-action.md):

  1. Add a button or action to a screen
  2. Add action: "Trigger Workflow"
  3. Select this Manual workflow
  4. Map screen data to input variables:
    • orderId ← Current row's Order ID column
    • customerId ← Current row's Customer ID column
    • etc.

Example: Complete Flow

Manual Workflow: "Send Order Confirmation"

Input Variables:

  • orderId (Text)
  • customerEmail (Text)
  • customerName (Text)

Workflow Nodes:

  1. Trigger (Manual)
  2. Query table: Get order details where ID = orderId
  3. Send Email: To = customerEmail, personalized with customerName

App Interaction (on Order detail screen):

  1. Button: "Send Confirmation"
  2. Action: Trigger Workflow → "Send Order Confirmation"
  3. Pass:
    • orderId = Current row's ID
    • customerEmail = Customer Email column
    • customerName = Customer Name column

Error Recovery

Variables Not Showing in Nodes

ISSUE: Input variables not available in node configuration

CHECK:
  - Are variables saved? (click outside input to save)
  - Did you select the right workflow?
  
TRY: Refresh page, variables should appear

Workflow Not Triggering

ISSUE: App action executes but workflow doesn't run

CHECK:
  - Is the Trigger Workflow action pointing to correct workflow?
  - Are all required input variables being passed?
  - Does the workflow have nodes? (empty workflows may not execute)

Variable Values Empty

ISSUE: Workflow runs but variable values are empty/null

CHECK:
  - Is the App Interaction correctly mapping data to variables?
  - Does the screen have access to that data?
  - Are column names correct in the mapping?

Report Format

MANUAL WORKFLOW CREATED:
  Name: {workflowName}
  Input Variables:
    - {variableName}: {type}
    - {variableName}: {type}
  Nodes Added: {list}
  Status: SUCCESS | FAILED
  
INTEGRATION NOTE:
  Use "Trigger Workflow" action in App Interaction to call this workflow.
  Map screen data to input variables.

Create Schedule Workflow Procedure

Overview

Creates a server-side workflow that runs automatically on a schedule. Options include every X minutes, hourly, daily, weekly, or monthly.

Schedule Options

FrequencyConfiguration
Every 5 minutesNo additional config
Every 15 minutesNo additional config
Every 30 minutesNo additional config
Every hourNo additional config
Every daySelect days of week + time
Every weekSelect day of week + time
Every monthSelect day of month (1-31) + time

Procedure

Step 1: Navigate to Workflows

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/workflows

EXPECTED: Workflow editor loads
VERIFY: Shows workflow list or empty state with "New workflow" option

Step 2: Create New Workflow

COMMAND: SNAPSHOT
PURPOSE: Find new workflow button

FIND: "New workflow" or "+" button
      May be in header or center of empty state
COMMAND: CLICK
REF: {ref of new workflow button}
ELEMENT: New workflow button

EXPECTED: Workflow type selection appears

Step 3: Select Schedule Type

COMMAND: SNAPSHOT
PURPOSE: Find workflow type options

FIND: List of trigger types:
      - Schedule
      - Webhook
      - Manual
      - On Email
      - Slack
COMMAND: CLICK
REF: {ref of Schedule option}
ELEMENT: "Schedule" trigger type

EXPECTED: New schedule workflow created
VERIFY: Right panel shows schedule configuration

Step 4: Name the Workflow

COMMAND: SNAPSHOT
PURPOSE: Find workflow name input

FIND: Name field in right properties panel
      May be at top of panel or in header
COMMAND: CLICK
REF: {ref of name input}
ELEMENT: Workflow name input
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Workflow name
TEXT: {workflowName}

EXAMPLES: "Daily Report", "Hourly Sync", "Weekly Cleanup"

Step 5: Configure Schedule Frequency

COMMAND: SNAPSHOT
PURPOSE: Find frequency selector

FIND: Frequency dropdown or options:
      - Every 5 minutes
      - Every 15 minutes
      - Every 30 minutes
      - Every hour
      - Every day
      - Every week
      - Every month
COMMAND: CLICK
REF: {ref of frequency dropdown}
ELEMENT: Schedule frequency selector
COMMAND: SNAPSHOT
PURPOSE: Find desired frequency option
COMMAND: CLICK
REF: {ref of desired frequency}
ELEMENT: "{frequency}" option

EXPECTED: Frequency selected

Step 6: Configure Time/Day Settings

Configuration varies by frequency:

For "Every day":
COMMAND: SNAPSHOT
PURPOSE: Find day and time selectors

FIND:
  - Day checkboxes (Mon, Tue, Wed, Thu, Fri, Sat, Sun)
  - Time picker

Select days:

COMMAND: CLICK
REF: {ref of day checkbox}
ELEMENT: "{dayName}" checkbox

REPEAT: For each day the workflow should run

Set time:

COMMAND: CLICK
REF: {ref of time picker}
ELEMENT: Time picker
COMMAND: TYPE or SELECT
REF: {ref of time input}
ELEMENT: Time input
TEXT: {time}

EXAMPLE: "09:00", "14:30"
For "Every week":
COMMAND: SNAPSHOT
PURPOSE: Find day and time selectors

FIND:
  - Day selector (single day of week)
  - Time picker
COMMAND: CLICK
REF: {ref of day selector}
ELEMENT: Day of week selector
COMMAND: CLICK
REF: {ref of desired day}
ELEMENT: "{dayName}" option

Set time as above.

For "Every month":
COMMAND: SNAPSHOT
PURPOSE: Find date and time selectors

FIND:
  - Day of month selector (1-31)
  - Time picker
COMMAND: CLICK
REF: {ref of date selector}
ELEMENT: Day of month selector
COMMAND: TYPE or SELECT
REF: {ref of date input}
ELEMENT: Day of month
TEXT: {dayNumber}

EXAMPLE: "1" (first of month), "15" (mid-month)

Set time as above.

Step 7: Enable the Schedule

COMMAND: SNAPSHOT
PURPOSE: Find enable toggle

FIND: Toggle or switch to enable/activate the schedule
      May say "Enabled", "Active", or similar
COMMAND: CLICK
REF: {ref of enable toggle}
ELEMENT: Enable schedule toggle

EXPECTED: Schedule is now active
VERIFY: Toggle shows "on" state

Step 8: Verify Configuration

COMMAND: SNAPSHOT
PURPOSE: Confirm schedule settings

VERIFY:
  - Workflow name is set
  - Frequency is correct
  - Days/time are configured
  - Schedule is enabled

Next Steps

After creating the trigger, add nodes to define what the workflow does:

  1. Add data operations (query, add, update rows)
  2. Add communication (send email, notification)
  3. Add conditions for logic
  4. Add loops for batch processing

See nodes/ procedures for adding workflow nodes.

Error Recovery

Schedule Not Saving

ISSUE: Changes don't persist

CHECK:
  - Is there a save button? (Some workflows auto-save)
  - Are all required fields filled?
  - Is there an error message?

TRY: Click outside the field to trigger save

Time Picker Not Working

ISSUE: Can't set time

CHECK:
  - Is it a dropdown or text input?
  - Does it need 24-hour format?

TRY: Type time directly: "09:00" or "9:00 AM"

Schedule Not Running

ISSUE: Workflow created but not executing

CHECK:
  - Is the schedule enabled?
  - Is the time zone correct?
  - Does the workflow have nodes to execute?

NOTE: Schedule won't run if there are no actions defined

Report Format

SCHEDULE WORKFLOW CREATED:
  Name: {workflowName}
  Frequency: {every X minutes | daily | weekly | monthly}
  Schedule: {specific times/days}
  Enabled: {yes | no}
  Status: SUCCESS | FAILED
  Notes: {any issues}

Create Slack Workflow Procedure

Overview

Creates a server-side workflow triggered by events in Slack. Requires Slack integration to be enabled and the Glide bot added to the Slack workspace.

Prerequisites

Before creating a Slack workflow:

  1. Slack Integration Enabled - In Glide team settings
  2. Glide Bot in Slack - Added to workspace
  3. Bot in Channel - Invited to channels it needs to monitor

If not set up, report to user:

BLOCKED: Slack integration required

USER ACTION NEEDED:
1. Go to Team Settings → Integrations
2. Connect Slack workspace
3. Add Glide bot to Slack workspace
4. Invite bot to relevant channels

Available Variables

Slack workflows receive event data as variables:

VariableDescriptionExample
Channel IDSlack channel identifierC1234567890
Channel NameHuman-readable channel name#general
User IDSlack user identifierU1234567890
User NameUser's display namejohn.doe
Message TextContent of the messageHello team!
TimestampWhen event occurredSlack timestamp
Thread TSThread timestamp (if reply)Thread identifier
Event TypeType of Slack eventmessage, reaction_added

Available variables depend on the specific event type configured.

Procedure

Step 1: Navigate to Workflows

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/workflows

EXPECTED: Workflow editor loads

Step 2: Create New Workflow

COMMAND: SNAPSHOT
PURPOSE: Find new workflow button
COMMAND: CLICK
REF: {ref of new workflow button}
ELEMENT: New workflow button

EXPECTED: Workflow type selection appears

Step 3: Select Slack Type

COMMAND: SNAPSHOT
PURPOSE: Find workflow type options
COMMAND: CLICK
REF: {ref of Slack option}
ELEMENT: "Slack" trigger type

EXPECTED: New Slack workflow created
VERIFY: Right panel shows Slack configuration options

Step 4: Check Integration Status

COMMAND: SNAPSHOT
PURPOSE: Verify Slack integration

FIND: Slack connection status in properties panel
      May show "Connected" or "Connect Slack" button

IF not connected:
  REPORT: BLOCKED
  REASON: Slack integration not linked
  ACTION: User must connect Slack in Team Settings

Step 5: Name the Workflow

COMMAND: SNAPSHOT
PURPOSE: Find workflow name input
COMMAND: CLICK
REF: {ref of name input}
ELEMENT: Workflow name input
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Workflow name
TEXT: {workflowName}

EXAMPLES: "Slack Message Logger", "Support Channel Bot", "Feedback Collector"

Step 6: Configure Slack Event

COMMAND: SNAPSHOT
PURPOSE: Find Slack event configuration

FIND: Event type selector or configuration options:
  - Which channels to monitor
  - Which event types to trigger on
  - Filter conditions

Select event type (if available):

COMMAND: CLICK
REF: {ref of event type dropdown}
ELEMENT: Slack event type selector
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of event option}
ELEMENT: "{eventType}" option

EVENT TYPES may include:
  - Message posted
  - Reaction added
  - File shared
  - Channel joined
  - etc.

Select channel(s) (if available):

COMMAND: CLICK
REF: {ref of channel selector}
ELEMENT: Channel selector
COMMAND: SNAPSHOT
COMMAND: CLICK
REF: {ref of channel}
ELEMENT: "#{channelName}" channel

NOTE: Bot must be in the channel to receive events

Step 7: Add Workflow Nodes

Now add nodes to process the Slack event.

Common patterns:

Log Messages to Table
  1. Add Row to "Messages" table
    • Channel = Channel Name
    • User = User Name
    • Content = Message Text
    • Timestamp = Timestamp
Auto-Reply to Keywords
  1. Condition: Check if Message Text contains "help"
  2. If true: Send Slack message back to channel
Create Task from Message
  1. Add Row to "Tasks" table
    • Title = Message Text
    • Source = "Slack"
    • Reporter = User Name

Step 8: Using Slack Variables in Nodes

COMMAND: SNAPSHOT
PURPOSE: Find data binding in node configuration
COMMAND: CLICK
REF: {ref of data selector}
ELEMENT: Data source selector
COMMAND: SNAPSHOT
PURPOSE: Find Slack variables

FIND: Slack trigger variables:
  - Channel ID
  - Channel Name
  - User ID
  - User Name
  - Message Text
  - etc.
COMMAND: CLICK
REF: {ref of desired variable}
ELEMENT: "{variableName}" Slack variable

EXPECTED: Node now uses that Slack data

Step 9: Verify Configuration

COMMAND: SNAPSHOT
PURPOSE: Confirm Slack workflow setup

VERIFY:
  - Workflow name is set
  - Slack integration connected
  - Event type/channels configured
  - Nodes use Slack variables correctly

Use Cases

Message Logger

  • Event: Any message in specific channel
  • Action: Log to table for analytics

Keyword Responder

  • Event: Message containing specific keywords
  • Action: Post helpful response or escalate

Feedback Collector

  • Event: Messages in #feedback channel
  • Action: Create row in Feedback table, notify product team

Support Bot

  • Event: Messages mentioning @support
  • Action: Create support ticket, acknowledge in thread

Sending Messages Back to Slack

To respond in Slack:

  1. Add "Send Slack Message" node
  2. Configure:
    • Channel: Use Channel ID from trigger (or hardcode)
    • Message: Your response text
    • Thread: Use Thread TS to reply in thread

Error Recovery

Slack Not Connected

ISSUE: "Connect Slack" showing, no integration

USER ACTION REQUIRED:
1. Go to go.glideapps.com/settings (Team Settings)
2. Find Integrations section
3. Click Connect Slack
4. Authorize Glide bot in Slack workspace

Channel Not Listed

ISSUE: Can't find channel in selector

CHECK:
  - Is the Glide bot invited to that channel?
  - Is it a private channel? (bot needs explicit invite)

USER ACTION: Invite @Glide bot to the channel in Slack

Workflow Not Triggering

ISSUE: Sent Slack message but workflow didn't run

CHECK:
  - Is workflow enabled?
  - Is bot in the correct channel?
  - Does event type match? (message vs reaction, etc.)
  - Is there a filter excluding this event?

Can't Send Slack Messages

ISSUE: Send Slack Message node fails

CHECK:
  - Does bot have permission to post in that channel?
  - Is Channel ID correct?
  - Is message content valid?

Report Format

SLACK WORKFLOW CREATED:
  Name: {workflowName}
  Integration Status: Connected
  Event Type: {message | reaction | etc.}
  Channels: {list of channels or "all"}
  Variables Used: {list}
  Nodes Added: {list}
  Status: SUCCESS | BLOCKED | FAILED
  
NOTES: {any issues or user instructions}

Create Webhook Workflow Procedure

Overview

Creates a server-side workflow triggered by HTTP requests to a unique webhook URL. Ideal for integrating with external systems (Zapier, Shopify, custom APIs).

Available Variables

Webhook workflows have three built-in variables:

VariableDescriptionUse For
The request bodyJSON payload sent in requestMain data payload
The request headersHTTP headersAuth tokens, content type
The request query parametersURL query string?id=123&action=update

Procedure

Step 1: Navigate to Workflows

COMMAND: NAVIGATE
URL: https://go.glideapps.com/app/{appId}/workflows

EXPECTED: Workflow editor loads

Step 2: Create New Workflow

COMMAND: SNAPSHOT
PURPOSE: Find new workflow button

FIND: "New workflow" or "+" button
COMMAND: CLICK
REF: {ref of new workflow button}
ELEMENT: New workflow button

EXPECTED: Workflow type selection appears

Step 3: Select Webhook Type

COMMAND: SNAPSHOT
PURPOSE: Find workflow type options
COMMAND: CLICK
REF: {ref of Webhook option}
ELEMENT: "Webhook" trigger type

EXPECTED: New webhook workflow created
VERIFY: Right panel shows webhook URL

Step 4: Name the Workflow

COMMAND: SNAPSHOT
PURPOSE: Find workflow name input
COMMAND: CLICK
REF: {ref of name input}
ELEMENT: Workflow name input
COMMAND: TYPE
REF: {ref of name input}
ELEMENT: Workflow name
TEXT: {workflowName}

EXAMPLES: "Shopify Order Import", "Zapier Contact Sync", "API Handler"

Step 5: Copy Webhook URL

COMMAND: SNAPSHOT
PURPOSE: Find webhook URL in properties panel

FIND: 
  - URL displayed in right panel
  - Copy button next to URL
  - May be labeled "Webhook URL" or "Endpoint"

Method A: Use copy button

COMMAND: CLICK
REF: {ref of copy button}
ELEMENT: Copy webhook URL button

EXPECTED: URL copied to clipboard

Method B: Select and copy URL

COMMAND: CLICK
REF: {ref of URL field}
ELEMENT: Webhook URL field
COMMAND: PRESS_KEY
KEY: Meta+A (select all)
COMMAND: PRESS_KEY
KEY: Meta+C (copy)

Step 6: Extract Webhook URL

COMMAND: EVALUATE
CODE: async () => {
  try {
    const url = await navigator.clipboard.readText();
    return { webhookUrl: url };
  } catch (err) {
    return { error: err.message };
  }
}

EXPECTED: JSON with webhookUrl
SAVE: Store this URL to provide to user/external system

Step 7: Add Query JSON Nodes (Recommended)

For webhook workflows, always add Query JSON nodes to parse the incoming data.

COMMAND: SNAPSHOT
PURPOSE: Find node canvas and add button

FIND: Workflow canvas with trigger node
      "+" button to add nodes

See nodes/add-query-json.md for detailed steps.

Quick Summary:

  1. Click "+" or drag from trigger node
  2. Search for "Query JSON" or find in Data category
  3. Add node
  4. Configure:
    • Source: "The request body"
    • Query: JSONata expression (e.g., orderId, customer.email)

Repeat for each piece of data you need to extract.

Step 8: Verify Configuration

COMMAND: SNAPSHOT
PURPOSE: Confirm webhook setup

VERIFY:
  - Workflow name is set
  - Webhook URL is visible
  - Query JSON nodes added for data parsing
  - URL has been copied for external use

Parsing Webhook Data

Example: Shopify Order

Incoming payload:

{
  "id": 12345,
  "customer": {
    "name": "John Doe",
    "email": "john@example.com"
  },
  "total": 99.99,
  "items": [
    {"name": "Widget", "qty": 2}
  ]
}

Query JSON nodes to add:

Node NameSourceJSONata Query
Order IDThe request bodyid
Customer NameThe request bodycustomer.name
Customer EmailThe request bodycustomer.email
TotalThe request bodytotal
Item CountThe request body$count(items)

Example: Simple Webhook

Incoming payload:

{
  "action": "create",
  "userId": "abc123",
  "data": {
    "name": "New Item"
  }
}

Query JSON nodes:

Node NameJSONata Query
Action Typeaction
User IDuserId
Item Namedata.name

Testing the Webhook

Provide the user with:

  1. The webhook URL
  2. Expected payload format
  3. Test command (if applicable):
curl -X POST "{webhookUrl}" \
  -H "Content-Type: application/json" \
  -d '{"test": true, "message": "Hello from test"}'

Error Recovery

Webhook URL Not Appearing

ISSUE: No URL in properties panel

CHECK:
  - Is the workflow saved?
  - Is this a Webhook type (not Schedule or Manual)?

TRY: Refresh page and check again

Can't Copy URL

ISSUE: Copy fails

TRY:
  1. Click directly in URL field
  2. Select all (Cmd+A)
  3. Copy (Cmd+C)
  4. Or manually select and right-click → Copy

Webhook Not Receiving Data

ISSUE: External system says it sent data but workflow didn't run

CHECK:
  - Is the URL correct? (no typos)
  - Is the request method POST?
  - Is Content-Type application/json?
  - Does the workflow have any nodes? (empty workflows may not log)

Report Format

WEBHOOK WORKFLOW CREATED:
  Name: {workflowName}
  Webhook URL: {url}
  Query JSON Nodes: {list of fields being parsed}
  Status: SUCCESS | FAILED
  Notes: {any issues or user instructions}

USER ACTION REQUIRED:
  Configure external system to POST to: {webhookUrl}

Sponsors

Details

Marketplace
glideapps/glide-code
Source
glide
Category
Community