Understanding performance in Quickbase

As your Quickbase applications grow, it is important to design them in a way that keeps them efficient and responsive. Understanding how Quickbase works can help you:

• Optimize your applications as they scale
• Make informed decisions about app structure
• Troubleshoot issues if they occur

This article explains how Quickbase manages performance, what factors can affect it, and what you can do to troubleshoot or design more efficient apps.

How Quickbase handles your requests

When you run a report, open a chart, view a dashboard, or fetch data using an API (both XML and REST), Quickbase calculates results in real time. That means your data is always up to date, but it also means the platform carries out several tasks on the spot, like:

• Evaluate fields—Quickbase calculates the values for formulas, lookups, and summary fields
• Apply filters—Records that don’t meet your criteria are removed
• Sort records—The remaining results are ordered, often by one or more fields
• Check permissions—User access rights are enforced on the data returned

If a field depends on other fields, for example a lookup field, Quickbase must perform these actions all of the child records as well.

Most of the time, this processing happens quickly. But as your apps grow in size and complexity, some combinations of data volume, field complexity, and actions performed can add up to more work than Quickbase can complete within its limits.

To protect the platform, Quickbase evaluates requests for complexity and processing time, and may return a timeout message if a request is predicted to exceed the platform’s limits. This is calculated transparently and may vary differently each time a report is run because of differences in the underlying data. The same predictive logic is what helps determine how many results are returned on a page in a report, or API. Learn more about API pagination.

Key factors that affect performance

Several elements can influence how quickly your reports, charts, dashboards and API calls are processed:

• Data volume—Larger tables take longer to process. 
  For example, a calculation that feels instant on 10,000 records may run slower on 5 million records.
• Usage volume—Actions might take longer if other users are also working in the same app simultaneously. Learn about traffic in your app with Performance Insights.
• Field complexity—Some fields take more time to calculate than others. 
  For example, a field that adds two numbers is very fast, while one that uses nested formulas or multiple lookups takes more time.
• Dependencies between fields—If one field relies on the results of several others, Quickbase has to calculate all of them first. This chain effect can make certain fields more complex.
• Permissions—Quickbase checks permissions on all data, including child records for fields with dependencies. This may slow performance for users with certain permissions. 
  For example, loading a report as a regular user might take longer than an admin who has access to all fields.
• How fields are used—The same field can have different impacts depending on context. Sorting, filtering, or grouping by a complex field multiplies the work Quickbase needs to do.
• Relationships and formula queries—Relationships can sometimes be more efficient because Quickbase optimizes them behind the scenes. Formula queries are flexible, but they can be slower when used in reports or across large datasets. 

For example, say you have a Projects table with 1,000 projects, and each project needs to check against a Holidays table that has 15 holiday records:

• A formula query field on the Projects table scans the Holidays table. For a single project, Quickbase processes 15 records.
• When you view a List All report of Projects, Quickbase initially calculates the formula query for the first 100 projects (based on pagination). That’s 100 × 15 = 1,500 calculations.
• If you then sort the report on that formula query field, Quickbase must evaluate it for all 1,000 projects. That becomes 1,000 × 15 = 15,000 calculations.

This example is simplified to illustrate how formula queries scale. In practice, Quickbase applies additional optimizations to reduce the workload.

Tools to understand performance in your apps

Quickbase offers several ways to better understand where complexity exists in your apps. Learn more about Performance tools.