Slow Google Sheets?

We’ve all been there, stuck watching the little loading bar creep slowly, frustratingly to it’s conclusion:

How can you speed up a slow Google Sheet?

First off, this is a *difficult* question to answer because there are so many factors that may or may not be causing you to have a slow Google Sheet.

What follows in this article is some suggested optimization strategies and some research into what causes slow Google Sheets.

# Strategies to speed up Google Sheets

- How to recognize slow Google Sheets (details)
- Know the size limits of Google Sheets (details)
- Measure a Google Sheet’s size (details)
- Measure a Google Sheet’s calculation speed (details)
- Delete un-used cells (details)
- Convert formulas to static values wherever possible (details)
- Use closed range references (details)
- Remove volatile functions or use with caution (details)
- Vlookup strategies (details)
- Index-Match strategies (details)
- Query function strategies (details)
- Array Formula strategies (details)
- Import Formula strategies (details)
- Google Finance function strategies (details)
- Use IF statements to manage formula calls (details)
- Manage expensive formulas with a control switch (details)
- Use Filter, Unique and Array_Constrain functions to create smaller helper tables (details)
- Avoid long calculation chains (details)
- Reference data on the same Sheet (details)
- Use helper columns (details)
- Split your slow Google Sheet into separate Sheets (details)
- Use Conditional Formatting sparingly (details)
- Leverage the power of Apps Script (details)
- Use custom formulas sparingly (details)
- Other troubleshooting tips for slow Google Sheets (details)
- Understand changes in the cloud can take time to propagate (details)
- Know when it’s time to move to a database (details)

I remember the old days when you would set hundreds of thousands of VLOOKUP formulas loose on your dataset and then go out for lunch. If you were lucky they’d be finished when you returned. (And woe betide anyone who made a mistake with a formula!)

Although we’ve come a long way from those days, if you work with data a lot, chances are you’ll find yourself coming up against slow spreadsheets at some stage.

A lot of the tips that follow are generally good spreadsheet practices anyway, so even if you only work with small Sheets at the moment, they’re worth implementing now.

# 1. How to recognize slow Google Sheets

If you’re reading this, chances are you’ll recognize some or all of the following issues.

**Calculations in your Google Sheets are super slow** and the dreaded loading bar makes an appearance every time you make a change to your Sheet.

Your **Google Sheet becomes sluggish** to respond to mouse clicks or keystrokes.

**Data does not show in cell**, even though you know you’ve entered data into the cell. For example, have a look at this formula that simply didn’t show a value after being entered:

**Your Google Sheet becomes unresponsive.** This is the worse case scenario, and in my experience, if this doesn’t resolve fairly quickly, you don’t often recover from here.

So if you see this error message, and you’ve waited a few minutes but nothing’s happening, then you might want to just bite the bullet, exit the page, and pickup again but trying a different approach this time.

This is usually accompanied by your computer going into overdrive with the fan whirring loudly!

# 2. Know the size limits of Google Sheets

Obviously if you’re dealing with large Google Sheets — Google Sheets with large amounts of data and/or formulas — then you’re more likely to see your performance suffer.

No discussion of slow Google Sheets therefore, would be complete without first discussing the size limits of Google Sheets.

#### Overall limit:

Google Sheets has a limit of 2 million cells per workbook (see Google file sizes).

If you do something that will take you past this limit (e.g. adding new rows or a new Sheet), you’ll see this error message:

#### Column limit:

Google Sheets has a maximum number of columns of 18,278 columns.

If you do something that would take you past this limit, you’ll see the following error message:

#### Individual cell-size limit

Within a single cell, there’s a maximum string length of 50,000 characters (enough for approximately 500 average sentences, or about 162 Tolstoy sentences).

If you do something that would take you past this limit, you’ll see the following error message:

#### Max number of rows you can add in one go

You can add a maximum of 40,000 new rows at a time (you can do this as many times as you want though, up to the 2 million cell limit).

If you try to do more than that, you’ll see the following error message:

# 3. Measure a Google Sheet’s size

Using Apps Script, you can quickly build a simple tool to calculate the size of your Sheet:

This Sheets audit tool shows the total number of cells in the Sheet, how many have data in them and then statistics for each individual sheet too, including how many volatile and array functions you have *(CLICK TO ENLARGE)*:

**Bonus:**Get your own copy of this Google Sheet Audit Tool to measure the size of your Google Sheets.

The code for this tool can also be found here on GitHub if you prefer.

I’ll do a post in the future looking specifically at how I built this tool with Apps Script.

New to Apps Script? Check out my beginner guide here.

So that’s measuring the size of Google Sheets, what about measuring their speed?

# 4. Measure a Google Sheet’s calculation speed

To measure the “speed” of various calculations you can make use of Chrome’s Developer Tools.

In your browser window, you can access the Developer Toolkit by pressing ** Cmd + Option + I** on a Mac or

**(on a PC). It can also be accessed in the View > Developer menu.**

`Ctrl + Shift + I`

Under the **Performance** tab of the Developer Tools you can record the webpage (or Google Sheet in this case) as it loads, and check the screenshots box to show you what is happening and when.

For formula calculations, you can identify when the calculations start, e.g. marked by the 1 in this image, at around the 3.6 seconds mark:

The number 2 shows a screenshot at this point in time, so you can see that your formulas are not showing yet.

You can identify when the formulas have finished calculating (the red box, around the 8.6 seconds mark):

Check the screenshot to see that the formula results are showing in the cells now.

And so you an see how long this batch of formulas took to calculate:

8.6s – 3.6s = 5s

There’s a whole lot more to the Developer Tools, but that’ll do us for today.

This is the methodology I’ve used to calculate formula speeds for comparison tests. I ran all of the tests in the same place at the same time of day (so wifi speed discrepancies were negligible) and also ran them each multiple times and took averages.

# 5. Delete un-used cells

Your Google Sheets will get slower as they get larger.

So one of the first things to try, before getting into the marginal gains of formula optimization, is reduce the size of your Google Sheet.

Blank cells slow down performance, dramatically so in fact. So it’s a good idea to delete them whenever you can, so you reduce the number of cells Google Sheets is holding in memory.

Ideally you should remove any large numbers of blank rows under your datasets, or columns to the right of your datasets.

**What about new rows being added automatically?**

Don’t worry if your data is being imported automatically by Apps Script or a third party tool like Supermetrics or Tiller, as the new rows are automatically added to your Sheet as required.

*(However, you should always test this theory with your specific setup or app, to confirm this is the case.)*

# 6. Convert formulas to static values wherever possible

Once you’ve used a set of formulas in your data, and you’re sure you won’t need them again, you should convert them to values.

This should reduce the file size, which will help performance overall, and it’s also best practice (to reduce errors occurring if someone or something happens to break the formulas).

You change formulas to values by copying them and then:

**Edit > Paste special > Paste values**

Better yet, learn the keyboard shortcut to save yourself time. Highlight the formulas to change, **Ctrl + C** on a PC or **Cmd + C** on a Mac to copy and then **Ctrl + Shift + V** on a PC or **Cmd + Shift + V** on a Mac to paste as values.

Note, I advocate keeping a copy of a “live” formula at the top of your columns of data in your tables, so you have a record of how the calculation was performed and can also very quickly re-use it if needed:

# 7. Use closed range references

Closed range references means using something like `A1:B1000`

instead of `A:B`

in your formulas (i.e. you explicitly specify the boundaries of your range).

If you’re working with large Sheets and are using open references where you don’t need to, this will be adding extra calculation overhead to your Sheet.

It might not look like there’s much data in column A, but Sheets will check every cell, including all the blank ones, if you use open ranges like A:B.

**Note: **Whilst this is generally a good idea for speeding up your formulas, there are obviously situations when an open reference is desirable, for example when new data is anticipated. Leaving an open range will allow any new data to be included in calculations.

# 8. Remove volatile functions or use with caution

In Google Sheets there are four functions, `NOW()`

, `TODAY()`

, `RAND()`

and `RANDBETWEEN()`

, that are known as *volatile* functions, which means they recalculate every time there’s a change to the Sheet. All dependent formulas must also be recalculated too (i.e. formulas that reference or include a nested volatile function).

This uses up processing power and so can negatively impact your Sheet’s performance, although this is only going to be noticeable if you have large numbers of them.

To illustrate, I copied 100,000 `TODAY()`

functions down column A, which took my machine about 5.5 seconds.

I then deleted 99,999 of these formulas and just left `TODAY()`

in cell A1 and then put the following formula in cell A2:

`= $A$1`

and then copied this one down. The dollar signs represent absolute references and keep all my formulas locked onto cell A1.

Running this formula down 100,000 cells in column A took around 4.1 seconds, so almost 1.5 seconds quicker.

It’s also best practice to do this, because if I ever need to make a change to the date, then I can just change it in this one place, A1, and not have to redo all of my formulas.

# 9. Vlookup strategies

Use closed, rather than open, range references for your search tables where possible (see no. 7 above).

Reduce the size of your lookup table, if possible, although this only has a marginal positive affect in my experience. For example, rather than search across everything you might use the Filter function (see no. 17 below) to create a smaller, helper table for the lookup first, and then use that in your VLOOKUP.

However, don’t be tempted to nest the FILTER (or other) function inside your VLOOKUP and create the table on the fly each. It’s much, much slower.

For example, this formula is **bad practice** and will really slow down your Sheet if you have a lot of them:

`=VLOOKUP( $A1 , UNIQUE( FILTER( $K$1:$N$10000 , $K$1:$K$10000 < 100 )) , 2 , FALSE )`

whereas creating that nested Filter table as a helper table and referencing it is the preferred method:

`=VLOOKUP( $A1 , $F$1:$I$10 , 2 , FALSE)`

Combining VLOOKUPs with Array Formulas to return multiple column values with a single lookup is significantly slower than simply using multiple individual VLOOKUPs.

In Excel, sorting your data and using approximate matching (TRUE as your final argument in the VLOOKUP) is quite a bit faster than the exact matching algorithm (FALSE as the final argument). It’s slightly quicker in Google Sheets too, but only slightly it seems, so it’s not worth the extra hassle.

Another Excel VLOOKUP trick is to use two approximate matching VLOOKUPs instead of a single exact match. It’s significantly faster because the underlying search algorithm is much, much faster. However, I found this technique was actually slightly *slower* on Google Sheets so I wouldn’t recommend it.

# 10. Index-Match strategies

The Index-Match is a powerful lookup combination and well worth learning (learn it in day 10 of my free Advanced Formulas 30 Day Challenge course).

In it’s classic construction, you might see formulas like this:

`=INDEX( Sheet2!$A$2:$P$51 , MATCH($A3,Sheet2!$G$2:$G$51,0) , MATCH(C$1,Sheet2!$A$1:$P$1,0) )`

where you have two nested MATCH functions to lookup the row and column numbers (which is why index-match-match is so flexible).

This is fine for small numbers of index-match-match formulas, but inefficient at scale.

Say you’re looking up 10,000 rows and 10 columns. For every single cell, you’re using two matches to lookup the row number and the column number, so your total number of calculations would be:

`No. of Match functions for row +`

No. of Match functions for column +

Index Match function =

```
```(10,000 rows * 10 matches) +

(10,000 rows * 10 matches) +

(10,000 rows * 10 indexes) =

`300,000 calculations`

Much better to **split the match lookups out** into their own helper row and column rows, as shown in this example:

By splitting both the match lookups into their own row and column, you can compute them all once first, and then use those numbers in your index function.

Now you’ll only have to calculate the index function when you do your calculation, so your total calculations now would be:

`(10,000 matches for the rows) +`

(10 matches for the columns) +

(10,000 * 10 indexes) =

```
```

`110,010 calculations`

Significantly less than before, only about 1/3 as many calculations to do!

# 11. Query function strategies

As alluded to above , using open range references can hurt performance because you may inadvertently include thousands of extra blank rows in your calculations (see no. 7 above).

Instead, use closed range references or create smaller helper tables as inputs to your Query functions to speed up performance.

For example, running tests with a QUERY function, I found that each additional 20,000 empty rows I was including with open ranges would add 1 second to the calculations.

So rather than a formula like this for example:

`=QUERY( Sheet2!A:E , "select *" , 1 )`

you’d be better served by specifying the range explicitly:

`=QUERY( Sheet2!A1:E100000 , "select *" , 1 )`

This improves the Query function speed because the calculation is no longer including all of the blank rows in `Sheet 2`

under the dataset.

# 12. Array Formula strategies

If you spend long enough reading help forums you’ll find people saying that using a single array formula to replace hundreds of individual formulas will be quicker, and others staunchly saying the opposite. So which is it?

In my experience, array formulas working on big datasets (those with lots of rows) are slow and will make your Sheet sluggish. I’ve found they tend to be slower than the individual formulas.

However, they’re so useful in specific situations, like gathering Google Form data, that I still recommend learning about them and using them, with caution.

I use them heavily for performing running calculations on datasets that grow over time (new rows being added). That way I know the calculation happens without me needing to update anything.

For example, this formula:

`=ArrayFormula( IF( A2:A <> "" , A2:A * 100 , "" ))`

which is the array version of this individual formula:

`= IF( A2 <> "" , A2 * 100 , "" )`

will automatically compute a value for every new row of data added.

I would test both versions on your own sheets, and choose whichever is most appropriate (weigh up speed versus array benefits of automatic calculation). The individual formula approach has the added benefit of being easier to debug and setup.

If you want to keep array formulas (and I hear ya!) consider archiving historic data periodically (see no. 21 below), to keep the live dataset manageable.

# 13. Import Formula strategies

The `ImportHtml`

, `ImportFeed`

, `ImportData`

, `ImportXml`

and `ImportRange`

formulas pull data from sources external to your Google Sheet, so they require an Internet connection to function.

They’re slower than other functions that operate entirely within your single Sheet, so they will potentially affect the performance of your Sheet.

For example, using ImportRange to import large amounts of data from another Sheet will take time and you may see the Loading… error message for a while:

The best approach here is to minimize the number of external calls required.

For example, with ImportRange you could make a single call to get a whole dataset, notwithstanding the point above about this being itself a slow operation, and then do any filter or further work locally, rather than doing multiple ImportRange calls.

Note, you’re limited to a maximum of 50 of ImportData functions in a single spreadsheet (link).

None of the other Import formulas have an explicit limit like this on their help pages and some limited testing suggests that if there are any limits, they’re certainly greater than 50.

By default, these functions recalculate as follows (see documentation):

**ImportRange**: Every 30 minutes**ImportHtml, ImportFeed, ImportData, ImportXml**: Every hour

# 14. Google Finance Function strategies

The `GoogleFinance`

function is another function that retrieves data from an external source, so requires an internet connection. Like the Import formulas above, it will be slower than regular functions operating inside your Sheet only.

Again, the general strategy here is to reduce the number of external calls you make with GoogleFinance function, i.e reduce the number of GoogleFinance functions you use.

So think about retrieving a whole year of stock prices with a single formula, rather than hundreds of daily functions for example.

Per the documentation, GoogleFinance data may be delayed up to 20 minutes.

# 15. Use IF statements to manage formula calls

You can use an IF wrapper to check whether a calculation needs to be performed before doing it.

#### Example

Say for example you have a table of product data that includes books, and you want to use a vlookup to bring in book sales data alongside each book.

So you set your VLOOKUP up to search for the ISBN number (the book’s serial number) in the sales data table and return the sales value. The inefficiency comes because you’re searching for all your products, not just books, so all those products that have N/a in the ISBN column are still be searched for.

Instead, check first for the ISBN number and then only perform the lookup if you have a valid ISBN.

The formula could look something like this, where you first check that the ISBN lookup value is not equal to **N/a**:

`= IF( A2 <> "N/a", your_vlookup , "Not a book")`

or more generally:

`= IF( test , calculation_if_test_true , output_message_no_calc )`

# 16. Manage expensive formulas with a control switch

Use a control switch cell with the IF statement method from above, to keep things manageable.

Use data validation to create a drop-down menu in a single cell, the control cell, with values “Process” and “On Hold” (or whatever makes sense for you).

Then use an IF formula like this to only process the performance-hungry formulas in your slow Google Sheets when you want to:

`=IF( $A$2 = "On Hold" , "On hold" , `*your_formula_here* )

Here’s an example of this control switch technique applied to some performance-hungry Instagram IMPORTXML formulas (for the top 25 accounts):

# 17. Use Filter, Unique and Array_Constrain functions to create smaller helper tables

The `Filter`

, `Unique`

and `Array_Constrain`

functions all accept ranges (tables) as inputs and return ranges (tables) as outputs, that are smaller than the input tables.

Thus they are useful to create helper tables for further data analysis work.

Say you had a table with 100,000 rows of data in, but were only interested in performing calculations on a subset of that data, then you could use one or more of these functions to reduce the size of your table and create a new helper table for your calculations.

For example, you might use the Filter and Unique functions to create a helper table from a dynamic subset of your larger table:

`=UNIQUE( FILTER( A1:E100000 , B1:B100000 < 100 ))`

or using Array_Constrain to create a helper table from a static subset of your larger table:

`=ARRAY_CONSTRAIN( A1:E100000 , 10 , 4 )`

# 18. Avoid Long Calculation Chains

By long calculation chains, I mean cells that reference each other in a long chain, for example a long column of cells equal to the cell above, like so:

I created a column with 100,000 copies of this formula, referencing the cell above, and it was NEVER able to show all of the formula answers, even though the underlying formulas were showing in the cells.

I had to close the file, wait a moment and re-open to see the completed results.

Interestingly, this blank cell issue always occurred at the 99,100 occurrence of the formula. Here you can see the formula referencing the cell above (A99102) but not showing the value 1 like the cells above are showing:

(I hit this 99,100 limit in all the various chaining tests I did, which makes me think it’s some kind of limit to what Sheets can handle for linked cell calculations.)

It’s slow and may not even complete the calculation under certain conditions.

Aside from that, it’s also very bad practice to chain calculations like this. One error will cascade through the entire chain and it’s also difficult to debug.

A better practice would be to reference a single cell with absolute references and then copy that down your column, e.g.

`= $A$2`

# 19. Reference data on the same Sheet

Referencing data in the same sheet keeps things simple — always a good practice — and saves time because your formulas can access the data more quickly.

Obviously it’s not always practical or convenient to reference data in the same tab of your Google Sheet, but keeping references within your one file will be quicker than using IMPORTRANGE to bring in data form other Google Sheet files.

That said, below I discuss the pros of splitting up large, slow Google Sheets (see no. 21 below) and using IMPORTRANGE to bring them back together as necessary.

# 20. Use helper columns

Tempting as it is to create clever formulas that do everything in one go, there are many advantages to creating helper columns. Not only are they easier to create, they’re easier to follow (for you and colleagues), easier to debug, and they can even be faster sometimes too.

Suppose you have a list of a website’s URLs in column A and you want to quickly extract the path, the part of the URL after the www.website.com address.

You might use this formula in column B:

`=RIGHT( A1 , LEN(A1) - SEARCH( ".com" , A1 ) - 4 )`

Now, since the hostname is the same in each case in this example, we’re needlessly calculating the nested SEARCH function every time.

We could run this once, figure out that our hostname was 24 characters long (and store this in a helper column to ensure best practices), and then replace the SEARCH function with this constant ( 24 digits + 4 digits for the “.com”):

`=RIGHT( A1 , LEN(A1) - 28 )`

# 21. Split your slow Google Sheet into separate Sheets

First of all, it may be time to consider warehousing your data in a proper database and not Google Sheets if you are getting close to that 2 million limit (see no. 27 below).

Assuming we’re sticking with Google Sheets though, it might be time to split up your huge dataset into separate Sheets if your Sheet is so slow that it’s frustrating to use.

This technique should be approached with **CAUTION** though, to avoid data loss. Only do this if you’re confident you know what you’re doing and you’re sure you really need to.

Be aware that this approach comes with a cost also. Before you had one single table to keep track of, to modify, update and analyze, whereas now, if you split it up, you’ll need to keep track of multiple Sheets and ensure that changes and analysis are consistent.

A safe bet for this approach might be to offload prior years of data say, or old products that are no longer in your inventory. In other words, it’s data we don’t envisage using again, but that we want to keep a copy of.

#### How to safely split up slow Google Sheets

The best approach to split up your really big Google Sheets is to make new copies, label each Sheet clearly and then delete all the data apart from the data relevant to that Sheet. For example, if you’re offloading data from 2015 into it’s own Sheet, then here are the steps:

- Make a copy of the master Sheet, with all your data in
- Name this new Sheet and include “2015” somewhere in the title
- Sort the data by year in this new Sheet
- Add a filter and show everything except 2015 data (i.e. hide the 2015 data)
- Delete all these rows
- Remove the filter to leave only the 2015 data

Once you’ve completed all the steps for all your archived data, you’ll want to remove it from your master Sheet. I’d advocate keeping a full copy of your master Sheet before you start deleting any rows of data though.

You’ll end up with a master Sheet that just has your current, or live, data in it, and it’ll hopefully be much faster.

You can also do any calculations or data analysis locally and then bring the data back together in your master Sheet using the IMPORTRANGE formula.

# 22. Use Conditional Formatting sparingly

Conditional formatting is a super nice feature for adding extra context to your Google Sheets, for example highlighting outliers or values above thresholds. I use a lot in my scheduling sheets to highlight the row for the current day for example.

However, it can be very slow on large datasets because it’s implemented on a cell-by-cell basis.

So it’s best used for small data tables and in your presentation tables and dashboard reports.

# 23. Leverage the power of Apps Script

Apps Script is a Javascript based scripting language that can be used to extend the functionality of Sheets (and interact with other Google services). Check out this introduction if you’re new to it.

The possibilities here are extremely broad, encompassing everything from automating repetitive processes to speed up your workflow to creating custom functions to save you typing out complex formulas over and over (see next section).

Apps Script is extremely effective at doing big batches of calculations, especially repetitive ones, often more quickly than thousands of regular formulas.

#### Example

Imagine I have a column of numbers that I want to classify into Small, Medium and Large using a nested IF statement like this:

`=IF( A1 > 500 , "Large" , IF( A1 > 250 , "Medium" , "Small" ))`

This took about 6.5s to compute for 100,000 rows, and about another 30s to copy and paste as values (another best practice for optimizing your slow Google Sheets – see no. 6 above).

Replacing this with Apps Script and running for the same data range took around 16s to paste in all 100,000 values, so less than half the time.

Here’s the code for this function:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
function columnClassifier() { var ss = SpreadsheetApp.getActiveSpreadsheet(); var sheet = ss.getActiveSheet(); var input = sheet.getRange(1, 1, sheet.getLastRow(), 1).getValues(); var output = []; for (var i = 0; i < input.length; i++) { if (input[i][0] > 500) { output.push(["Large"]) } else if (input[i][0] > 250) { output.push(["Medium"]) } else { output.push(["Small"]) }; } sheet.getRange(1,2,output.length,1).setValues(output); } |

Optimizing your Apps Script code is an entirely different and gigantic topic in its own right, so I won’t make any comments in this article. Note however, the current quotas and limitations applied to Apps Script code.

# 24. Use custom formulas sparingly

Custom formulas, also known as user defined functions, or UDFs, are custom functions written in the Apps Script script editor window.

Complex custom formulas will be very slow if you approach them in the traditional function way, and read/write single cells at a time.

For example, consider this custom formula to mark up a product price by 15%:

1 2 3 4 5 6 7 8 9 10 |
/** * Markup a price by 15% * * @param {number} input The value to markup * @return The input multiplied by 1.15. * @customfunction */ function MARKUP(input) { return input * 1.15; } |

which looks like this in use:

Copying and pasting this down 1,000 rows is SUPER slow. It took me about 10 seconds, but it’s also dependent on your wifi connection.

What you need to do with custom formulas, to improve their performance, is think more like array formulas. The slow part of these formulas is the reading from, and writing to, the Sheet, as this happens via the spreadsheet API, so it’s dependent on your wifi connection.

It’s best to minimize the number of read/write calls to your Sheet if you can.

Say you want to perform a calculation on 10,000 cells, then you’ll be better off reading all 10k cells into your function once, performing the calculation and then outputting back to your Sheet in one go, as a range.

For example, change the above formula to this more general one, which accepts a range input and outputs a similar sized range:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
/** * Markup a price by 15% * * @param {number} input The value or range to markup * @return The input multiplied by 1.15. * @customfunction */ function MARKUP_RANGE(input) { if (input.map) { return input.map(MARKUP_RANGE); } else { return input * 1.15; } } |

This will perform the same calculation on 1,000 cells in under a second, which is significantly faster. This is how it works in practice, accepting the whole range as the input now:

**Note:** Custom apps script formulas are recalculated only when their arguments change. Also, these arguments must be deterministic, i.e. not one of the volatile functions like NOW() or RAND(). If your custom function tries to return a value based on one of these, it will display `Loading...`

indefinitely.

Read more about custom function optimization on the Google documentation.

# 25. Other troubleshooting tips for slow Google Sheets

Sometimes it might not be an issue with Google Sheets that’s causing the slow response time. It’s worth trying these strategies to see if any resolve your issues:

> Close and re-open the Google Sheet (sometimes it’s the simplest fixes that work).

> Refresh your browser.

> Clear your cache and cookies.

> Try another browser or operating system. Make sure both browser and operating system are currently running on their latest version.

> Disable browser plugins or extensions.

> If possible, try replicating the issue on another computer to see if it’s the computer hardware having issues. A Google Sheet’s calculation speed depends mostly on the local resources.

> Try replicating your issue on another wifi network to see if it is a network issue. Most functions are run locally in the browser but some, like the IMPORT formulas, require access to the Internet (as well as any Apps Script which is run on Google servers).

> Try disabling and re-enabling offline access.

> Try a faster computer perhaps ¯\_(ツ)_/¯

# 26. Understand changes in the cloud take time to propagate

Remember that if you’re working in real-time with other collaborators, changes can take a few moments to synchronize.

Other users and any apps script files will be seeing a cached version of the Sheet until all the synchronization operations are completed, and this may affect how certain cells appear. For example, they may well have finished calculating in your Sheet but still be showing blank or #N/A in the view a collaborator sees.

Just something to keep in mind, and honestly, it’s a very minor point. In my experience it all happens so quickly that it does feel almost instantaneous, although again really large, slow Google Sheets will suffer from this more.

# 27. Know when it’s time to move to a database

There will come a time, and perhaps you’re already there, when you have to admit defeat and accept that Google Sheets won’t fulfill all of your data needs. For all of it’s strengths, of which there are many, that 2 million cell limit fills up pretty quickly with real-world data.

Well before any of your production Sheets approach the 2 million limit you should think through the next steps beyond slow Google Sheets.

You’re going to want to move your data into a database archive. You can still work in a Sheets environment but offload the data storage to a dedicated database.

#### Google Database Options

Within the Google ecosystem, we’re talking about BigQuery and Cloud SQL, both cloud databases. However, the integration isn’t simply drag-and-drop anymore, so you’ll need development skills to connect these services.

Google BigQuery is integrated with Google Drive, so you can use your Google Sheets as tables in BigQuery. You can also use the BigQuery Apps Script service to manage your BigQuery projects.

Connecting a Google Sheet to Cloud SQL directly requires Apps Script, although you could export data from Google Sheets (e.g. as CSV) and import that into Google Cloud SQL.

Look out for more resources on these topics later this year.

# Conclusion

That’s all folks!

I’ve tried to make this post as exhaustive and as useful as possible, but I’m absolutely sure there are more ideas out there.

I welcome any comments and thoughts on this topic. Think of this post as a living, breathing article to which more will hopefully be added in the future.

Thanks for reading and I hope the insights contained herein have been valuable!

*(This post contains some affiliate links, which means I earn a small commission on any signups for the products mentioned in this post. I only do this with products I personally use and believe in.)*

Great stuff Ben, thank you! Will refer to this article often, both for my own sheets, and in support of users on the Sheets Help Forum.

That “Toggle” idea btw is great. I’ve got a sheet on which, in addition to a the primary duties the sheet performs, there are many tabs that show reports that are only occasionally needed. Since these reports Query or Filter the entire database, I don’t want them running in the background when the user is not even looking. I put a giant ON (in green) / OFF (in red) switch cell at the top of the report, keeping them deactivated when not in use.

Lots to think about here, and I’m going to flip through the structure of my sheets looking for opportunities to apply these ideas. Great stuff Ben!

Best,

Lance

Thanks Lance! Great to hear of your use case for a toggle switch too. Let me know if you have anything to add 😉

Ben,

Brilliant! A very timely article as I attempt to speed up my unwieldy sales tracking spreadsheet. Lots of great ideas to implement!

Thank You!

Bernie

Thanks Bernie!

Thank you Ben, super useful and very helpful information. This post will certainly be part of my “G Sheets how-to reference manual”.

Keep up the great work , looking forward to seeing more advanced Google Script how-to´s and courses!

Cheers,

Thanks Frank!

Great Article Ben.

Thanx for such an exhaustive article. I was indeed looking for such article for some time.

Just a question: Somewhere I read that there is a limitation of number of formula cells to 40,000. I am already have a sheet having more than this so this limit is definitely not correct. But is there actally any limit on the number of formula cells or the only limit is overall number of cells limited to 2 million?

Further is there any script that removes unwanted rows and columns from the sheet?

Yes, that must be an old limit, but it doesn’t exist now. I’ve not heard of a formula cell limit anymore, but I’ll add it in here if I do. For deleting rows you could try this add-on: https://chrome.google.com/webstore/detail/remove-blank-rows-and-mor/gmidogdphchbiehdmbigdbcopkpjpnio?hl=en-US

You could quite easily write a small script to do it yourself too. You’d need to calculate the max rows and the last row with content and then delete those rows.

Hope that helps!

Ben

Dear Ben,

Thanx for the reply.

As you said in the article, I have also observed that normal formulas are speedier than array formulas but then formulas need to be copied every time new rows are added.

To reduce the work I have developed a small script which adds row and then copies the formulas formulas in the new rows. But for each sheet I have to make changes in the script to remove the values from non-formula cells depending on the requirement.

I have not been not able to develop any generic formula that can be used in different sheets.

Can you suggest some way to copy only from formula cells or copy all but then remove values from all non-formula cells.

The script used in one of the sheet is given below:

function AddRows_FOR_sheet() {

var sh = SpreadsheetApp.getActiveSheet();

var s = sh.getActiveRange();

var row_position = s.getRowIndex();

var row_num = Browser.inputBox(‘Adding row below current position’, ‘Enter row numbers to be added’, Browser.Buttons.OK_CANCEL);

var lCol = sh.getLastColumn();

sh.insertRowsAfter(row_position, row_num);

var range = sh.getRange(row_position, 1, 1, lCol);

range.copyTo(sh.getRange(row_position + 1, 1, row_num, lCol), {contentsOnly : false});

}

Perfect! Very relevant! Impressive!

Thanks !

Thanks Sergei

Thanks Ben!!

seriously awesome tips.

Now, i can easily speed up my google sheet and my productivity also.

thanks for posting for us

and save our valuable time in future

Thanks Nitish

Thank you Ben, that’s an awesome post, coming right on time, and tips which are not in many other places.

Thanks Cédric!

Ben,

What would you recommend for hardware to make the sheets calculate as fast as possible. An i7 K series processor? or xeon? have you tried different hardware?

Jason