When you have a Notion database with hundreds or thousands of rows, formulas that once computed instantly can become slow. The page may freeze for seconds or even time out when you edit a formula property or filter the database. This lag happens because Notion recalculates every formula in every row every time the database loads or a value changes. This article explains why formula performance degrades at scale and provides specific steps to optimize your formulas so your database remains responsive.
Key Takeaways: Optimizing Notion Formulas for Large Databases
- Reduce formula complexity: Break monolithic formulas into multiple simple formula properties to reduce per-row computation time.
- Use rollup sparingly: Replace rollup formulas with direct relation lookups or precomputed values to avoid cascading recalculations.
- Apply filters to limit visible rows: Use database filters to reduce the number of rows that trigger formula recalculation on load.
Why Notion Formulas Slow Down in Large Databases
Notion recalculates every formula property in every row of a database each time the database view loads or any related data changes. For a database with 10,000 rows, a single formula that references five other properties forces 50,000 property reads per load. If the formula uses a rollup that itself references another database, the computation chain grows exponentially. Notion does not cache formula results between sessions, so every open of the database triggers a full recalculation. The lag becomes noticeable when the formula contains nested if statements, multiple rollups, or references to properties in other databases that themselves have many rows.
Steps to Improve Formula Performance
- Identify the slowest formulas
Open your database and note which formula properties take the longest to load. Sort by the formula column and watch the loading spinner. Focus on formulas that userollup(),prop()with many arguments, or nestedif()statements. - Break complex formulas into smaller parts
Instead of one formula that calculates A, B, and C, create three separate formula properties. Each computes one value. Then create a final formula that references those three formula properties. This reduces the computation per property and allows Notion to update only the affected properties when data changes. - Replace rollups with direct formula references
If a rollup property pulls a value from a related database, replace it with a formula that usesprop("Relation").first()orprop("Relation").map(). Direct formula references are faster because they do not require the rollup engine to aggregate across the entire related database. - Limit the number of rows in the view
Add a database filter that shows only the rows you need. For example, filter by a status property set to “Active” or a date property in the current month. Fewer visible rows means fewer formulas to compute on load. - Use the
dateBetween()function instead of manual date math
Manual date calculations usingprop("Date1") - prop("Date2")are slower than the built-indateBetween()function. Replace all manual date subtraction withdateBetween(prop("Date1"), prop("Date2"), "days"). - Remove unused formula properties
Delete formula properties that you no longer use. Each formula property adds to the total computation time even if it is not displayed in the current view. - Archive old rows instead of keeping them in the same database
Move completed or outdated rows to a separate archive database. Use a relation to link back if needed. This reduces the row count in your active database and speeds up all formula computations.
If Notion Still Lags After Optimizing Formulas
Formula column shows “Loading…” indefinitely
This occurs when a formula contains a circular reference or references a property that itself depends on the formula. Check all formula properties for loops. Remove any formula that references another formula that eventually references back to the first one.
Rollup formula returns “Error” in large databases
Notion limits rollup computations to 10,000 rows per database. If your related database exceeds that, the rollup fails silently. Replace the rollup with a formula that uses prop("Relation").map() and then an aggregation function like sum() or count(). This bypasses the rollup limit and improves speed.
Performance lag only on mobile or desktop
Notion mobile apps have less memory and processing power than desktop browsers. If your database has more than 5,000 rows, consider creating a simplified view with fewer formula columns specifically for mobile use. Use the “Hide” option on the column menu to remove heavy formula columns from the mobile view.
| Optimization Technique | Before (Slow) | After (Fast) |
|---|---|---|
| Formula structure | Single formula with 10 nested if statements | Three separate formulas each with 3 if statements |
| Rollup usage | rollup(prop("Related"), prop("Value"), sum) |
prop("Related").map(current.prop("Value")).sum() |
| Date calculation | prop("End") - prop("Start") |
dateBetween(prop("End"), prop("Start"), "days") |
| Row count management | 10,000 rows in one database | 5,000 active rows + 5,000 archived rows |
By applying these optimizations, you can significantly reduce formula computation time in large Notion databases. Start with the simplest change, such as removing unused formula properties or adding a filter, and test the performance before moving to more complex restructuring. For databases with over 50,000 rows, consider splitting the data into multiple databases linked by relations to keep each database small enough for fast formula recalculation.