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:

| Metric | Threshold | Source | |--------|-----------|--------| | Column computation time | 100ms | Performance Analysis - columns exceeding this show ⚠️ | | Query column entries | 10,000 max | Query Column Limits | | Glide Table rows | 25,000 max | Big Tables Guide | | Big Table rows | 10 million max | Big Tables | | Big Table rollup/lookup matches | 100 max | Big Tables | | Collection items visible | 24 recommended | Build for Speed | | Image dimensions | 1,500px max | Build 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

| Issue | Why It's Slow | Recommendation | |-------|---------------|----------------| | Query columns | Full table scan | Use Relations instead when matching exact values | | Query on same table | Can crash app | Never do this - restructure data | | Nested computed columns | Cascade delays | Minimize chain depth, use Performance Analysis to identify | | Filtering on computed columns | Full table recalc | Filter on basic columns when possible | | Large collections | Heavy rendering | Limit to 24 items, use pagination | | Large images | Slow download | Keep under 1,500px | | External data sources | Sync delays | Prefer 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:

• 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
• 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