Starter Guide to optimize Buddypress or Buddyboss

Performance Optimizations

Top 15 Optimizations for Buddypress and Buddyboss to follow right away

Follow our comprehensive guide to start optimizing your BuddyPress community today. Packed with condensed, actionable insights and real-world case studies, our guide empowers you to tackle performance bottlenecks, streamline database queries, and implement effective caching strategies, all aimed at enhancing your site’s speed and reliability. If you want to learn even more, check our case studies for further insights or consult one of our experts which can try to identify your bottleneck depending on your server configuration right away.

Special Hint

The best performance improvements are generated from adjusting/removing hooks and code based on specific needs. This involves removing or deactivating internal PHP-Code and hooks that many communities may not use, allowing for a streamlined and efficient operation.

By tailoring the functionality to fit your requirements, we can enhance performance and ensure that your platform runs smoothly and effectively.

Make use of PHP built-in features: OPCache

OPCache is a built-in PHP extension that enhances performance by storing precompiled script bytecode in memory, allowing PHP to skip parsing and compiling every single PHP file on subsequent requests. This improvement is not coupled to WordPress specifically, but generally advised overall. This can result in faster execution times and reduced server load. Activating OPCache is straightforward; it typically involves a simple configuration change in the server’s PHP settings, making it an easy yet effective optimization technique. Definitely give it a try! Simply enable it in your webhost provider control panel. But be aware: Whenever you change PHP code, activate or deactivate a plugin, depending on your OPCache config you have to clear the OPCache manually.

Adjusting memory limits & database settings

Adjusting memory limits and database settings is a crucial step in optimizing the performance and stability of a WordPress site. Here’s a guide on how you can effectively adjust these settings:
Under wp-config.php, check the setting define('WP_MEMORY_LIMIT', '256M'); and try to decrease to allow the server to spawn more PHP children processes. Accordingly, you should also set the limit in the PHP.ini file – or respectively in your webserver configuration (like Plesk or cPanel).

Changing Database Storage Engine to InnoDB

Switching your database tables from MyISAM to InnoDB can enhance the performance and reliability of writing-intensive applications. InnoDB uses row-level locking instead of table-level locking, which allows for multiple concurrent transactions without conflicts, thus improving throughput for applications with high write loads like a Buddypress community. This feature is beneficial for frequent simultaneous writes. It is an easy change and definitely worth it.

Debloat Database

After some time you will notice that the database will get bigger and bigger. Why is that? There are numerous reasons to it! Sometimes it is because plugins won’t remove their corresponding database entries upon plugin-deletion. Or because you have edited posts or pages and never deleted old revision – which can result in hundreds of post/page-revisions being stored. Or because Usermeta entries of already deleted users weren’t properly deleted.

To remove post and page revisions, you can either install yet another plugin, simply search for “Post revision deletion” in the WordPress store. Or you can simply run the following query once directly in your database using PhpMyAdmin: DELETE FROM wp_posts WHERE post_type = "revision";

To avoid excessive revisions being created, it can also make sense to limit the number of total revisions being stored per post / page — if exceeded, oledr ones will automatically be removed. Just add this code to your wp-config.php (instead of using yet another plugin for such a trivial task):
define( 'WP_POST_REVISIONS', 10 );

There are actually numerous orphaned or outdated rows in the database which can and should be deleted from the database from time to time. We managed to shrink our database by 20-30% for several clients. For example: Who cares about old notifications or activity entries from months or even years back?

Optimize SQL-Tables from Time to Time

Regularly optimize your database tables to remove overhead and improve performance. This shall rebuild the indices. You can do this using plugins like WP-Optimize or by running SQL commands directly on a regular basis. We like to run it daily using a custom WordPress Cronjob. It is as easy and straight-forward as this; just paste this code into your functions.php:

if(!wp_next_scheduled('CRONJOB_OptimizeDatabase')) {
    wp_schedule_event(strtotime('00:15:00'), 'daily', 'CRONJOB_OptimizeDatabase');
}
add_action('CRONJOB_OptimizeDatabase', function ()
{
    global $wpdb;     $tables = $wpdb->get_col("SHOW TABLES"); 
    foreach($tables as $table) { 
      $wpdb->query("OPTIMIZE TABLE $table"); 
    }});

Caching Techniques

Database / Page Caching

Database and page caching are essential for enhancing the performance of dynamic websites using BuddyBoss or BuddyPress by storing data temporarily to speed up future requests and reduce server load. However, the dynamic nature of these platforms, characterized by frequent user interactions like profile updates and forum posts, makes caching challenging because cached data can quickly become outdated. To address this, techniques such as cache invalidation and selective caching need to be used. Using a direct Database Query technique simply by activating such methods from a Caching Plugin like W3 TotalCache or WP Fastest Cache are therefore not possible via a custom implementation or data invalidation concept. Instead, check the next point.

Object Caching

WordPress’s object caching interface can enhance your website performance by storing database query results and other complex data structures in memory, allowing for rapid retrieval without repeated database access. Utilizing a persistent external object cache like Redis, Memcached, or SQLite Cache takes this a step further by retaining cached data across page loads. These caching solutions integrate seamlessly with WordPress through native PHP functions. Not all data can or shall be cached persistently but Buddypress already makes use of these interface, if enabled; including cache invalidation.
If your Webhost or Server supports either of SQLite, Redis or Memcached, make use of object caching by simply activating it e.g. in W3 TotalCache.

WordPress Transients

WordPress Transients are a powerful caching mechanism that allows developers to store calculated data (e.g. from expensive / load-intensive queries or calculations) with an expiration time. This can drastically reduce the number of database queries and improve site performance by storing the results of expensive operations, such as API calls or complex database queries, for a specified period. However, if object caching is not activated on the server, transients are stored in the wp_options table, which means that database queries will still occur to retrieve these cached values. While this is still more efficient than recalculating the results on every page load, enabling a persistent object cache like described one section above further optimizes performance by storing transients in memory.

Frontend Loading-Time

All of these features can and will improve the responsiveness of pageload times on the client side by decreasing the filesizes, minimizing the number of files to be loaded and / or caching the files on the clients machines. Doing so will not only improve the loading times but also decrease the overall server load specifically on the webserver (mostly Apache or Nginx). Hence, indirectly benefitting the available ressources to spawn and run efficient PHP processes.

Lazyloading of Images

Enabling lazy loading of images is an effective optimization technique that improves webpage performance by deferring the loading of images until they are needed. Instead of loading all images on a webpage at once, lazy loading ensures that images are only loaded when they enter the viewport, i.e., when they are about to be visible to the user. This reduces initial page load time and bandwidth consumption, offering a faster and more efficient user experience, especially beneficial for pages with many images like an online community with a lot of avatars to be loaded from the server. We like to use the Plugin “Lazy Loader” by Florian Brinkmann because it uses the awesome native Javascript libray LazySizes which is 100% configurable and works like a charm. 18k stars on Github don’t lie.

Browser Caching

Browser caching is an easy-to-use technique for improving overall performance by storing static resources such as images, stylesheets, and scripts on a user’s local device. When a user visits a website, these resources are downloaded and stored in the browser’s cache. On subsequent visits, instead of fetching these files from the server again, the browser retrieves them from the local cache, which significantly reduces page load times and server load. This does not directly benefit the execution time of either PHP or MySQL because retrieval of static ressource only affects your webserver (mostly Apache) – but still it is a useful and very easy to use technique. Set the appropriate cache headers, such as Cache-Control and Expires, to specify how long these resources should be cached, ensuring that users have a faster and more efficient browsing experience. This approach minimizes unnecessary server requests and bandwidth usage, thereby improving the overall performance and scalability of the website.

Minify CSS / JS

Minifying CSS and JavaScript files is a crucial step by reducing file sizes and improving load times on client side. Minification involves removing all unnecessary characters from code — such as whitespace, comments, and line breaks — without affecting its functionality. This process results in smaller file sizes, which means faster downloads and quicker parsing by the browser, leading to improved page responsiveness. Tools and plugins like W3 TotalCache or Fastest Cache can automate this process, ensuring that the minified files are optimized for production environments. Furthermore, combining minification with other strategies, such as file concatenation can further improve resource delivery to the users browser. This can be activated in W3 TotalCache with minimal effort.

Use a CDN-provider like Cloudflare

Using a Content Delivery Network (CDN) to offload static files is a strategy for optimizing webserver performance and scalability. A CDN is a network of geographically distributed servers designed to deliver content to users more efficiently. The CDN usually retrieves static ressources from the origin webserver every now and than, then stores and serves the static files such as images, CSS, JavaScript, and other media files through the server network. This reduces load on your webserver, but also improves loading times for users across the globe, because the CDN picks the best server-location to server the files depending on the user location. Additionally, CDNs often provide built-in security features, such as DDoS protection and secure token access, further enhancing the website’s reliability and security. This does only require small changes to your domain DNS settings – but is free and easy to setup.

Deactivate not-needed Plugins

It nearly goes without saying: Deactivating unnecessary plugins is a crucial step in optimizing the performance and security of a WordPress website. Each active plugin consumes server resources (and can potentially introduce security vulnerabilities or conflicts), particularly in complex setups like those using BuddyBoss or BuddyPress. We understand it is often necesary to play around with new plugins in case you want to introduce new features. Just be mindful to delete these plugins if you are done and are choosing to not use a specific plugin. You can significantly reduce load times, improve server response, and minimize the risk of software conflicts.

Decrease huge amount of AJAX calls (a.k.a. Heartbeat)

We cannot emphasize this enough: This tipp is HUGE! WordPress provides an easy method for plugin developes to retrieve data from the server by making background calls every few seconds. Now, consider a scenario where a user opens multiple tabs in your community — each tab will ping your WordPress installation every few seconds. This creates a substantial load on the server!

Reducing the number of AJAX calls, commonly referred to as “heartbeat” requests, is essential for enhancing web application performance and alleviating server strain. The heartbeat feature can slow down or even disrupt a website’s functionality when more than 50-100 users are online simultaneously.

Fortunately, there are several strategies to optimize the Heartbeat without compromising the user experience – this list shall give you a good starting idea:

1. Increase the Polling Interval: Extend the time between each request to reduce server load.
2. Adjust Polling Based on User Activity: Make the polling interval dependent on the number of online users
3. Pause Polling for Inactive Tabs: Stop the polling/heartbeat for tabs that are inactive in the background.
4. Implement a Custom Solution: Develop a custom solution that only triggers the full Heartbeat when there is a pending notification for the user, effectively reducing 99% of Heartbeat calls.

You can use a code like this in your functions.php to change the polling interval in general. This should get you started:

define('HEARTBEAT_SECS', 45);
add_filter('heartbeat_settings', function ($settings)
{
	$settings['interval'] = HEARTBEAT_SECS; 		//Anything between 15-60
	$settings['minimalInterval '] = HEARTBEAT_SECS; //Anything between 15-60
	return $settings;
});

Analyze and optimize Autoload Options

In WordPress, options stored in the database can be marked as “autoload”. Autoload options are automatically loaded into memory on every page load. While this can be efficient for frequently used options, having too many autoload options or loading large amounts of data unnecessarily can slow down your site. Analyze the Autoload Options to identify unnecessary or bloated autload options which could be orphaned from previous plugin installations.

A large number of autoloaded options can put unnecessary strain on your database, affecting site performance.
With the following query you’ll find the number of autoload options with the total size in Kilobytes:

SELECT  
    'autoloaded data in KiB' as name,
    ROUND(SUM(LENGTH(option_value))/ 1024) as value 
FROM wp_options WHERE autoload='yes' 
UNION 
  SELECT 'autoloaded data count', count(*) 
  FROM wp_options WHERE autoload='yes'

Change WordPress-Cronjobs to run on demand only

In the default installation, during every pageload, the WordPress system checks the scheduled cronjobs and runs them if necessary / scheduled. Changing WordPress cron jobs to run on demand using an external cron job trigger can improve site performance by reducing unnecessary execution of scheduled tasks. This can be achieved by changing wp-config.php to define('DISABLE_WP_CRON', true); – but be mindful to set up an external trigger service like Easycron, Fastcron or, if available, one which is available from within your Web Hosting package.

Turnoff not needed “slow” features

There are a lot of features in Buddypress and Buddyboss which are quite runtime intensive but rarely used or of not much use. For example:

Buddypress Username mentions (parsing of @username)

One example, the parsing of usernames in comments and/or posts is activated by default, but wasn’t often used in the communities we optimized. If you don’t think you need this feature, you can deactivate it by adding this code to your functions.php:

add_filter("bp_activity_do_mentions", "__return_false");

PMPro Tracking of Views & Visits

If you happen to use PMPro (paid membership pro) for managing membership levels, payments and premium access, you’ll quickly find that PMPro tracks the number of views and visits which is at least one write-access upon every pageload. Not good! Write intensive queries are to be avoided if possible because the database has to rebuild the indices of the corresponding tables. These can easily be deactivated by adding this code to your functions.php:

remove_action("wp", "pmpro_report_login_wp_visits");
remove_action("wp_head", "pmpro_report_login_wp_views");
remove_action("wp_login", "pmpro_report_login_wp_login", 10 ,2);

Deleting orphaned transients

As we discussed earlier, WordPress has a feature called transients, which is a sort of cache with easy access for developers. Transients come with the ability to set an expiration time. Unfortunately, Wordpres itself doesn’t take care of cleaning up the orphaned, that means expired entries itself. This can result in a flooded database or caching system. The goal should be to clean as many unneeded entries as possible.

Simple solution: Install Delete Expired Transients and make sure to run it regularly to make your database or persistent object cache less of a mess. Unfortunately this plugin does not come with a scheduled cronjob, which means: You have to run it manually yourself. And who likes manual stuff which you have to remember on a daily or weekly basis? Solution: Build a small cronjob which is scheduled as WordPress Cronjob and runs nightly. Simply take our code to take care of it:

if(!wp_next_scheduled('CRONJOB_CleanOrphanedTransients')) {
    wp_schedule_event(strtotime('00:15:00'), 'daily', 'CRONJOB_CleanOrphanedTransients');
}
add_action('CRONJOB_CleanOrphanedTransients', function ()
{
    $blog_id = get_current_blog_id();
	if(class_exists('DelxtransCleaners'))
		DelxtransCleaners::clearBlogExpired($blog_id);
});

Analyze using Query Monitor

Analyzing your database load using, for example, the Query Monitor plugin in WordPress is a powerful way to understand the database query load and, as a result, optimize the performance and efficiency of your WordPress site. This is particularly sensible for BuddyPress, as there is much to understand and analyze. While using Query Monitor to examine your SQL queries, you should particularly focus on recurring queries, the total number of queries, and slow queries.

By identifying the number of SQL queries, and especially the number of recurring SQL queries, you can often find cascades of WP-Hooks running in a specific call chain that are not needed and should be resolved or removed. Sometimes such an optimization can save hundreds of queries for every single page load. We’ve seen plenty of such instances, sometimes resulting in a 100% performance increase of a single page load.

Make sure to check out our case studies to learn more about it.

Analyze recurring SQL Queries

Recurring SQL queries are queries that are executed multiple times during a single page load. These could be queries to fetch the same data repeatedly. Such queries will definitely slow down your site if they are unnecessary or could be cached. For example, if the same query is being executed multiple times, it could indicate inefficient code or the need for better caching strategies. By identifying these queries, you can refactor the code to reduce redundancy. We know it is not always a good idea to patch code directly because you’ll have to modify the code with every plugin, but it can definitely be worth the job. Sometimes you gain several hundred milliseconds by such an optimization. This might also involve using caching mechanisms or combining multiple queries into a single, more efficient query.

Check total number of SQL Queries

This refers to the total count of SQL queries executed to generate a particular page or response. If the amount is really high, like a few hundred queries, you know there’s some weird code to be optimized. Each query takes time to execute and process. The more queries, the longer it can take to load a page, especially on pages that are visited frequently. Fewer queries mean less database load, which is crucial as your site traffic increases.

Number and runtime of Slow SQL Queries

Slow queries are those that take a longer time to execute, usually due to complex joins, unoptimized indexes, or large data sets. Every query that takes more than 0.1 seconds to run should definitely be analyzed more closely. Identifying slow queries helps in pinpointing the exact operations that are dragging down the performance. Even if the number of such queries is low, a few slow queries can have a disproportionately large impact on load times. This one, in particular, can potentially be optimized by creating or refining indexes in your database, even without touching the code.

Scroll to Top