Optimising Drupal views and forms with Caching

Performance is often the difference between a Drupal site that users trust and one they abandon. Caching is not just a performance enhancer, it’s a core part of creating fast, reliable digital experiences. When used correctly, Drupal’s caching strategies can significantly lower page load times, reduce server strain, and improve the overall responsiveness of a site.

Real-world examples show the impact clearly. One e-commerce platform reduced page load times by 65% and server load by almost 70% after fine-tuning its caching layers. A large educational portal managing thousands of daily visitors improved homepage render times by more than 50% by configuring views and page caching strategically. These improvements didn’t just make the sites faster, they also supported higher engagement, better user retention, and lower hosting costs.

In this blog, we’ll cover the full range of Drupal caching techniques, from internal page caching to dynamic page caching, views caching, and form caching. Along with technical explanations, you’ll find real examples, common pitfalls to avoid, and direct links to Drupal’s official documentation for deeper reference. 

The goal: helping you master caching, so your site feels faster, scales smarter, and stays responsive no matter how much traffic you handle.

Views Caching strategies

In-depth explanation

Drupal Views is a powerful tool that lets you create dynamic lists and pages from your content. However, every time a view is executed, Drupal queries the database and rebuilds the view. An operation that can be heavy under load.

Let’s explore the different caching strategies available:
‍

• No Caching:
  The default behaviour is to re-render everything on each request. This provides the most current data but can be very resource-intensive during high traffic.
  Documentation:
  Drupal Views Overview

• Time-based Caching:
  This method caches the view’s data for a set time period (for example, 1 hour). After the cache expires, Drupal regenerates it. It works well for content that doesn’t change continuously.
  Documentation:
  Drupal Cache API Overview

• Contextual Caching:
  Drupal can store different cache variants based on contextual factors like user roles, languages, or URL parameters. The default views plugins typically handle this out of the box, so you don’t need custom code unless your project has very specific requirements.
  Documentation:
  Cache Contexts

• Tag-based Caching:
  With tag-based caching, cached items are associated with one or more tags. When content corresponding to a tag is updated, Drupal clears only the relevant caches. This precise invalidation helps keep data fresh while reducing unnecessary cache clears.
  Documentation:
  Using Cache Tags in Drupal

Practical use case: views Caching strategies

The scenario

Imagine managing a high-traffic news website. The “Latest Articles” view is accessed by thousands of users every day. Without caching, each page load forces Drupal to rebuild the list of articles, placing a heavy load on your server.

The goal

Combine time-based caching (to re-cache periodically) with tag-based caching (to immediately clear the cache when an article is updated). This ensures your users receive fast, up-to-date content.

Sample implementation
‍

/**
  * Implements hook_views_pre_build().
  *
  * This function configures the "latest_articles_view" with a hybrid caching strategy.
  * It caches the view for 1 hour but invalidates the cache immediately if articles change.
  */
 function mymodule_views_pre_build($view) {
   if ($view->id() === 'latest_articles_view') {
     $view->setCache([
       'type' => ['time', 'tag'],  // Combining time-based and tag-based caching.
       'max_age' => 3600,          // Cache duration: 1 hour.
       'contexts' => [
         'languages',             // Maintain separate caches per language.
         'user.permissions',      // Different cache variants if permissions affect visibility.
       ],
       'tags' => [
         'article_list',          // Invalidate cache when articles are updated.
       ],
     ]);
   }
 }

‍

Explanation: This example demonstrates how to customize caching for the “latest_articles_view” to achieve fast response times while keeping the content fresh when articles are updated.

Query result Caching

In-depth explanation

Query result caching stores the raw output of database queries rather than the fully rendered view. This approach targets the most resource-intensive part of data retrieval.

• Performance gains:
  By caching raw query results, you can drastically reduce the need to rerun complex SQL queries on every page load.
• Resource optimisation:
  This approach reduces the load on your database, freeing up resources for other critical operations.
• Configurable lifespans:
  Like time-based view caching, you can set the lifespan for cached query results based on your update frequency.

Practical use case: Query result Caching

The scenario

Consider an online store with a “Products” view that executes heavy SQL queries involving multiple table joins. Constantly executing these queries for every request can significantly strain your database server.

The goal

Cache the raw SQL query results for a duration (e.g., 1 hour) so that repeated requests retrieve results from the cache rather than re-running the query, unless a product update occurs.

Sample implementation
‍

/**
  * Implements hook_views_pre_build().
  *
  * This snippet sets a caching strategy for the "my_product_view" to store raw query results.
  * It reduces the need for repeated heavy queries, caching results for 1 hour.
  */
 function mymodule_views_pre_build($view) {
   if ($view->id() === 'my_product_view') {
     $view->setCache([
       'type' => ['time', 'tag'],  // Utilize both time and tag-based caching.
       'max_age' => 3600,          // Cache lifespan: 1 hour.
       'contexts' => [
         'languages',
         'user.permissions',
       ],
       'tags' => [
         'node_list',
         'product_list'           // Invalidate cache when product data updates.
       ],
     ]);
   }
 }

‍

Explanation: By caching the raw output of heavy queries for “my_product_view,” the system minimises redundant database operations. Tag-based invalidation ensures that when product details change, the cache is promptly refreshed.

Rendered output Caching

In-depth explanation

Rendered output caching takes the efficiency a step further by storing the complete HTML output generated by a view. This helps to bypass the resource-intensive rendering process on subsequent requests.

• Efficient delivery:
  Serving pre-rendered HTML dramatically reduces page load times since Drupal avoids reprocessing the view.
• User role variations:
  With appropriate cache contexts (e.g., user roles), different user groups receive the correct version of the content from the cache.
• Managing complexity:
  For pages where the overall layout does not change frequently, even if the underlying data does, rendered output caching significantly boosts performance.

Documentation:
More details can be found in the Drupal Render API Documentation.

Practical use case: rendered output Caching

The scenario

Think of a product catalogue page where the layout is largely static despite occasional data updates. Re-rendering this static layout for every user can be inefficient.

The goal

Cache the fully rendered HTML output for 1 hour, creating variations based on user roles if needed, to serve pages swiftly without sacrificing dynamic content accuracy.

Sample implementation
‍

/**
  * Implements hook_views_post_render().
  *
  * This function embeds caching metadata into the final rendered output.
  * The view’s complete HTML is then cached for 1 hour, and cache variants are created based on user roles.
  */
 function mymodule_views_post_render($view, &$output) {
   $output['#cache'] = [
     'max-age' => 3600,            // Cache for 1 hour.
     'contexts' => ['user.roles'], // Separate caches for different user roles.
     'tags' => ['content_list'],   // Invalidate cache when content updates.
   ];
 }

‍

Explanation: This configuration ensures that once the view renders its HTML, that version is cached for quick reuse, reducing the need to run the rendering pipeline on every page load.

Form Caching considerations

In-depth explanation

Forms in Drupal are dynamic interfaces that include user input, interactive elements, and security tokens (such as CSRF tokens). Caching forms is challenging because:

• State and security:
  Caching entire forms might lead to accidental data exposure if not properly isolated. Only static elements such as layout or instructional text should be cached.
• Fragment Caching:
  It’s possible to cache parts of a form that remain constant, while ensuring dynamic, sensitive portions are always freshly rendered.
• Context-specific Caching:
  By applying cache contexts (e.g., based on user identity or URL path), you ensure that cached fragments are unique to each user, preventing data mix-ups.

Documentation:
Refer to the Drupal Forms API documentation for details on managing form rendering and state.

Practical use case: dynamic form Caching

The scenario

Imagine an e-commerce checkout form. It contains static elements like step-by-step guidance and dynamic elements like personalized promotions and shipping fields. You want to cache the static pieces for speed, but always render the dynamic sections in real time.

The goal

Implement a caching configuration that applies to the non-sensitive parts of the form, using precise cache contexts to isolate user-specific data.

Sample implementation
‍

/**
  * Implements hook_form_alter().
  *
  * This function applies caching directives to "my_dynamic_form".
  * It ensures that while static form fragments may be cached, dynamic elements are always rendered freshly.
  */
 function mymodule_form_alter(&$form, &$form_state, $form_id) {
   if ($form_id === 'my_dynamic_form') {
     $form['#cache'] = [
       'contexts' => [
         'user',        // Unique cache per user.
         'user.roles',  // Tailor cache entries for different roles.
         'url.path',    // Sensitive to the current page URL.
       ],
       'tags' => ['user:' . \Drupal::currentUser()->id()], // Unique user-specific tag.
     ];
   }
 }

‍

Explanation: This snippet shows how to safely cache parts of a dynamic form. The use of fine-grained cache contexts ensures that cached fragments are correctly isolated per user, thus enhancing speed without compromising security.

Contextual filters and Caching

In-depth explanation

Contextual filters allow you to tailor the output of your views using dynamic parameters (such as URL segments or user inputs). These filters benefit from caching just like any other view component. Fortunately, the default views plugins in Drupal already handle caching for contextual filters.

• Default handling:
  By default, caching for contextual filters is managed internally by Drupal’s Views module. This means you typically don’t need to write custom code to handle caching for these filters.
• When customisation is needed:
  Custom caching for contextual filters might only be necessary if your project has very specific requirements or if you’re altering the default behaviour with a custom plugin. For most sites, the built-in solution is robust and reliable.

Note: Since the default caching for contextual filters is already handled by the Views module, there is usually no need to add extra code unless you are developing a custom filter plugin with specialised caching needs.

Security implications

In-depth explanation

While caching dramatically boosts performance, it’s crucial to ensure that it doesn’t compromise your site’s security. Consider the following points:

• Sensitive data exposure:
  When caching personalized content, detailed cache contexts (like user and user roles) keep each user’s data isolated.
• CSRF tokens and session data:
  Always render tokens and other sensitive dynamic elements fresh, and never cache them.
• Granular invalidation:
  Utilise cache tags to ensure that when a piece of sensitive content is updated, only the affected caches are cleared. This precision protects both performance and data integrity.

Documentation:
Visit Drupal Security Best Practices for comprehensive guidance.

Implementation examples and practical use cases

Let’s consolidate our knowledge with real-world examples and sample code.

Example 1: Optimising a complex product view

Practical use case

Imagine an e-commerce store where the product catalogue is viewed frequently by anonymous users. The heavy lifting of assembling product details can slow down the site if not optimised. By caching both raw query results and rendered output, you ensure the catalogue loads quickly under heavy traffic.

Sample implementation
‍

/**
  * Implements hook_views_default_views_alter().
  *
  * This configuration sets a tag-based caching strategy for the "product_catalog" view.
  * It caches both the raw query results and the rendered HTML for 1 hour.
  */
 function mymodule_views_default_views_alter(&$views) {
   if (isset($views['product_catalog'])) {
     $view = $views['product_catalog'];
    
     $view->display['default']->display_options['cache'] = [
       'type' => 'tag',
       'options' => [
         'results_lifespan' => '3600',   // Cache the query results for 1 hour.
         'output_lifespan' => '3600',    // Cache the rendered output for 1 hour.
         'output_tag' => 'product_list', // Invalidate cache when product data is updated.
       ],
     ];
   }
 }

‍

Explanation: This sample demonstrates how a custom caching configuration improves performance for the product catalog by reducing repeated heavy queries and re-rendering, while ensuring that changes in product data clear the cache appropriately.

Example 2: Caching a dynamic form with user-specific data

Practical use Case

A dynamic form like a checkout or profile update contains both static guidance (which benefits from caching) and dynamic, user-specific sections (which need to be rendered fresh). By applying caching only to the non-sensitive parts, you can improve speed without risking data leaks.

Sample implementation
‍

/**
  * Implements hook_form_alter().
  *
  * This function applies caching directives to the "my_dynamic_form",
  * ensuring that while static elements are cached, dynamic content remains secure and fresh.
  */
 function mymodule_form_alter(&$form, &$form_state, $form_id) {
   if ($form_id === 'my_dynamic_form') {
     $form['#cache'] = [
       'contexts' => [
         'user',        // Unique cache per user.
         'user.roles',  // Tailored cache for different user roles.
         'url.path',    // Sensitive to the current page URL.
       ],
       'tags' => ['user:' . \Drupal::currentUser()->id()], // Unique cache tag per user session.
     ];
   }
 }

‍

Explanation: This code safely applies caching to non-dynamic elements of a form, ensuring that overall load times are improved while personal and sensitive parts are always freshly rendered.

Summary and next steps

We’ve delved into advanced caching techniques for Drupal views and forms, covering:

• Views Caching strategies:
  Detailed options, including time-based, contextual, and tag-based caching, and why the built-in defaults are often sufficient.
• Query result Caching:
  How caching raw database outputs reduces server load significantly.
• Rendered output Caching:
  Storing pre-rendered HTML for ultra-fast response times.
• Form Caching considerations:
  Balancing performance gains with the need to protect sensitive user data.
• Contextual filters:
  Recognising that default plugins already handle caching here, unless custom behaviour is required.
• Security implications:
  Ensuring a secure caching strategy through granular contexts and targeted invalidation.

Next steps

1. Evaluate your site:
   Identify which views and forms offer the best caching opportunities.
2. Test and deploy:
   Implement these caching strategies in a staging environment and use Drupal’s debugging tools (like the Devel module) to monitor performance.
3. Monitor and adjust:
   Continuously refine cache lifespans, contexts, and tags based on real-world usage and data updates.
4. Explore further:
   For more on Drupal caching best practices, review the following resources:

• Drupal Cache API Documentation
• Drupal Views Module Documentation
• Drupal Render API Documentation
• Drupal Security Best Practices

Series navigation

This article is part of our comprehensive 10-part series on Drupal caching:

1. Introduction to Drupal Caching
2. Understanding Drupal’s Cache API
3. Choosing the Right Cache Backend for Your Drupal Site
4. Mastering Page and Block Caching in Drupal
5. Optimising Drupal Views and Forms with Caching (You are here)
6. Entity and Render Caching for Drupal Performance (Coming soon)
7. Building Custom Caching Services in Drupal (Coming soon)
8. Implementing Custom Cache Bins for Specialised Needs (Coming soon)
9. Advanced Drupal Cache Techniques (Coming soon)‍
10. Drupal Caching Best Practices and Performance Monitoring (Coming soon)

Conclusion

Optimising Drupal views and forms with intelligent caching isn’t just a technical exercise, it’s a necessary step toward building fast, scalable, and resilient digital experiences. By applying a combination of time-based, tag-based, and contextual caching strategies, you can significantly reduce server load, improve response times, and deliver consistently reliable performance, even under high traffic.

The key is understanding the different layers of caching available, query result caching, rendered output caching, and selective form caching, and applying them thoughtfully based on the specific needs of each component. Balancing speed with security, especially when dealing with user-specific data, ensures that caching improvements don’t come at the cost of data integrity.

Mastery of these techniques transforms your Drupal site into a platform that not only handles today’s demands but remains agile enough for future growth. As caching strategies evolve, continuing to monitor, refine, and adapt your configurations will keep your site operating at its best.

In the next parts of this series, we’ll explore even more advanced caching methods, including entity caching, custom caching services, and performance monitoring best practices, helping you move from basic optimization to a truly high-performance Drupal architecture.

‍