Quick Summary:

Boost your Ruby on Rails application performance with Rails caching. By leveraging Rails cache, you can acquire faster response time, minimum database load, and happier users. Let’s find out more in this tutorial guide.

Table of Contents


Do you know a 1-second delay in page load time can result in a 16% decrease in customer satisfaction?

Are you looking for the fastest way to respond to the users through your application?

Then try Rails caching. It is the ultimate solution for performance improvement and seamless user experience. This technique allows storing or using previously generated data to enhance performance.

You can effectively optimize your application and improve backend operations by leveraging cache. Let’s unlock its potential by understanding why to use rails caching, discussing different types of rails cache, how to implement using various cache stores, how to clear it, and real-life examples of caching.

Why Use Rails Caching?

Rails caching offers numerous benefits to improve the performance and scalability of applications. The following reasons why Rails cache is a valuable technique for optimizing applications:

Ruby on Rails and optimization

Boost Responding Process

Rails caching enhances response time by storing data and serving pre-rendering content. It reduces the use of redundant data and complex calculations. Also, it ensures that the response is directly served to the user, which leads to a boost in the loading page, a seamless user experience, and application performance.

Increase Application Capabilities

Using Rails caching increases the capabilities of your Ruby on Rails application by optimizing its performance and handling large workloads. Also, by fetching essential data with a cache, your application can serve more responses rapidly and efficiently, improving user interaction.

Cost Optimization

Implementing a Rails cache can significantly save costs for your RoR application. With optimized resources, you eliminate irrelevant databases and emphasize necessary resources. Also, it reduces the number of servers and hosting that slow down the application performance. With minimum resources, you can reduce operational costs.

Less Dependency On Third-Party API

Cache decreases the dependency on external API by storing data locally or their response. With API response, you can minimize the number of requests to external services, which reduces the chances of failure.

Enhance Backend Performance

One of the significant advantages of rail caching is seamless backend performance. You can decrease the backend workload by accessing data and caching computationally operations. As a result, it ensures an intuitive user experience, a faster loading process, and better scalability.

Different Types of Rails Cache

Here are the various types of Rails caching mechanisms that optimize application performance efficiently and promptly.

Page Caching

Page caching is a technique that allows generated pages to go directly to subsequent requests without processing through the entire Rails process. Apache and NGNIX are the web server that fulfilled the process.

However, being rapid, it cannot be implemented everywhere, including pages that need authentication files, which directly serve the filesystem. Also, we cannot use page caching if we have any authentication for that page or sensitive data.

We can use page caching like this:

Copy Text
class PostsController < ApplicationController
  Caches page: index

Earlier, it was included in the Rails gem. But, after Rails 4, we used the action pack-page_caching gem to implement page caching.

Page expiration and cache invalidation are critical to managing page caching in Ruby on Rails. While caching improves performance, it’s crucial to ensure that cached pages remain up-to-date and show the latest data.

Cache expiration determines how long a cached page remains valid before it needs to be refreshed. The expiration time depends on the nature of the content and how frequently it changes.

Rails allow us to define the expiration time for cached pages. We can set a global expiration time in the `config/environments/production.rb` file or specify individual expiration times for specific actions using the expires_in method following:

Copy Text
class PostsController < ApplicationController
  Caches page :index, expires in: 1.hour

Action Caching

Similar to page action, action caching eliminates the core issues faced in page caching. In page caching before_filter like, authentication is not executed because the page cache sends data from the web server.

In action cache, before_filter runs so we can authenticate the user or request. The request reaches the Rails stack in action caching, so all validation and authentication execute when required.

Action caching Rails helps in caching the result of controller actions like index and show.

Here is an example of it:

Copy Text
class ListsController < ApplicationController
  before_action :authenticate, except: :public

  caches_action :index, :show, expires_in: 1.hour

  def index

  def show

Low-level Caching

We can use low level caching in Rails using Rails.cache.fetch.

The code:

Copy Text
def index
  @products = Rails.cache.fetch("products_list") do

Here’s how Rails.cache.fetch works:

  • First, identify the cache data uniquely and take a cache key(here ‘products_list’). It verifies if the data corresponding to the cache exists in the present cache.
  • If the data is found in the specific cache, `Rails.cache.fetch` returns the cached data simultaneously.
  • If the data is unavailable in the cache, then `Rails.cache.fetch` executes the block of code provided as the second step.
  • Later, the result of the block is stored in the cache along with the particular cache key.
  • The result is also returned by `Rails.cache.fetch`, allowing you to use the computed data in your application.

So, low-level caching allows us to cache specific code blocks or data, giving us more control over the caching process. It’s beneficial for Rails to cache small data frequently reused, such as database queries or expensive computations.

Revolutionize Your Application Optimization In Seconds
Hire Ruby on Rails Developer that sets a new standard of excellence in optimization.

Advance Rails Caching Techniques

To enhance your application performance with unique features, you can use these advanced Rails caching techniques:

Fragment Caching

Fragment caching is used for caching a specific page part. We can cache a specific page block and reuse it across multiple requests.

For instance, we have a blog app with a sidebar that displays a list of recent posts. This list is fetched from the database and rendered as HTML. However, fetching and rendering this list on every request can take time and slow down the application.

To optimize this, we can implement fragment caching. The first step is identifying the part of the view we want to cache in the application. In our case, it’s the recent posts list in the sidebar.

Following is the code we can use:

Copy Text
<% cache "recent_posts_sidebar" do %>
  <!-- Code to render the recent posts list -->
  <!-- Code to render the recent posts list -->
  <!-- Code to render the recent posts list -->
<% end %>

In our Rails view file, we can wrap code for recent posts with a cache helper method: The cache method takes a unique key, identifying the cached fragment. In our example, the key is “recent_posts_sidebar”.

When a user visits the page for the first time, Rails will render the recent posts list, store it in the cache, and send it to the user.

On subsequent requests, Rails will retrieve cached versions instead of re-rendering lists, which helps in faster page load times.

To invalidate the cache and regenerate fragments, we can use the expire_fragment method at appropriate times, such as when a new blog post is created:

Here is the code to implement:

Copy Text
def create
  # Code to create a new blog post
  # Code to create a new blog post
  # Code to create a new blog post


In this example, when a new blog post is created, the expire_fragment method is called with the same key we used for Rails caching. It removes the cached fragment from the cache store, ensuring subsequent requests re-render and cache the updated list.

Russian Doll Caching

Russian Doll caching in Ruby on Rails allows us to cache nested or hierarchical fragments of view. It enables us to cache individual components and its dependencies hierarchically, resembling the layers of a Russian nesting doll.

For instance, we have a blog application with models: Post and Comment. Each Post has many Comments. The purpose is to display a list of posts with relatable comments. However, rendering the list can be time-consuming if we fetch and render all the associated comments for each post on every request.

Additionally, in our view file, we can wrap the code that renders the list of posts and its associated comments with the cache helper method.

Following is the code:

Copy Text
<% cache "posts_with_comments" do %>
  <% @posts.each do |post| %>
    <% cache “post” do %>
      <!-- Code to render the post -->
      <!-- Code to render the post -->
      <!-- Code to render the post -->
      <% post.comments.each do |comment| %>
        <% cache “comment” do %>
          <!-- Code to render the comment -->
          <!-- Code to render the comment -->
          <!-- Code to render the comment -->
        <% end %>
      <% end %>
    <% end %>
  <% end %>
<% end %>

In the above example, we use two levels of Rails caching. Outer cache block with the key “posts_with_comments” caches the entire list of posts and their comments. Inner cache block with a “post” object as the key caches every individual post, and a nested inner cache block with a “comment” object as the key caches each individual comment.

When a user visits a page for the first time, Rails will render a list of posts and comments, store the fragments in the cache, and send it to the user. On later requests, Rails retrieves the cached fragments instead of re-rendering them, resulting in faster page load times.

To invalidate the cache and regenerate fragments, we can use the expire_fragment method at appropriate times, such as when a new comment is added to the database.

Here is the code:

Copy Text
def create
  # Code to create a new comment
  # Code to create a new comment
  # Code to create a new comment

  @post = Post.find(params[:post_id])

In the above example, when creating a new comment, we find its associated post and call the expire_fragment method with the “post” object as an argument. It will remove cached fragments related to that post from the cache, ensuring that the subsequent request will re-render and cache the updated fragments.

How to Implement Various Caching By Using Different Cache Stores?

To implement numerous caching in Rails, you must configure your application with a specific cache store and mechanisms. Here are the multiple methods to leverage in your RoR application.

How to Implement Caching Using Rails File-Cache Store

The file is one of the most used Rails cache stores and can be implemented by running code to development. rb in file_store.


Copy Text
config.cache_store = :file_store, "/path/to/file/whereYouWantToStoreCache"

The file store turns default when no cache store is configured. Also, it writes entries to the file system only. The valuable part is that you do not have to specify cache or file store; the data will be stored in the tmp/cache directory in the application’s root.

Copy Text
config.cache_store = :file_store

Cache files are saved to disk space and will not be removed automatically. As a result, we must ensure that it does not fill our disk space. It can be done using `Rails.cache.cleanup`.

How to Implement Caching Using Memory Store

Rails 5 has defaulted cache store, and that is memory_store. It is in the development environment while we create a new app. Also, it is unsuitable for microservices.

It will store cached data in the Ruby web server’s memory. Thus, no need to clear the cache. Because whenever our development web server restarts, it will clear all cache data.

The default:memory_store size is 32MB. But we can reverse it by passing:size option.

We can add this code to development.rb if we want to store cache for a development environment in memory_store.

Copy Text
config.cache_store = :memory_store, { size: 16.megabytes }

When the cache is accessed and data occupies the total size, the recently used cache entries will automatically be removed from the memory_store to make space for new data.

We can also use memory_store in production, which is the easiest way. But, we can not use it if our application runs multiple server processes. Because all server processes can not access each other’s cache, and all the processes manage their copy of the cache.

How to Implement Caching Using Mem Cache Store

The:mem_cache_store uses Dalli gem(https://github.com/petergoldstein/dalli) and Memcached(https://www.memcached.org/) to store cache. It will store data in a different process than the Ruby servers. That’s why cached data is not removed when our application server restarts.

When this mem_cache_store server is restarted, all cache is removed. If we do not pass any address to use the remote server, it is assumed that the cache server is running on localhost.

Copy Text
config.cache_store = :mem_cache_store, "cache-1.example.com", "cache-2.example.com"

Default, it will use a maximum of 64MB cache store size. But we can configure it to use less or more size for storing cache data.

It is easy to use when our application server runs multiple processes or servers. We can share cached data between multiple processes, servers, or hosts using a remote server.

How to Implement Caching Using Redis Cache Store

Redis was introduced in Rails 5.2. It allows us to store cache similar to the Memcache store.

Copy Text
Config.cache_store = :redis_cache_store, {
        url: ENV.fetch('REDIS_URL') { 'redis://localhost:6379/1' },
        size: 64.megabytes

Redis periodically stores cached data in a disk. Thus, whenever the cache server restarts, the cache data are safe and not removed automatically.

We can also pass a remote server for the Redis store to centralize our cache.

It also takes size parameters as configuration. So, we can modify our storage size as per the requirement.

Which Rails Store to Use?

Memory and file are preferable for smaller applications and development use. On the other hand, Memcached and Redis are ideal choices for production servers.

Because both Redis and Memcached stores can handle larger app cache, both allow us to use centralized cache_store. So, it is useful when our application runs multiple servers or processes.

Seeking an RoR company with innovation and reliability?
Your search ends here! Get in touch with the best RoR development company for secure and dynamic solutions.

How to Clear Rails Cache?

There are multiple methods to Rails clear cache; let’s look at it through the different approaches:

Manual Clear

You can clear the cache by performing it manually. Rails cache stores a cache by default in the directory, and you need to select a particular cache or section to clear it.

Command Line

Clear your Rails caching by running the command line- Rails.cache.clear. It will clear your cache irrespective of the system and cache store you used for optimization. It is helpful for all types of Rails stores.

Automated Cache Clearing

You can clear the specific cache using an automated process. For instance, the automation system will configure your process whenever there are changes or updates in the data. The automated cache helps you to stay updated.

Rails Cache Use Cases

Here are real-life examples of using Rails cache on your applications. Here are the success stories of using Rails caching:

Rails Cache Use Cases


The code collaboration website used page caching for caching public repository pages. Using cache, GitHub can provide a responsive user interface and seamless experience to numerous users globally.


A vacation rental application used fragment caching to fetch components. By leveraging cache, Airbnb can provide better search results, property listing, and a seamless process for generating user profiles.


The online music streaming service uses fragment caching to optimize components. With the components, SoundCloud augments responsiveness by delivering excellent track listings, streamlining the process of making playlists, and a vast search list.


An e-commerce platform that uses page caching, low-level caching, and fragment caching to improve website performance. Using caches, Shopify renders faster results for the search list, shopping cart, and product description.


No need to settle for average performance when you have a Rails caching that provides unparalleled efficiency for your Ruby on Rails application. Relevant caching techniques can fasten your application loading timing, minimize downtime, mitigate the N+1 query problem, and decrease database load.

You can hire a Ruby on Rails developer or RoR development company to deliver efficient and scalable solutions tailored to your requirements.

Frequently Asked Questions (FAQs)

You can enable Rails cache by configuring the caching settings in your config/environments/production.rb file and using particular cache stores like Memcached or Redis that match your requirement.

Fragment and low-level caching are the best caching strategies for high-performance Rails applications. It allows caching particular codes while handling multiple components simultaneously.

Rails cache counter is a feature that allows you to track the associated record whenever that specific object is created, updated, or deleted.

Following codes, you can read, write, and delete cache:

  • To write cache- Rails.Cache.Write
  • To read cache- Rails.Cache.Read
  • To delete cache- Rails.Cache.Delete

Yes, it is technically possible to cache every request, but up to a specific limit. Also, ensure that the request does not have excess memory usage.

Why Settle For Mediocre Performance And Slow-Loading Pages?

Unleash the potential of Rails Caching and deliver exceptional performance with faster response times that keep your user engaged and satisfied with the application.


Build Your Agile Team

Hire Skilled Developer From Us

[email protected]

Your Success Is Guaranteed !

We accelerate the release of digital product and guaranteed their success

We Use Slack, Jira & GitHub for Accurate Deployment and Effective Communication.

How Can We Help You?