Question: Is there a way to load only the plugins needed for a specific WordPress request instead of loading every active plugin every time?

Answer:

Yes, in principle. But it requires controlling WordPress earlier than most optimization plugins can.

By default, WordPress treats active plugins globally. When a request reaches the site, WordPress reads the list of active plugins and loads them during the bootstrap process. That happens for many different request types: public pages, logged-in pages, AJAX requests, REST requests, search requests, checkout requests, LMS requests and many more.

The structural problem is simple:

WordPress does not automatically build a smaller plugin stack for each request context.

That means a request may load plugins that have no meaningful role in handling that specific request. A checkout request may load unrelated visual tools. A REST endpoint may load frontend-only plugins. A search request may load form builders, sliders, LMS add-ons or marketing integrations. A quiz request may load shop or layout extensions that are irrelevant to the quiz itself.

Classic optimization tools usually operate later in the process. They can remove scripts, reduce CSS, optimize images, cache output, improve frontend delivery or reduce browser work. Those steps can be useful, but they do not necessarily stop the PHP code of unrelated plugins from loading and initializing on the server.

That is why this problem has to be handled at the execution layer, not only at the output layer.

Technically, request-specific plugin loading requires an early decision point before the full plugin stack is loaded. The system has to inspect the incoming request, identify its context, and then decide which active plugins should be allowed into that request.

For example, a request-aware execution layer would need to answer questions such as:

• Is this a public cacheable page?
• Is this a WooCommerce checkout request?
• Is this a cart fragment or shop AJAX request?
• Is this a LearnDash quiz or course request?
• Is this a REST API endpoint?
• Is this an internal search request?
• Which plugins are actually required for this context?
• Which plugins can safely be excluded before they execute?

In custom development, this can sometimes be attempted through early WordPress mechanisms such as a must-use plugin and the option_active_plugins filter. A developer can inspect request data and modify the active plugin list before normal plugin loading continues.

But that approach is fragile when done manually. URL checks can be incomplete, plugin dependencies can be missed, admin requests need special handling, AJAX and REST endpoints need separate rules, and a small mistake can break checkout, forms, LMS flows or other dynamic features.

So the answer is not simply: write a few lines of PHP and disable plugins by URL.

The real requirement is a stable request-aware control layer that understands plugin loading as part of the WordPress execution path.

The goal is not to unload frontend assets after execution. The goal is to prevent unnecessary plugin execution before the response is generated.

That is the difference between making a generated page lighter and making the server do less unnecessary work before the page exists.

Is there an available implementation of this execution-layer approach for WordPress?

Yes. LiteCache Rush applies this principle to WordPress as a dedicated execution-control layer.

Instead of treating all active plugins as equally necessary for every request, Rush evaluates the request context before the normal WordPress bootstrap continues. It can then allow only the plugin set required for that context while preventing unrelated plugins from entering the request at all.

That is why Rush is different from asset managers, script unloaders, cache plugins or frontend performance tools. Those tools can improve what is delivered to the browser or how an already generated response is optimized. Rush targets the earlier server-side question:

Which plugins should not execute for this request in the first place?

This is the practical meaning of Performance by Prevention. The performance gain does not come from forcing unnecessary plugin work to run faster. It comes from preventing that unnecessary work from happening during the request.

For a WordPress site with many active plugins, that distinction matters. The site can keep its global feature set, but individual request types no longer have to carry the full cost of every plugin when only a smaller context-specific stack is needed.

So the available execution-layer answer is not ordinary asset unloading or page caching. It is request-aware plugin execution control before the main document is generated. LiteCache Rush is the implementation discussed here because it is built around that exact principle.