A faster WordPress site still needs a working menu, a current product price and a checkout that remembers what someone put in their basket. Those details can disappear from performance discussions once the conversation turns into a race for a higher PageSpeed score.
007AJ Performance and Caching brings page caching, front-end optimization and several maintenance tools into one WordPress plugin. What caught our attention at WPBay is the way it approaches setup. It checks for existing cache files and hosting conflicts before enabling its page cache, backs up configuration files before editing them, and provides a Safe mode for removing its changes when something goes wrong.
There is plenty to configure, from local image compression to Redis object caching. You can leave those options alone while you establish whether the basic page cache helps your site.
This feature covers version 1.0.1, checked against the supplied plugin package, the developer’s documentation and the current WPBay listing. The practical advice below explains how to configure and assess it on your own hosting; it does not assign a performance score from a benchmark we have not run.
What is 007AJ Performance and Caching?
007AJ Performance and Caching is a WordPress performance plugin built around a disk-based page cache. It saves rendered HTML for eligible public pages so subsequent visitors can receive a saved copy without WordPress rebuilding the page through its usual theme and plugin rendering.
The same package includes CSS and JavaScript optimization, image compression, WebP and AVIF generation where supported, local Google Fonts hosting, cache preloading, database cleanup, CDN address rewriting, external cache purging and optional persistent object caching. A Web Vitals screen can collect approximate performance measurements from visitors.
It requires WordPress 6.3 or newer and PHP 7.4 or newer. Version 1.0.1 is intended for single WordPress installations. Multisite is unsupported across the suite, so it should not be treated as a network-wide optimization tool.
A blog, business website, portfolio or documentation site is a sensible place to consider it. These sites often serve the same public page to many visitors. A shop can benefit on eligible catalogue pages, although its basket, checkout and customer account need different treatment.
The useful question is how much of your traffic can receive the same HTML. That answer matters more than the number of settings in the plugin.
How its WordPress page cache works
WordPress normally assembles a page when a request arrives. Depending on the site, that can involve database queries, theme templates, block rendering, shortcodes and work performed by multiple plugins.
007AJ stores the resulting HTML under wp-content/cache/ajpc. It installs an advanced-cache.php drop-in, which WordPress can load early when WP_CACHE is enabled. An eligible cache hit serves the saved file before the normal rendering work proceeds.
PHP still handles this early request path. The improvement comes from avoiding much of the repeated work required to build a public page.
This is particularly relevant to time to first byte, or TTFB: the time before the browser receives the first byte of a response. As Google’s web.dev guidance on TTFB explains, slow server responses can also delay the start of rendering. A functioning page cache can shorten that wait when generating the page is the bottleneck.
It will not shrink an oversized photograph or make a heavy slider’s JavaScript execute faster. Those happen later, in the browser. That is why page caching and front-end optimization deserve separate measurements.
A cached page also has a lifetime. During that period, visitors can receive its saved HTML until the cache expires or is purged. Automatic clearing when content changes helps keep that copy current, but anything that personalizes the page must be excluded or handled carefully.
Read the setup check before enabling caching
The setup check is one of the strongest reasons to look closely at this plugin.
007AJ checks the WordPress and PHP versions, required writable locations, available disk space, existing cache configuration, detected hosting and other cache plugins. It also checks whether another plugin already owns advanced-cache.php.
A foreign page-cache drop-in blocks installation of its own. It does not silently replace the file. That matters because the early page-cache mechanism needs a clear owner.
If you already use WP Rocket, LiteSpeed Cache or a host-provided full-page cache, first establish what is currently serving your pages. Running another page cache alongside it can make purging and troubleshooting harder. You may have a reason to use selected optimization features, but switching ownership of the page cache should be deliberate.
The plugin also recognizes several managed hosting environments and holds back page caching until the administrator explicitly acknowledges the host-cache situation. Detection is a prompt to check your hosting configuration. It cannot determine every custom server rule or account-level cache setting.
There is a similar distinction with WP_CACHE. WordPress documents this constant as the switch that allows the advanced cache drop-in to load. Setting it to true by itself does not produce cached pages. If an existing configuration explicitly sets it to false, 007AJ asks for that conflict to be resolved rather than casually rewriting the existing setting.
On Apache and LiteSpeed, the plugin can add browser-caching and compression rules to .htaccess, with a backup before the edit. Nginx users receive a configuration snippet to apply through the server’s own configuration process. The plugin does not write Nginx server configuration.
None of this requires changing every setting on day one. It requires knowing which part of your existing setup already does the job.
How to set up 007AJ Performance and Caching
Start with a staging copy and a current backup. Pick a few pages you know well: the homepage, a content page, a page with a form and, for a shop, a product page and checkout. Capture how they behave before making changes.
Install the purchased ZIP through WordPress’s plugin upload screen and activate it. Activation does not automatically enable the performance features. Open the 007AJ Performance and Caching dashboard, read the Setup check, and resolve any blocking issues.
Then use Enable page cache.
That action installs the managed cache files and configuration changes, backing up configuration files before editing them. The plugin runs a self-check against your own site to check that it still responds and that a cached response can be obtained.
Leave the optional Optimize and Advanced speed features off for this first pass. Keep database cleanup, image bulk processing and object-cache installation for later. This gives you a useful baseline: any difference you observe comes primarily from the page cache and the associated configuration you enabled.
The self-check can be obstructed by basic authentication, a firewall or hosting restrictions on loopback requests. An unsuccessful check needs investigation; it does not, by itself, tell you which part of the setup failed.
Once public pages are working correctly and you can identify cache hits, move to the front-end options one at a time. Record each change. A short note such as “enabled JavaScript defer; tested menu and enquiry form on mobile” is much more useful during troubleshooting than a memory of ticking several boxes.
How to tell whether the page cache is working
Look at the response headers for the page document.
By default, 007AJ adds an X-AJPC-Cache header with a status such as MISS, HIT or BYPASS. A bypass can also include a reason.
Open a private browser window without logging into WordPress. In the browser’s developer tools, use the Network panel and inspect the main document request for an ordinary public URL. Request the same URL again.
An uncached eligible request may show MISS while the page is generated and saved. A subsequent eligible request should show HIT. The first request may already be a hit if another visitor or a preload job warmed the cache.
For a command-line check, use a normal GET request that prints the response headers:
curl -sS -D - -o /dev/null https://example.com/Replace the example address with a public URL on your site and run it again. Avoid curl -I for this test: it sends a HEAD request, and this plugin bypasses that request method.
If a CDN or host cache sits in front of WordPress, inspect its headers too. An upstream cache can return a previously stored X-AJPC-Cache value. That value then describes the response it saved, rather than proving that the current request reached 007AJ at the origin. Use your host’s documented cache-bypass or origin-testing method when you need to isolate the plugin.
Page source may look almost identical after page caching is enabled. That is expected. Saving HTML does not require minifying it or changing the theme’s markup.
The separate X-AJPC-Opt header describes optimization performed during a WordPress-generated response. It does not have to appear afresh on an early page-cache hit that serves previously saved HTML.
A bypass can be the correct result
A logged-in administrator should not receive the same cached response as an anonymous visitor. Form submissions, REST requests and AJAX requests also need their normal processing.
007AJ excludes requests based on method, cookies, URL and other conditions. Its WordPress-aware cache writer also skips contexts including search results, previews, password-protected content and WooCommerce cart, checkout and account pages.
Non-tracking query parameters normally cause a bypass. The default tracking exceptions include common campaign parameters such as utm_*, allowing those requests to use the underlying public page cache.
Keep that distinction intact. A parameter that changes language, currency, filtering or displayed content cannot be treated as harmless tracking merely to improve the hit rate.
If a page you expect to cache keeps bypassing, read the reason and check its cookies and URL. Testing while logged in, testing a search URL or carrying a shopping-session cookie can explain the result immediately.
Improve CSS and JavaScript without losing working pages
The Optimize screen offers minification, JavaScript defer, image and iframe lazy loading, and switches for some WordPress front-end assets. Safe and Balanced presets provide starting points, with an Undo option.
I would still review the switches the chosen preset enables. A preset cannot know that your enquiry form depends on a particular script running before a visitor clicks its submit button.
Minification produces smaller generated copies of CSS and JavaScript. Defer changes when eligible scripts execute. Lazy loading delays some media downloads until they are needed. Each changes a different part of the loading process, so a setting deserves a specific reason for being enabled.
The plugin writes generated assets into its own cache directory. It does not overwrite the original stylesheets and scripts supplied by your theme or other plugins. Exclusions let you leave a troublesome file or page out of an optimization.
After a change, test the site as a visitor. Open the mobile menu, submit a form, use a search box and interact with any slider, tab or modal. These are ordinary site behaviours that a speed report can miss.
The Advanced speed screen adds file combining, delayed JavaScript, unused CSS reduction, critical CSS and resource hints. These need more attention than basic page caching.
Combining files changes loading and caching behaviour. Compare the result on your actual site before treating fewer requests as a performance improvement.
Delayed JavaScript waits for an interaction or a configured timeout. That can suit a secondary widget. A payment field, consent control or above-the-fold component may need to initialize immediately. Add exclusions wherever waiting would impair the visitor’s task.
Critical CSS needs a visual check
Critical CSS is intended to provide the styles needed for the initial view while the full stylesheet loads afterward. Unused CSS reduction tries to leave unnecessary rules out of the generated stylesheet.
007AJ estimates these from the stylesheets and page markup. It does not render the page in a browser to determine exactly what appears in a particular viewport.
That limitation matters on sites where scripts add classes later, menus reveal hidden elements, or a form only displays error styling after submission. Review the “Always keep” rules and exclusions, and use the manual critical CSS override where appropriate.
Check several page types and screen sizes. A homepage that looks right at first load tells you little about a product variation selector or a mobile navigation panel.
For a temporary comparison, the plugin documents ?ajpc-off=1 as a way to bypass its optimization. Remember that this parameter can also alter the page-cache path, and an upstream cache may have its own behaviour. It is useful for diagnosis, but it is not automatically an equal cache-to-cache performance comparison.
Local image optimization and Google Fonts hosting
Large images are often a more visible problem than unminified code.
007AJ compresses JPEG and PNG files locally on your server and keeps copies of originals under wp-content/ajpc-backups/images/. The Media Library provides a restoration option; files edited after optimization are protected from being blindly overwritten during restoration.
Start with a small, representative selection. Check a photograph, a logo, an image with fine text and a product close-up. Compression that looks acceptable in a blog card may be unsuitable for the image a customer uses to inspect a product.
The plugin can generate WebP and AVIF copies where the server’s image capabilities support them. AVIF availability depends on the hosting setup. It checks whether generated copies are smaller before keeping them.
Creating a modern-format file and delivering it are separate steps. Inspect the browser’s Network panel to confirm which file the page actually receives. Existing browser or CDN caches may need clearing before a new format becomes visible.
Bulk processing runs in background batches through WP-Cron, with progress, pause and resume controls. Originals and generated copies consume disk space, while local processing consumes server resources. On a large library, use a quiet period and monitor capacity.
Lazy loading also deserves a selective approach. The main image visible at the top of a page should not be needlessly delayed, particularly when it is the page’s largest contentful element.
Local Google Fonts hosting is another optional feature. Your server downloads the font stylesheets and files already requested by the site and serves local copies once they are available. Background downloads mean the first page view after enabling it may still use the remote files.
Check font weights, italic variants and fallback behaviour after switching it on. This feature addresses those Google Fonts requests; other embeds and services on the page still need their own assessment.
Cache preloading and keeping published changes current
A cache helps most when the requested page is already available.
007AJ can preload public URLs from your sitemap and navigation menus. Its configurable pace runs from one to thirty pages per minute, with same-site requests and pauses when the server is busy.
The preload process depends on scheduled work. If your site disables normal WP-Cron, make sure a server-side cron process invokes WordPress’s scheduled tasks. That also affects image batches and any scheduled database maintenance you choose to enable.
Use a modest rate at first. Preloading is still asking your server to generate pages. A large run on limited hosting can compete with actual visitors.
Purging is the other half of the arrangement. The plugin clears relevant cached content when posts, comments and other supported data change, with additional handling for events such as WooCommerce stock updates. Administrators can purge all pages or the current page from the admin bar.
If another cache serves HTML outside WordPress, it needs to hear about the update too. Otherwise you can clear 007AJ’s copy and continue receiving an older copy from the host or CDN.
The plugin offers optional Cloudflare purging through your own scoped API token, plus integrations with selected hosting caches and server purge mechanisms. Configure only the integration that matches your setup and use its connection test where available.
CDN address rewriting serves a different purpose. It changes eligible asset URLs to the CDN hostname you enter. It does not purchase a CDN service, upload your files or guarantee that those new URLs work. Your CDN needs to retrieve the assets under the expected paths.
After a purge or CDN change, open a recently edited page as a visitor and verify the actual content and assets. The success message in the dashboard is only part of that check.
Using 007AJ with WooCommerce or a membership site
A shop contains both reusable public pages and private, changing sessions.
A product description can often be shared across anonymous visitors. A basket, account page or checkout carries information that must remain specific to the customer.
007AJ includes WooCommerce session-cookie exclusions and WordPress-aware checks for cart, checkout and account pages. Those are useful safeguards, but a shop with extra personalization still needs its own review.
Currency switchers, regional pricing, customer-specific discounts and location-dependent stock can change what appears on an otherwise public URL. Add appropriate exclusions or confirm how the existing application handles those differences before enabling broader caching.
Test with separate browser sessions. Add a product in one, open a fresh session in another, and confirm that their baskets and customer-specific details remain separate. Check stock changes, variation selection, discount application and a complete test purchase on staging.
For a membership site, the anonymous sales pages may benefit while logged-in member pages bypass the full-page cache. That behaviour is intentional. It also means a slow logged-in dashboard requires investigation into its own queries, plugins and scripts.
Page caching makes eligible public responses cheaper to serve. It does not make every personalized WordPress screen faster.
Safe mode: how to recover from a bad change
Recovery controls are a substantial part of this plugin’s appeal.
007AJ backs up wp-config.php and .htaccess before editing them. Its managed changes have identifiable markers. Safe mode turns off the performance features, removes its managed file changes and clears generated caches while retaining saved settings.
That makes it easier to return to a working configuration and then investigate a specific setting.
If wp-admin is inaccessible, the developer documents a file-based escape route: create an empty file named ajpc-safe-mode.flag inside wp-content, using your host’s file manager or SFTP. The plugin uses that flag to enforce Safe mode.
This is worth knowing before trying advanced optimizations. Save the path alongside your hosting details so you can reach it without relying on the WordPress dashboard.
Safe mode has defined limits. It does not restore database rows you deleted, and restoring compressed original images uses the image restoration controls. Removing 007AJ’s changes also does not clear every independent cache operated by your host or CDN.
The automatic setup checks and rollback mechanisms handle detected configuration failures. They cannot reliably discover every broken interaction in a theme or every third-party script. Keep your own backup and test the pages people use.
Database cleanup and object caching solve different problems
The Database screen can count candidate records before deleting selected categories, including revisions, auto-drafts, trashed content, spam, expired transients and orphaned metadata. Optional scheduling runs daily or weekly for the categories and age limits you choose.
Use the count preview to understand the proposed change. Old revisions may still have editorial value, and trashed content may be waiting for someone to restore it.
The plugin does not create a database backup for cleanup. Deleted rows cannot be undone through Safe mode. Take a recoverable database backup first and choose a narrow scope.
A smaller database is not automatically a faster website. Removing old revisions will not repair a plugin that runs an expensive query on every request. Cleanup is maintenance; measure a performance problem separately.
Persistent object caching can be more relevant when repeated database work is the bottleneck. The Object cache screen supports an existing Redis or Memcached server and installs an object-cache.php drop-in after a connection test.
It does not install either server for you. Your host must provide the service, and the connection should use the host’s recommended configuration.
Replacing an existing object-cache drop-in requires explicit confirmation, with a backup retained. If the configured cache server becomes unavailable, the drop-in can fall back to caching within the current request. That fallback preserves operation, although an initial connection timeout can still add delay.
Choose one owner for the persistent object-cache drop-in. Page caching and object caching can coexist because they store different things, but installing multiple competing implementations for the same drop-in creates avoidable confusion.
Measure speed, Core Web Vitals and working behaviour
Record a baseline before enabling features, then test the same pages under comparable conditions. Keep device type, connection and cache state consistent enough to make the comparison meaningful.
For page caching, inspect eligible hits and TTFB. For image and CSS changes, watch the visible loading process and Largest Contentful Paint. For script changes, exercise the controls people actually use and check responsiveness. Watch for layout shifts as fonts and delayed assets arrive.
Google’s Core Web Vitals documentation identifies good thresholds as LCP within 2.5 seconds, INP within 200 milliseconds and CLS at or below 0.1. These metrics describe different aspects of the visit, so a fast server response alone does not establish good results across all three.
007AJ’s optional Web Vitals sampling can give you an indication of visitor experience. It sends timing values and viewport width to your own site, storing daily aggregate counts for 90 days rather than individual page URLs or visitor identifiers.
The implementation reports the longest observed interaction as an approximation and estimates results from grouped values. Its site-wide dashboard is useful for spotting a trend, but it should not be presented as an authoritative per-page INP report or as Google’s field dataset.
Use browser tools and PageSpeed Insights for targeted diagnosis, and Search Console’s Core Web Vitals reporting where sufficient field data exists. Most importantly, keep checking that the faster version lets visitors finish their task.
There is a real SEO reason to improve performance. Google includes Core Web Vitals in its ranking systems, while also explaining that good scores do not guarantee top rankings. A caching plugin supports the experience of your content; it cannot replace the content’s relevance or usefulness.
Price, licence and who should consider it
As checked on October 7, 2026, the WPBay product page lists a $59.95 lifetime plan for one site, with taxes excluded.
That one-site limit matters for agencies budgeting for several clients. Read the current purchase terms before buying, particularly if you need multiple installations or have specific expectations about support.
The seller, 007AJ.com, handles product-related support through WPBay’s ticket system. The listing covers questions and reported issues; custom development and installation services are outside the stated support scope.
007AJ is a reasonable product to shortlist when you want a page cache with visible diagnostics, configuration checks and a recovery mechanism, together with optional optimization tools you can enable gradually. Local image processing may also appeal if you want to avoid sending media to an external compression service.
A site already well served by its host’s cache has a different decision to make. Identify a remaining problem first, then decide whether the plugin’s image, asset or maintenance features address it without overlapping the existing setup.
Multisite operators need another solution. A business buying primarily to fix an expensive custom database query should investigate that query before purchasing a broad performance plugin.
For the right single-site setup, the appeal is the combination of useful tools and control over how they are introduced. You can begin with a public-page cache and add more only when your measurements justify it.
Questions before you buy
Does 007AJ enable caching as soon as it is activated?
No. You activate the plugin, read the Setup check and then explicitly enable page caching. Optional optimization modules also need to be enabled. This gives you an opportunity to inspect existing hosting and cache arrangements before making performance changes.
Why does my logged-in visit show BYPASS?
Logged-in requests are deliberately excluded from the full-page cache. Test an ordinary public URL in a private browser session. Shopping-session cookies, functional query parameters and other exclusions can also produce a legitimate bypass.
Can it work on Nginx?
The PHP-based page-cache drop-in can operate without Apache rules. The plugin provides snippets for server features that need Nginx configuration rather than writing that configuration itself. Apply those through your host or server administrator and verify the result.
Does image optimization require an external paid service?
Compression runs locally. WebP and AVIF generation depend on your server’s capabilities, and backups require disk space. There is no need to send images to an external image-compression API for the included local processing.
Will Safe mode undo database cleanup?
No. Database cleanup deletes selected records, and the plugin does not create a database backup for that operation. Safe mode disables performance features and removes managed changes; deleted database content needs restoration from your own backup.
Can I use it together with Safe Speed Cache?
The developer states that the two editions cannot be active together. They share settings, so you should use one edition at a time. More generally, check who owns your existing page-cache and object-cache drop-ins before introducing another implementation.
The first step
Start with the page cache, prove that eligible public requests are hitting it, and check that important pages still work. Then tackle the largest remaining problem, whether that is an oversized image, blocking CSS or a script that makes the mobile menu slow.
That approach suits 007AJ Performance and Caching well. Its recovery controls make experimentation easier, while the separate switches let you keep changes you can explain and measure.
You can see the current plan on the 007AJ Performance and Caching listing at WPBay and consult the official setup documentation before installation.
