Quick STG Cache Audit: 10 Tests to Improve Page Speed

STG Cache Audit Best Practices for Faster WordPress Sites

A focused STG Cache audit identifies misconfigurations and performance bottlenecks so your WordPress site loads faster with fewer errors. Below is a concise, actionable audit process and best-practice checklist you can follow.

1. Prepare baseline measurements

• Collect metrics: measure current page speed (Lighthouse/GTmetrix/WebPageTest), Time To First Byte (TTFB), First Contentful Paint (FCP), Largest Contentful Paint (LCP), Cumulative Layout Shift (CLS), and Total Blocking Time (TBT).
• Record environment: WordPress version, theme, PHP version, hosting type (shared/VPS), active plugins list, STG Cache plugin version, and CDN status.

2. Verify STG Cache core settings

• Enable caching: confirm page cache is active for logged-out users.
• Cache lifespan: set an appropriate cache TTL (start with 1 hour–24 hours depending on content freshness).
• Cache for mobile: enable separate cache for mobile if your site serves different markup/CSS for mobile.
• Logged-in users: ensure caching is disabled for admin/logged-in users or tailored with exceptions.

3. Configure exclusions and dynamic content handling

• Exclude carts and checkout: skip caching for e-commerce cart, checkout, account pages, and other dynamic endpoints.
• Cookies and query strings: set rules to bypass cache for session or cart cookies and important query strings (e.g., ?add-to-cart).
• AJAX endpoints: ensure admin-ajax and REST API endpoints used by dynamic features are not cached incorrectly.

4. Optimize static asset handling

• Minify and combine: enable CSS/JS minification and concatenation if STG Cache supports it, but test for JS/CSS breakage.
• Defer and async: defer noncritical JS and use async where safe to reduce render-blocking resources.
• Gzip/Brotli: enable compression on the server or via plugin.
• Browser cache headers: set long cache expiry for versioned assets and purge on deployment.

5. Use a CDN and edge caching

• CDN integration: configure a trusted CDN to serve static assets and offload traffic.
• Purge strategy: ensure CDN cache is purged when STG Cache is cleared or when new assets are deployed.
• Edge rules: configure CDN to respect origin cache-control and handle query strings consistently.

6. Optimize cache purging and invalidation

• Automatic purges: enable automatic purging on post/page updates, plugin/theme changes, and comment submissions.
• Granular purging: prefer targeted purges over full-site purges to reduce cache warm-up time.
• Warm cache: consider warming important pages after purge (manually or via a tool) to avoid first-visit slowness.

7. Test plugin and theme compatibility

• Disable conflicts: temporarily disable optimization features (minify/combine) if you see layout or JS errors and re-enable selectively.
• Staging checks: run audit changes in a staging environment before applying to production.

8. Monitor and iterate

• Synthetic tests: run scheduled Lighthouse or WebPageTest runs after changes.
• Real User Monitoring (RUM): collect field data for LCP, FCP, and CLS to detect regressions across geographies and devices.
• Error logs: watch server and JavaScript errors that could indicate cache-related problems.

9. Security and header hygiene

• Remove sensitive headers: avoid exposing server details in HTTP headers.
• HSTS and security headers: configure security headers at the server or CDN level without breaking caching rules.

10. Routine maintenance checklist

• Update WordPress, theme, plugins, and STG Cache regularly.
• Audit active plugins quarterly and remove unused ones.
• Revisit TTLs and purge rules after major content changes or traffic pattern shifts.
• Keep a rollback plan and backups before major cache configuration changes.

Quick 10-step audit checklist

1. Capture baseline metrics (Lighthouse/WebPageTest).
2. Confirm STG Cache version and enable page cache.
3. Set sensible TTLs and mobile cache rules.
4. Exclude dynamic pages (cart, checkout, account).
5. Configure cookie/query string bypasses.
6. Enable compression and browser caching.
7. Integrate and sync CDN purges.
8. Enable safe minify/concatenate, test for breakage.
9. Set up automated purges and cache warming.
10. Monitor RUM and synthetic metrics; iterate.

Follow this process to reduce TTFB, eliminate render-blocking resources, and ensure cached content serves correctly across user types and devices.