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