How to reduce Workload Units (WU) consumption of your bubble.io app

In April 2023, Bubble announced a pricing update that shifted the focus for app developers. Instead of concentrating on minimizing capacity use, the spotlight is now on reducing Workload Unit (WU) consumption.

With Bubble's Workload Unit (WU) billing model fully implemented as of October 1, 2024, it's time to focus on getting the most value from your Bubble subscription. The new system ties app actions—page loads, API calls, database changes, and workflows—to WU consumption. While this might sound overwhelming, don’t worry: here are 11 actionable tips (plus a bonus) to optimize your app's WU usage.

1. A new mindset for bubble development
2. Avoid nested searches
3. Limit auto-binding
4. Avoid advanced filters
5. Use shorter lists when possible
6. Hide elements by default
7. Optimize conditional statements
8. variables to reuse data
9. Leverage browser tools
10. Optimize API calls
11. Understanding the count operator
12. Bonus tip: think like a developer

A new mindset for Bubble development

The key to reducing WU consumption lies in developing a dual mindset that prioritizes both performance and efficiency. Before implementing any feature, ask yourself:

1. Can this process be simplified? 
2. Is this piece of data truly necessary?
3. Have I measured its WU impact?

Efficiency often boils down to simplification. The fewer actions your app performs, the fewer WUs it consumes. But don’t assume—always test and measure to confirm

11 Tips to optimize workload units (WUs) in your Bubble app

1. Avoid nested searches

Nested searches happen when one search depends on the results of another. For example, if you have a repeating group that searches for messages and then another search runs within the same group, that’s a nested search.

Why it’s a problem:

Nested searches result in multiple database queries, increasing WU consumption significantly.

Fix it:

• Add a relevant field to your database to filter results upfront.
• Perform the filtering in a single query instead of layering searches.

2. Limit auto-binding

Auto-binding is a convenient Bubble feature, but it can be costly in WUs. Every time an auto-bound field updates, it triggers a database operation.

Better alternative:

Use a Save button to apply all changes in a single operation, reducing the number of database writes. This is especially useful for multi-field forms.

3. Avoid advanced filters

Advanced filters fetch all data into the front end and then process it in the user’s browser. This increases WU usage and slows down performance.

Optimize it by:

• Structuring your database to include tags or option sets for better filtering at the query level.
• Using constraints to refine searches before they reach the front end.

4. Be cautious with empty constraints

If you use the Ignore Empty Constraints option in your searches, Bubble may fetch unnecessary data when a condition isn’t set yet.

Solution:

• Use conditionals to delay loading the data source until all required constraints are valid.
• Ensure searches are only triggered when relevant data exists.

5. Use shorter lists when possible

Fetching shorter lists of items is often more WU-efficient than performing repeated searches.

Example:

• Instead of searching for related items in a separate table, save a short list of related data in the parent object.
• Avoid storing long lists (e.g., 200+ items) in a single object, as these can lead to heavier loads.

6. Hide elements by default

Bubble’s caching system fetches only what’s visible on page load. If you have hidden groups or elements that aren’t needed immediately, this can save WUs.

How to implement:

• Set groups and elements to “not visible on page load.”
• Make them visible only when triggered by specific conditions.

7. Optimize conditional statements

Bubble evaluates conditional statements from left to right. If a condition fails early, subsequent conditions won’t run.

Best practice:

Place the simplest, least resource-intensive conditions first to avoid unnecessary operations.

8. Use variables to reuse data

Fetching data multiple times for different elements consumes unnecessary WUs. Instead, store commonly used data in variables or custom states.

How to do it:

• Use hidden groups or repeating groups to store data.
• Reference this stored data instead of performing new searches.

9. Leverage browser tools

The developer console in browsers like Chrome can help you monitor your app’s performance.

Key areas to check:

• Elements loaded: Reduce unnecessary elements to lighten page loads.
• Network tab: Monitor data fetches and identify heavy requests.
• Fetch sizes: Analyze search sizes and optimize queries accordingly.

10. Optimize API calls

API calls can return large datasets, even if you only need a portion of the data.

Optimize API efficiency by:

• Using pagination or limits to fetch only the necessary data.
• Sorting and filtering API responses before they’re sent to Bubble.

11. Understanding the :count operator

The :count operator is a prime example of how WU usage can vary unexpectedly. Imagine you need to show an element conditionally when Search:count is 0. While Bubble's documentation states that a :count operation consumes 0.20 WUs, real-world testing shows a different picture.

Here’s what we observed:

1. Search (1,000 items):count is 0

- WU Consumption: 3.86

- Why? This operation downloads the first 10 items from the server before evaluating the count, leading to unexpected WU spikes.

2. Search (1,000 items):first item is empty

- WU Consumption: 0.69

- Why? This only downloads one item from the server, making it significantly more efficient.

3. Search (1,000 items):count≥1 (≤1)

- WU Consumption: 0.20

- Why? This operation directly fetches the count value without downloading any items.

Bonus tip: think like a developer

Adopting a developer’s mindset can go a long way in optimizing WU consumption.

What to do:

• Check Bubble’s server logs to track high-WU operations.
• Regularly review workflows and database queries for efficiency.
• Test different implementations and measure their WU impact.

Key takeaways

• Simplify workflows and avoid redundant searches to minimize WU consumption.
• Use database design strategically to reduce reliance on advanced filters and nested searches.
• Take advantage of browser tools and server logs to monitor and fine-tune your app.
• Always experiment, measure, and iterate for the most efficient implementation.

Struggling with poor performance and high WU consumption in your Bubble app? Book a call to discuss how to improve your app performance! 🚀