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:

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

The audit will:

1. Extract app ID from URL
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

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

Known Performance Issues

From Glide Documentation

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:

• Performance Analysis
• Query Column Limits
• Build for Speed and Scale
• Big Tables Guide

Community:

• Performance Tips & Tricks

Plugin procedures:

• procedures/fetch-app-data.md - Data extraction
• procedures/analyze-layout.md - UI inspection

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