On Nginx servers, Apache .htaccess rules cannot serve HTML cache by themselves. When W3Speedster detects Nginx, it provides a ready-made nginx.conf snippet so cached HTML can be served from the site root.

How to Access

• Open W3Speedster Dashboard → HTML Cache and enable HTML Caching.
• If Nginx is detected, the tab shows a notice with the exact nginx.conf content to create in your WordPress root.
• Include that file in your Nginx server block, for example: include /path/to/site/nginx.conf;
• Test and reload Nginx with nginx -t && nginx -s reload, or use your host panel.
• Open the homepage while logged out so a cache file can be created, then reload the HTML Cache tab to confirm the status.

Status messages

• Nginx cache is working — the homepage response matched the cached HTML file.
• Nginx cache rules found — rules are present, but no homepage cache file exists yet.
• Nginx cache is not serving yet — rules and a cache file exist, but Nginx is still not returning that file. Check the include and reload Nginx.

Notes

• This is the Nginx equivalent of serving HTML cache files through rewrite rules.
• When Ignore query parameters is enabled, Nginx cache rules also ignore the query string for lookups.

The post Nginx Cache Support appeared first on W3Speedster.

When Optimize with AI is enabled, the URL table shows Desktop and Mobile status, the last update time, and actions for each page. Filters and pagination are stored in the page URL, so a refresh keeps the same view.

Functionality:

• Rows Per Page — show 10, 20, 50, or 100 rows at a time.
• Status — filter by All, Queued, In-progress, Optimized, or Not Optimized.
• URL — type part of a URL and click Filter to narrow the list.

Status meanings

• Queued — waiting for the next crawl slot.
• In-progress — critical CSS or cache work is running, including cloud sync.
• Optimized — desktop and mobile work for that URL is complete.
• Not Optimized — the page failed or was marked not optimized on purpose.

How to Access

• Open W3Speedster Dashboard → Optimize with AI.
• Use the filter row above the URL table.

The post Status Filters & Table appeared first on W3Speedster.

Bulk Actions let you update several Optimize with AI URLs at once. Select rows with the checkboxes (or Check all), choose an action, then click Apply.

Available actions

• Re-optimize — clears local HTML cache and critical CSS files for the selected URLs, sets them to Queued, and starts crawling them now (limited by Pages per Minute).
• Queue for next run — clears those files and sets status to Queued without crawling immediately. Pages are picked up on the next Optimize with AI cycle.
• Mark as not optimized — sets status to Not Optimized so W3Speedster stops retrying until you queue or re-optimize them again.

How to Access

• Open W3Speedster Dashboard → Optimize with AI.
• Select one or more rows, choose a bulk action, then click Apply.

Benefits

• Fix failed pages without resetting the whole site.
• Delay heavy crawls when the server is busy.
• Keep the queue accurate instead of waiting on false timeouts.

The post Bulk Actions appeared first on W3Speedster.

Ignore query parameters tells HTML cache to look up pages without the query string. For example, /product/?srsltid=abc and /?utm_source=google can use the same cache files as /product/ and /.

Functionality:

• Applies to HTML cache delivery through .htaccess, PHP/advanced-cache, and Nginx (nginx.conf).
• Overrides Enable caching page with GET parameters while it is on. W3Speedster will not use a separate cache file per query string for lookup.
• On a cache miss, the original query string still reaches WordPress; only the cache path ignores it.
• Off by default. Enabling it does not rewrite existing rules until you save, and it does not flush the HTML cache.
• Not the same as Remove query parameters, which strips version strings such as ?ver= from CSS and JavaScript file URLs for browser and CDN caching.

When to enable

• Tracking parameters such as srsltid, gclid, fbclid, and utm_* that should not create extra HTML cache files.
• Sites that cache pages with GET parameters but want one shared cache for marketing variants of the same URL.

How to Access

• Open W3Speedster Dashboard → HTML Cache.
• Enable Ignore query parameters (under Enable caching page with GET parameters).
• Save changes.

The post Ignore query parameters appeared first on W3Speedster.

Pages per Minute sets how many queued pages Optimize with AI may start crawling in one minute. In the admin UI the field is labeled Pages per Minutes. The maximum value is 20. Use a lower value on smaller servers and a higher value on stronger hosts.

Why We Need It

• Large sites need a steady optimization pace, not an all-at-once burst.
• Too many pages at once can overload the server; too few makes the job take longer than necessary.
• This setting lets you match optimization speed to your hosting capacity.

Problems Without It

• Without a limit, crawls can spike CPU and memory usage.
• Without enough throughput, finishing the full URL list can take much longer.
• Every host is different, so a fixed pace for all sites is not practical.

Solutions with Pages per Minute

• If Pages per Minute is empty, W3Speedster can fall back to the Preload Page Caching per Minute value.
• Set a value from 1 to 20 on the Optimize with AI tab, then click Save.
• Only pages that successfully start crawling move from Queued to In-progress. Remaining pages stay Queued for the next minute.
• Pages already In-progress keep syncing optimization status and are not limited by this setting for status checks.
• If a page stays In-progress for about 60 seconds with no local work started and no cloud job, it returns to Queued automatically.

How to Access

• Open W3Speedster Dashboard → Optimize with AI.
• Set Pages per Minutes (max 20) and click Save.

Benefits

• Protects the server while optimization runs.
• Lets powerful hosts finish large sites faster when you raise the limit.
• Keeps the queue predictable: new crawls start only when a slot is available.

The post Pages Per Minute appeared first on W3Speedster.

Optimize with AI automates the main performance tasks for your site. It crawls your pages, then generates critical CSS, optimizes images, and builds HTML cache so you do not have to manage each step manually.

Why We Need It

• Critical CSS, image optimization, and cache creation take time when done by hand and are easy to miss on some pages.
• Each page can be optimized for its own layout, which keeps performance more consistent across the site.
• When content changes, AI can pick up new or updated pages so optimization stays current.
• Faster pages improve user experience and can support better SEO results.

Problems Without AI Optimization

• Manual runs often skip critical CSS, cache, or image work on some URLs.
• Pages missing from the sitemap, or added later, may stay unoptimized until they are crawled.
• Resetting and regenerating optimizations becomes slow and error-prone without automation.
• Uneven settings across pages lead to uneven performance.

Solutions with Optimize with AI

• Crawling Through Sitemap
  • AI reads the sitemap to find site URLs.
  • URLs are processed in controlled batches so the server is not overloaded.
• Generating Critical CSS
  • Page-specific critical CSS is generated for each URL.
  • Above-the-fold content can render sooner, which improves perceived speed.
• Image Optimization and Cache Creation
  • Images are optimized automatically where those options are enabled.
  • HTML cache files are created so repeat visits load faster.
• Handling Missing URLs
  • If a URL is not in the sitemap, critical CSS can still be created the first time that page is crawled.
• Reset and Rescan
  • Use Reset when you want a clean rebuild.
  • Previous critical CSS is cleared, then the sitemap is scanned again and optimizations are regenerated.
• Automatic Safeguards
  • Optimize with AI depends on related options such as critical CSS, image optimization, and caching.
  • If required options are turned off, Optimize with AI turns itself off so it does not run in an incomplete state.

Benefits

• Faster load times with less manual work.
• Optimizations that stay updated as the site changes.
• More consistent performance across pages and devices.

The post Enable AI Optimization appeared first on W3Speedster.

While integrating a Content Delivery Network (CDN) significantly enhances performance by offloading static resources, not all paths in a Joomla—should be served via CDN. Certain directories and dynamic endpoints must always be served from the origin server to maintain functional integrity and prevent unexpected issues.

W3Speedster addresses this requirement with a flexible Path Exclusion feature.

Why We Need It

• Preserve Core CMS Functionality: Joomla-specific directories (e.g., /libraries/, /administrator/, /templates/system/) contain essential files. Serving them via a CDN can result in:
  • Version mismatches
  • Failed asset resolution
  • Malfunctioning module rendering or backend errors
• Avoid Extension & Plugin Conflicts: Joomla components, modules, and plugins often require direct file access or serve AJAX endpoints. Excluding such paths ensures proper operation without CDN interference.
• Prevent Caching of Dynamic or Sensitive Logic: Some Joomla paths include:
  • CSRF token-protected URLs
  • Login/authentication modules
  • Real-time module updates or admin AJAX calls

These must not be cached or routed via CDN to prevent security breaches or UI malfunctions.

How It Works in W3Speedster

1. Path Exclusion Field
   • Located under: W3Speedster > CDN Settings > Exclude Paths
   • You can enter relative paths that should bypass the CDN rewriting logic.
2. Example Pattern Configuration: /libraries/, /administrator/, /templates/, /media/system/js/, /modules/mod_ajax/, /api/
   • All files under these directories will not be served via CDN
   • Instead, they will be loaded directly from the origin (e.g., https://www.example.com/administrator/index.php)
3. Matching Logic: W3Speedster uses string pattern matching (not regex) to determine if a URL should be excluded. Ensure each path begins with a forward slash (/) and ends with one if targeting directories.

Benefits

• Maintains Extension Compatibility – Ensures that dynamic components, real-time modules, and backend admin features work seamlessly.
• Preserves CMS Integrity – Prevents broken template behavior, script errors, or failed admin/API interactions.
• Simplifies Debugging – Keeps CDN logic separate from core functionality, allowing easier issue isolation.
• Enhances Security – Prevents CDN caching of login URLs, session-based responses, or tokenized endpoints.

Note: Avoid excluding too many paths unnecessarily, as it limits CDN benefits. Only exclude paths essential for functionality or security.

Verification Tip

After applying exclusions:

• Inspect the page source (Ctrl+U) to confirm that excluded paths are loading from the origin URL.
• Use tools like PageSpeed Insights or DevTools Network Tab to ensure CDN is applied selectively.

The post Exclude path from cdn appeared first on W3Speedster.

Key Features of W3Speedster

• CDN Integration
  • Easily integrate any Content Delivery Network (CDN) to reduce latency and improve global load times.
• HTML Caching
  • Generates static HTML versions of pages for faster delivery to users.
• Image Optimization
  • Automatically compresses images and allows adjustment of image quality settings.
• Lazy Loading
  • Delays the loading of below-the-fold images and iframes until the user scrolls near them.
• WebP Support
  • Converts and serves modern WebP images for better compression and faster loading.
• CSS Minification
  • Removes unnecessary whitespace, comments, and formatting from CSS files to reduce size.
• JavaScript Minification
  • Minifies JavaScript files to improve script execution time and reduce load size.
• Defer Parsing of JavaScript
  • Delay loading of non-critical JavaScript to prioritize visible content and improve LCP (Largest Contentful Paint).
• Serve Scaled Images
  • Ensures images are appropriately resized and scaled to match their display dimensions.
• Avoid CSS @import
  • Rewrites or inlines styles to avoid performance penalties caused by @import usage.
• Flexible Exclusion Options
  • Selectively exclude specific CSS, JS, pages, images, or URLs from optimization rules.
• Google Fonts Optimization
  • Combines and optimizes font delivery to reduce additional HTTP requests and FOUT (Flash of Unstyled Text).
• Delay JavaScript Execution
  • Allows you to delay non-essential JavaScript (e.g., third-party scripts) until after user interaction.

Advanced Use Case Support

W3Speedster is engineered to function effectively in advanced Joomla use cases, including:

• Full compatibility with Joomla templating systems, custom templates, and layout overrides.
• Works seamlessly with Joomla eCommerce extensions, multilingual and multisite configurations, and user group access controls.
• Offers granular configuration of: Page-level HTML caching and purging, Exclusions for administrator pages, AJAX endpoints, or dynamically generated URLs.

The post What exactly does W3Speedster do? appeared first on W3Speedster.

After integrating W3Speedster into your Joomla application, it’s recommended to conduct a baseline performance test to assess the immediate optimization impact.

Step 1: Run a Default Settings Test

• Complete the W3Speedster integration into your Joomla application.
• Measure the application’s performance metrics before enabling any optimization (e.g., using tools like Lighthouse, GTmetrix, or Joomla Debug System).
• Enable Recommended Default Settings from the W3Speedster configuration panel.
• Re-run the performance test after enabling the default settings.
• This helps you benchmark the default optimization benefits and understand W3Speedster’s initial performance gains for your Joomla environment.

Step 2: Optional Advanced Testing (For Technical Users)

For developers familiar with web performance, asset loading behavior, and server-side rendering, W3Speedster allows deeper optimization through manual tuning.

You can enhance performance further by:

• Utilizing diagnostic tools such as:
  • GTmetrix
  • Pingdom Tools
  • Google PageSpeed Insights
• Analyzing reports to identify bottlenecks in your Joomla application’s:
  • Route-level response times
  • Asset loading sequences
  • Render-blocking resources
  • Server-to-client delivery delays
• Applying tool-specific recommendations in combination with W3Speedster’s advanced settings to align optimization with your app’s structure, such as:
  • Delaying non-critical scripts
  • Deferring or inlining CSS
  • Optimizing database queries and eager loading
  • Fine-tuning middleware and route caching
• This step is ideal for projects where performance is mission-critical or for applications with custom frontend stacks or real-time interaction layers.

Step 3: Interpreting Performance Test Results

To get accurate and consistent results, follow these best practices:

• Stick to one testing tool for consistency (e.g., only GTmetrix).
• Run three consecutive tests on the same tool.
• Take the average of the three results for a more reliable benchmark.

Are there any recommended settings for W3Speedster?

Yes, W3Speedster provides a set of pre-configured recommended defaults—designed as a “fast track” to achieving a(Way to 90+ on Google PSI) and similar performance benchmarks.

However, optimal results may vary based on the unique architecture of your Joomla application, including:

• Frontend stack (e.g., Joomla templates, JavaScript frameworks, or custom frontend extension
• Third-party extensions or custom plugins/modules
• Hosting environment (shared, VPS, managed cloud, etc.)
• Content structure, such as: (e.g., media-heavy articles, image galleries, component-based layouts, API-driven features)

Features That Work Automatically

Some of W3Speedster’s most impactful features are designed to be plug-and-play. Simply enable them, and they handle the rest automatically in the background:

• CSS Minification
  • Reduces file size by removing unnecessary characters (whitespace, comments) from your stylesheets.
  • Improves load time without altering the appearance of your site.
• JS Minification
  • Strips down JavaScript files to their essential code only.
  • Reduces execution time and enhances overall performance.
• WebP Support
  • Automatically converts and serves images in WebP format, which is lighter and faster than JPG or PNG.
  • No manual conversion or theme changes needed.

These automated settings are safe and effective across most Joomla setups, requiring no advanced technical expertise. They are designed to deliver noticeable performance improvements out-of-the-box, making them ideal for developers seeking quick optimization without deep configuration.

Best Practice: Gradual Testing & Enablement

To ensure a stable and effective optimization process when integrating W3Speedster into your Joomla website, follow these steps:

• Begin with the recommended default settings to quickly achieve performance improvements aligned with Way to 90+ on Google PSI
• Incrementally enable advanced features, such as:
  • Custom Code
  • Exclusion
  • Integration Hooks with Joomla Extensions
• Use performance tools (like PageSpeed Insights, GTmetrix, or Pingdom) after each change.
• If a feature causes rendering issues, disable it immediately and retest.

Automated Features (No Manual Configuration Required)

The following features in W3Speedster are fully automated once enabled, requiring no further setup:

• HTML Caching – Speeds up repeat visits by caching the HTML output.
• WebP Support – Automatically serves images in WebP format if the browser supports it.
• Image Quality Control – Optimizes images without visible quality loss.
• Lazy Loading – Defers off-screen images and iframes for faster initial load.
• CSS Minification – Removes unnecessary characters from CSS files.
• JS Minification – Shrinks JavaScript files for faster execution.
• Combining Inline & 3rd-Party Scripts – Reduces HTTP requests by merging JavaScript code.
• Combining Google Fonts – Merges multiple font requests into one to reduce loading time.

These features work silently in the background to improve performance without manual adjustments.

Settings Pane Structure

Use this section to locate specific settings in the W3Speedster dashboard:

HTML Cache Tab

• HTML Caching – Enable/disable full-page cache.
• Minify HTML – Remove whitespace and comments from HTML output.
• Cache Preload – Automatically preloads cache for faster first loads.
• Leverage Browser Cache – Instruct browsers to cache static assets.
• Gzip Compression – Compress site files for faster delivery.
• Query Parameter Handling – Control how query strings are cached
• URL Exclusion – Exclude specific URLs from being cached.
• Cache Path – Customize the directory path for storing cache files.

General Tab

• License Key – Enter your valid W3Speedster license.
• INP Issues – Tools and fixes to improve Interaction to Next Paint (INP) scores.

CDN Tab

• CDN URL – Add your Content Delivery Network (CDN) URL.
• CDN Exclusion – Specify which files or paths to exclude from CDN.

CSS Tab

• CSS Minification – Reduce size of CSS files.
• Combine Google Fonts – Merge font requests into fewer HTTP calls.
• Critical CSS – Generate and inline above-the-fold CSS.
• CLS Fixes – Tools to minimize Cumulative Layout Shift.

JavaScript Tab

• JavaScript Minification – Compress JavaScript files.
• Combine JavaScript – Merge scripts into a single file to reduce load time.
• Load JS via URL – Add custom JavaScript file URLs to be loaded.

Exclusion Tab

• Exclude JS/CSS/Images/Pages – Prevent specific resources from being optimized or cached.
• Preload Resources – Prioritize key files for faster loading.
• Lazy Load Exclusion – Define elements to skip lazy loading.
• Custom Code Injection – Add your own:
  • CSS Code
  • JavaScript Code

Cache Tab

• HTML Cache
• CSS/JS Cache
• Critical CSS Cache

Manage and clear caches individually for precise control.

Image Settings Tab

• Image Optimization – Automates image compression.
• Image Size Adjustment – Resize large images to optimal dimensions.
• Lazy Loading – Enabled by default.
• WebP Support – Converts images to WebP format.
• Image Quality Control – Adjusts image quality threshold.

Hooks Tab

• Predefined PHP Functions – Integrate custom logic using available hooks.

Web Vitals Log Tab

• Core Web Vitals Log – Tracks real-time metrics related to:
  • LCP (Largest Contentful Paint)
  • CLS (Cumulative Layout Shift)
  • INP (Interaction to Next Paint)

The post Getting Started with W3Speedster appeared first on W3Speedster.