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.

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.

After integrating W3Speedster into your Magento store, 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 Magento environment.
• Measure the application’s performance metrics before enabling any optimization (e.g., using tools like Lighthouse, GTmetrix, or Magento Profiler).
• 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 Magento setup.

Step 2: Optional Advanced Testing (For Technical Users)

For developers familiar with web performance, asset loading behavior, and Magento’s frontend 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 Magento store’s:
  • Block Level rendering times
  • Asset loading sequences
  • Render-blocking resources
  • Server-to-browser 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 indexing
  • Fine-tuning cache types and full-page caching (FPC)
• This step is ideal for stores where performance is business-critical, especially in custom-themed or extension-heavy Magento deployments.

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 structure of your Magento store, including:

• Frontend stack (e.g., Luma, Hyvä, or PWA Studio)
• Third-party modules or custom extensions
• Hosting environment (shared, VPS, dedicated, or cloud-optimized for Magento)
• Content structure, such as:(e.g., Heavy category or product pages, Image/media-driven CMS blocks, Checkout and account-related real-time workflows)

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 settings are safe across most Magento setups and require no advanced technical configuration.

Best Practice: Gradual Testing & Enablement

To ensure a stable and effective optimization process when integrating W3Speedster into your magento Store, 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
  • Magento-specific layout and observer integration
• 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:

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

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

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

Feature:

The Change Logs functionality in W3Speedster provides a detailed audit trail of all configuration changes made within the plugin. It tracks which user performed what action, along with timestamps, ensuring complete transparency and accountability over optimization settings.

Why We Need It

• Accountability: Tracks individual user actions, helping teams identify who made specific changes.
• Audit History: Maintains a chronological log of all configuration updates, reversals, or resets.
• Error Tracing: Helps pinpoint the source of performance issues caused by misconfiguration.
• Team Collaboration: Facilitates multi-user workflows by providing visibility into each contributor’s activities.
• Security Monitoring: Detects unauthorized or unexpected changes that could impact performance or stability.

How It Works in W3Speedster

• Automated Logging: Every time a user saves, updates, or resets a configuration within the W3Speedster dashboard, an entry is automatically recorded.
• Detailed Entries:
  • User identification (username or user ID)
  • Type of action (e.g., enabled minification, disabled cache)
  • Date and time stamp
  • Affected setting(s)
• Accessible Interface: View logs directly from the W3Speedster dashboard under the “Change Logs” section for quick reference.

Benefits

• Improves transparency for developers and site owners.
• Speeds up troubleshooting by allowing rollback to prior configurations based on tracked changes.
• Enhances team workflows, especially in multi-admin environments.
• Increases trust by providing visibility into all modifications made in the optimization settings.

How to Access

• Navigate to the W3Speedster Dashboard admin.
• Click on the “Change Logs” tab or section.
• Browse the chronological list of actions, filter by date or user, and review detailed activity logs.

Best Practices

• Review logs periodically to ensure no unauthorized or accidental changes have been made.
• Use logs during debugging to correlate changes with performance regressions or improvements.
• Maintain least-privilege access—only allow trusted users to modify plugin settings.

Summary

The Change Logs feature in W3Speedster acts as a real-time audit system, ensuring every action is recorded and reviewable. It empowers teams with visibility, supports debugging workflows, and enforces accountability across optimization efforts—critical for maintaining long-term performance and operational integrity.

The post Change Logs appeared first on W3Speedster.

Step-by-Step Testing Procedure

• Enable options incrementally: Activate one setting at a time rather than enabling all features at once. This makes it easier to identify and isolate issues.
• Test in a non-logged-in session – After enabling each option:
  • Open your site in a browser window where you are not logged in.
  • Preferably use a private/incognito window to test.
  • This ensures you see the site as a regular visitor would, bypassing any admin-specific behavior.
• Check multiple page types – Review different types of pages on your site, such as:
  • Home page
  • Blog or archive pages
  • Product or service pages
  • Contact or form-based pages
• If you encounter a display or functionality issue
  • Disable the last setting you enabled.
  • The issue will usually be resolved immediately after doing so.

Summary

Following this structured approach allows you to:

• Maximize performance gains with W3Speedster
• Minimize the risk of breaking the layout or functionality
• Confidently identify and roll back conflicting settings

The post Best practice appeared first on W3Speedster.

• After purchasing W3Speedster, you can download the ZIP file from your W3Speedster Account Dashboard, email, or from the order received page during checkout.
• To download it from my account, navigate to: My Account (login required).
• Locate the most recently purchased order and click Download.

Safari Users – Important Notice

Safari may automatically unzip .zip files upon download, which prevents you from uploading the plugin.

How to Disable Automatic Unzipping in Safari

• Open Safari.
• Go to Safari > Settings (or Preferences, depending on your macOS version).
• Under the General tab:
  • Uncheck the option: “Open ‘safe’ files after downloading.”
• This ensures that the plugin file remains in .zip format after downloading, which is required for installation.
• Now you can download the zip file normally and proceed with the installation.

The post Download W3Speedster appeared first on W3Speedster.

The Exclude JavaScript from Optimization feature in W3Speedster offers developers precise control over which JavaScript elements, both tags and inline scripts—should bypass optimization routines such as lazy loading or minification. This ensures that critical functionality, user interface behaviors, and third-party integrations remain unaffected by performance enhancements.

Why We Need It

• Ensure Functional Reliability
  • Prevent critical JavaScript files and inline logic from being delayed or reordered.
  • Maintain stable and predictable behavior across all devices and user sessions.
• Support Script Dependencies: Many scripts require strict loading sequences or DOM availability. Excluding them prevents initialization errors.
• Protect Time-Sensitive Code: Tracking tools, API handlers, UI initializers, and third-party services often need synchronous execution during the initial page load.

Problems Without Exclusion

• Core Script Failures: Lazy loading may defer essential JavaScript (e.g., navigation, modals, or UI logic), causing broken functionality.
• Delayed Third-Party Integrations: Services like Google Analytics, Facebook Pixel, Stripe, or CAPTCHA systems may fail if their scripts load late or out of order.
• Visual & Interaction Glitches: UI elements relying on animation, layout calculation, or live updates may behave inconsistently.
• Loss of Event-Driven Behavior: Inline scripts tied to user actions or page-load events may not execute when needed, impacting UX and tracking accuracy.

W3Speedster’s Solution

W3Speedster resolves these issues with a dual mechanism for JavaScript exclusion:

1. Exclude JavaScript Tags
   • Script Identification – You can define:
     • Full external URLs (https://example.com/js/main.js)
     • File names (jquery.js, custom-interaction.js)
     • Script tag identifiers or unique substrings in the script path.
   • Bypass Lazy Load & Minification – Marked scripts are excluded from:
     • Lazy loading deferral
     • Minification and merging
     • Async or defer manipulations
   • Ideal Use Cases
     • Core UI libraries (jquery.js, main.js)
     • Payment SDKs (Stripe, Razorpay)
     • Real-time modules (WebSockets, chat scripts)
     • E-commerce components (cart logic, session validators)
2. Exclude Inline JavaScript
   • Pattern-Based Filtering – Specify unique:
     • Text patterns (e.g., gtag, fbq, initializeSlider)
     • script tag IDs (id=”initMenu”)
     • Keywords that match logic-critical functions
   • Immediate Execution – Matching inline scripts:
     • Execute as part of the original HTML load
     • Are not affected by lazy loading or other deferral logic
   • Ideal Use Cases
     • Tracking scripts: <script>gtag(‘config’, ‘UA-XXXXX’);</script>
     • Marketing pixels: <script>fbq(‘track’, ‘PageView’);</script>
     • UI initializers: <script>initializeSlider();</script>

Best Practices

• Use precise and unique identifiers to avoid over-exclusion or unintended matches.
• Keep the exclusion list minimal—only essential scripts should bypass optimization.
• Regularly audit excluded scripts to ensure relevance as your site evolves.
• Verify third-party requirements, especially those that mandate synchronous script loading.

Summary

The Exclude JavaScript from Optimization feature in W3Speedster provides advanced control over the execution of both external and inline JavaScript. By selectively excluding mission-critical scripts from lazy load and other optimizations, developers can ensure seamless functionality without sacrificing overall performance. This balanced approach enhances site stability, supports third-party integrations, and upholds a high standard of user experience across all environments.

The post Exclude Javascript From LazyLoad appeared first on W3Speedster.