Where the time goes
Every chart, control and table on a page is at least one query to its data source, issued when the page opens and again whenever a date range or filter changes. The time a viewer waits is the sum of three things: the number of queries the page sends, the time the slowest source takes to answer each, and whether any of those answers were already in the cache. Looker Studio renders charts as their results arrive, so a page with one slow chart looks finished while the viewer waits for the piece they actually wanted.
The sources differ enormously in answer time. A spreadsheet is read in full on every query and slows as it grows. The Google Analytics and Google Ads connectors are bounded by their APIs, which impose per-property and per-account quotas rather than raw speed limits. BigQuery answers in proportion to the bytes it scans, which depends on how the table is partitioned and how much of it the query touches. Partner connectors add a hop to the vendor's servers and sometimes a sync delay on top.
Diagnosis starts by opening a slow page and noting which charts arrive last; those point at the source and the query shape to fix. The data sources guide describes the layers involved; this page assumes the sources are sound and the problem is how much the report asks of them. Keep in mind the audience too: a KPIA metric tied directly to an objective. page opened by a dozen people every morning sends a dozen times the queries of a page opened once a week, and viewer count is a lever as real as chart count.
Caching behaviour
Looker Studio keeps a cache of query results, and a chart whose query matches a cached result is drawn from it without touching the source. How long a result stays usable is governed by the data freshness setting on each data source; the choices offered depend on the connector, and the help centre documents the defaults and ranges. A viewer who needs the newest data can refresh the report, which bypasses the cache for that session, and editors can shorten the freshness window for sources that genuinely change by the minute.
In practice two things decide whether the cache helps. The first is the freshness setting: a short window means the cache expires before the next viewer arrives, and every open becomes a cold load. Most marketing data changes once a day, after platforms finalise the previous day's figures, so a freshness window measured in hours loses nothing and saves a great deal. The second is query identity: a result is reusable only for the same chart, date range, filters and credentials. A page whose viewers each pick their own date range is a page whose cache is rarely hit. Defaulting controls to a shared, sensible period — month to date, last complete week — makes most opens identical and therefore cached.
Credential mode matters here as well. With owner's credentials, every viewer's query is the same query, so one viewer's cold load warms the cache for the next. With viewer's credentials, each viewer's results are fetched as them and, in practice, are not shared, so the report pays a cold load per person. Google does not document every detail of cache sharing, so treat this as the pattern observed rather than a guarantee, and test with a colleague's account before relying on it.
Extract data sources
An extract data source is a snapshot: you choose an existing source, pick the dimensions and metrics to keep, optionally a filter and a date range, and Looker Studio stores the result and serves reports from that copy. The extract can be refreshed automatically on a schedule, and there is a documented ceiling on how much data one extract can hold. Because queries hit stored data rather than a live connector, charts answer quickly and consume no API quota.
Extracts suit data that is aggregated and stable: daily campaign cost and conversions, weekly organic clicks by landing page, monthly revenue by market. They suit it especially when the live connector is slow or quota-bound, which makes them the first structural fix for a busy analytics or advertising report. They do not suit intraday monitoring, event-level data, or anything that would exceed the limit once the date range grows. An extract also freezes the schema at the fields you chose; a chart that needs a new dimension needs the extract rebuilt.
The practical pattern is to extract at the grain the page actually uses. If every chart on a page groups by campaign and date, extract campaign, date and the handful of metrics, and nothing else; the extract is small, the refresh is quick and the queries are trivial. Keep the live source connected on a separate detail page for the rare viewer who needs today's figures, so the extract carries the daily audience and the live source carries the exceptions. When a page on an extract keeps showing the same figures day after day, the diagnosis for a Looker Studio report that is not updating works out whether the extract, the cache, a warehouse load or the source itself has stopped moving.
Reducing queries per page
The cheapest performance gain is sending fewer queries. Count the elements on a slow page: every chart, every scorecard, every filter control that lists values from the data, every table. Each is a query, and a page assembled by adding "one more view" over months typically carries far more than its question needs. Remove charts that do not help answer the page's question, merge several scorecards into one table where a reader scans rather than reads, and move detail tables to a separate page so they load only when wanted.
Controls deserve particular attention. A drop-down list populated from the data queries the source to fill its options, and six of them on a page is six queries before the viewer has done anything. Prefer fixed-list or input-box controls where the values are known, and cut controls that nobody uses. Pages matter too: Looker Studio queries only the page being viewed, so splitting a long page into several short ones divides the load rather than multiplying it, and gives each page one question.
Report-level elements are the exception to watch: a chart or control placed at report level is drawn, and queried, on every page. Use report level for the date control and perhaps one filter, not for a row of scorecards. Finally, check the date range: a chart defaulting to a year of daily rows scans and transfers far more than one defaulting to the current month with a comparison, and the viewer who wants the year can select it.
| Technique | What it reduces | Trade-off |
|---|---|---|
| Remove charts that do not answer the page's question | Queries per open | Someone will ask where their chart went; point them to the detail page |
| Split long pages into one question per page | Queries per open | Navigation between pages |
| Replace data-driven drop-downs with fixed lists | Control queries | Lists need updating when values change |
| Default date controls to a shared period | Cache misses | Viewers wanting other periods change the control |
| Lengthen data freshness to match the source's real update cycle | Source queries | Figures can lag by up to the window |
| Extract stable, aggregated data | Source queries and quota use | Schema is fixed; a size limit applies |
| Move blends into a warehouse table | Queries per chart | Someone must own the scheduled query |
| Pre-aggregate in BigQuery to the page's grain | Bytes scanned, answer time | Modelling work; a second table to maintain |
Blends, calculated fields and filters
A blend queries every table it joins, separately, each time a chart using it loads; a chart on a blend of four sources is four queries plus a join performed in Looker Studio. Several charts on the same blend repeat the work. Blends are also where fan-out lives: a grain mismatch that multiplies rows multiplies the data transferred and joined before it multiplies the wrong totals. The blending tutorial covers building a blend correctly; for performance the rule is to keep blends few, keep their dimensions minimal and move any blend that appears on more than one page upstream into a single table.
Calculated fields cost little when they are simple arithmetic on aggregated fields, and more when they apply regular expressions or CASE logic to every row of a large dimension. A regular-expression grouping over hundreds of thousands of campaign rows is evaluated on each query; the same grouping computed once in the source — a warehouse column or a sheet lookup — is free thereafter. Chart-level calculated fields on blends are the most expensive combination, because they run after the join on the client. A conversion rate such as CVRShare of visits or clicks that convert. written as a ratio of sums is cheap; the same ratio recomputed per row and then averaged is both wrong and slower.
Filters have two costs. Filters that the source can apply before returning rows — a date range, a dimension equals a value — reduce data transferred and are nearly free. Filters that depend on a calculated field, especially a regular-expression match, can force the source to return everything so Looker Studio can filter it afterwards. Where a filter is used on every page, push the condition into the source: a warehouse view, a sheet column or a connector-level filter in the data source settings, so the rows never leave the source at all.
Quotas and connector limits
Connectors backed by product APIs have quotas, and Looker Studio consumes them on the viewer's behalf. The Google Analytics connector draws on the analytics Data API's documented per-property quotas; the Google Ads connector on its API's limits; Search Console and YouTube on theirs. When a quota is exhausted, charts show an error rather than old data, usually at the busiest moment of the day, and the error persists until the quota window resets. Google documents the quota sizes and the error messages in each product's developer and help pages; this guide does not reproduce the figures because they change.
Quota consumption scales with queries, so every technique above reduces it: fewer charts, shared defaults, longer freshness, extracts. Two further points are specific to the GA4Google's event-based analytics platform. connector. Requests for many dimensions and metrics in one chart, or across long date ranges, are costlier than simple ones, so a wide detail table is the first thing to extract or remove. And the paid analytics tier carries larger quotas, which is an answer available to large organisations and not to most.
Spreadsheet sources are limited differently: a sheet is read in full on each query, so size and formula complexity, not an API, set the ceiling, and a sheet that grows daily will one day stop answering in time. Partner connectors publish their own limits, often per plan. In every case, design the report as if the limit were lower than documented, because the documentation describes the connector alone and the report shares the quota with every other report on the same property.
A quota-bound GA4 report rebuilt for speed
An e-commerce team's trading dashboard failed with quota errors most weekday mornings. The report had 42 charts across six pages, 11 filter controls populated from the data, four blends, and the GA4 connector set to refresh every 15 minutes; about 30 people opened it before nine o'clock, each choosing their own date range. The rebuild extracted daily campaign, channel and landing-page aggregates into three extract sources refreshed nightly, cut the pages to 16 charts, replaced the data-driven drop-downs with fixed lists for market and device, defaulted every date control to month to date, and moved the two blends that fed the headline page into a scheduled BigQuery table. Cold page loads fell from around 40 seconds to about six, quota errors stopped, and the live GA4 source remained on a single detail page for the merchandising analyst who needed intraday figures.
Moving to a warehouse source
At some point the fastest Looker Studio report is one that barely computes anything: it reads a table that already holds the answer at the grain the page needs. That is what a warehouse source provides. The analytics export into BigQuery, described in the BigQuery export basics guide, delivers event-level rows that are unsampled and free of connector quotas; a scheduled query turns them into a small daily table of sessions, conversions and revenue by the dimensions your pages use, and Looker Studio queries that table in a fraction of a second.
The gains come from the modelling, not from BigQuery itself. A chart pointed at the raw event tables scans every event in the date range on each query and costs money for the privilege; partitioned, pre-aggregated reporting tables scan a little and answer fast. The same pattern suits advertising data landed by scheduled transfers and CRM data exported nightly: one reporting table per question, joined and aggregated on a schedule, so no blend runs in the report. This is also where the metrics layer becomes concrete, because the scheduled query is the definition, and every report reads the same one.
A warehouse source introduces costs of its own. Someone must own the queries, watch them when exports change, and pay the storage and query bills, which are modest for marketing-scale data but not zero. BigQuery's acceleration features can help with repeated queries; what helps most is a reporting table small enough that acceleration is barely needed. Move to a warehouse when quota errors, slow blends or disputed definitions are costing more than that ownership would; keep direct connectors for the reports that have none of those problems. When an existing report makes that move, the tutorial on moving a Looker Studio report onto a warehouse rebuilds it on one reporting table and reconciles the figures before viewers switch.
Common mistakes
- Short freshness on data that changes once a day. The cache expires before anyone benefits from it.
- Every viewer choosing a different date range. No two opens share a query; set a shared default.
- Report-level scorecards. Queried on every page, including the pages where nobody looks at them.
- Drop-downs populated from the data for every dimension. Six queries before the viewer has clicked.
- One blend copied across five pages. Each chart re-runs the join; move it upstream.
- Regular-expression filters on large dimensions. The source returns everything and Looker Studio filters it afterwards.
- Querying raw event tables from Looker Studio. Scans the whole range on every open; aggregate first.
- Blaming the connector before counting the charts. Most slow reports are slow because of what they ask, not what they ask it of.
The Looker Studio hub links the rest of the series, and the data sources guide is where to confirm that the sources themselves are configured sensibly before optimising the report that reads them.
