Decoded GA4 in Steep —
native BigQuery, flat tables,
queries that stay fast.
Steep is a product analytics platform built specifically for BigQuery. It connects natively, no migrations, no exports. The catch is that Steep — like every other tool — is much happier when the underlying table is flat. Decode GA4 turns the nested export into a clean events table that Steep can actually reason about.
Steep was engineered for BigQuery from day one. It does not have to translate dialects or work around external connectors. What it does need is a sensible schema underneath.
Why nested GA4 hurts product analytics tools
Product analytics is mostly about counting events with specific properties. In a nested GA4 export, every property lookup is a CROSS JOIN UNNEST against event_params. Tools that build SQL on the fly — natural-language interfaces especially — generate verbose, slow queries when the schema looks like that. Steep is no exception. Pointed at the raw export, the SQL it writes is correct but expensive.
Why Steep specifically benefits from a flat table
Steep's value is letting non-SQL users ask questions like "page views by country last week" and get an answer in seconds. That round-trip depends on the underlying SQL being short and efficient. With flat columns, the SQL is short and efficient. With nested event_params, it is neither.
What changes with Decode GA4
Decode writes a flat events table into a BigQuery dataset of your choice. Standard parameters — page_location, page_referrer, ga_session_id, geo.country — are direct columns. Steep reads them through its standard BigQuery connector. Natural-language queries map to short, fast SQL. The same dimensions work in custom queries written by your analysts.
The traditional approach
Connect Steep to the raw GA4 export
Register the events_YYYYMMDD table as a source. Every Steep query runs UNNEST under the hood. Natural-language queries take longer to compile and end up scanning more bytes. Custom queries become harder to write because every analyst needs to remember the unnesting pattern.
Build your own flattened table
Stand up a scheduled query or dbt model that flattens GA4 and writes back to BigQuery. Maintain it forever. Update the SQL every time GA4 adds a parameter. Carry the cost of duplicate storage. Steep gets a clean source — you get a pipeline to operate.
Limit Steep to a curated subset of events
Define a tightly scoped staging table that only exposes a few events and parameters, then point Steep at that. Easier to maintain, but you have just shipped the same trade-off Universal Analytics did — pre-decided dimensions and no flexibility for new questions.
Decode GA4 vs raw GA4 export in Steep
| Feature | Decode GA4 source | Raw GA4 export |
|---|---|---|
| Schema Steep sees | Flat events table | Nested event_params records |
| SQL generated for natural-language queries | Short, direct GROUP BY | CROSS JOIN UNNEST per property |
| Bytes scanned per query | Pruned by partition + column | Inflated by repeated records |
| Custom SQL readability | Standard BigQuery SQL | UNNEST gymnastics required |
| Handling new GA4 parameters | Auto-detected upstream | Manual schema work |
| Maintenance over a year | Zero | Recurring schema fixes |
Install once via Marketplace, register the decoded events table as a Steep data source, write the kind of SQL you would expect.
- [ 1 ]
Subscribe via Google Cloud Marketplace
Decode GA4 is a single Marketplace listing — usage-based, no monthly minimum, billed through your existing GCP invoice. Subscription takes about a minute.
- [ 2 ]
Deploy the events_external template
Pick a BigQuery dataset, run the installer. Decode writes a flat external table called events into it. Every standard event parameter is a direct column.
- [ 3 ]
Connect Steep to BigQuery
In Steep, go to Settings → Data Sources → BigQuery. Provide the GCP project ID and a service account JSON with BigQuery Data Viewer plus Job User. Register the decoded events table as a source.
- [ 4 ]
Query in Steep
Use Steep's natural-language interface or write SQL directly. A query like select partition_date as event_date, event_param.page_location, count(*) as pageviews from your-project.your_dataset.events where event_name = 'page_view' group by 1, 2 order by 1 desc reads cleanly and runs fast.
HOW THE SETUP WORKS
Wire decoded GA4 into Steep in four steps. Steep handles the connection. Decode handles the schema. Nothing custom in the middle.
GCP
Run the Decode GA4 installer with the events_external template. Note the destination dataset.
GCP
Create a service account with BigQuery Data Viewer and Job User on the project.
Steep
Add a BigQuery data source with the project ID and service account JSON.
Steep
Register the decoded events table and start asking questions in SQL or natural language.
Steep reads the events table through a service account in your project. The data never leaves BigQuery — Steep is the query layer, not a copy. Same access controls you already have on the warehouse.
What you get in Steep
Natural-language queries that scale
Steep's NL layer turns into short, efficient SQL because the schema is flat. Ask for "page views by country last week" and you get the answer fast, not after a slot warm-up.
SQL you would write yourself
Custom queries in Steep look like normal BigQuery SQL — group by partition_date and event_param.page_location, count, done. No CROSS JOIN UNNEST, no correlated subqueries.
Predictable BigQuery costs
Flat columns plus partition pruning means the bytes scanned per query are visible and stable. The bill behaves the way the cost calculator suggested it would.
Native BigQuery, no exports
Steep was built for BigQuery. There is no second copy of your data, no syncing job, no separate access model to manage.
Schema evolution that just works
When GA4 adds a new event parameter, the next decode run picks it up. Steep sees the new column on the next query — nothing to update by hand.
Same source for every other tool
The decoded events table works as a source for dbt, Looker Studio, Rill, and every other BigQuery-aware tool. Steep is one consumer of many on the same upstream.
Self-serve product analytics
PMs and growth analysts ask Steep questions in plain English and get answers backed by real BigQuery queries. Decoded events keep those queries short, which keeps the round-trip under the threshold where people stop bothering to ask.
Funnel and retention analysis
Standard funnels — view_item, add_to_cart, begin_checkout, purchase — read as case statements over event_name. Retention cohorts read as joins on user_pseudo_id. The SQL Steep generates is short enough to debug if something looks off.
Custom event parameter exploration
Product teams who instrument their own event parameters — feature flag, plan tier, A/B variant — see those parameters as direct columns the moment they start firing. No staging table to update before the new dimension is queryable in Steep.
Does Steep need a service account in my GCP project?
Yes. Standard BigQuery practice — a service account with BigQuery Data Viewer and Job User on the project, JSON key uploaded into Steep's data source settings. Nothing Decode-specific. See setup →
Will Steep's natural-language queries break when GA4 adds new parameters?
No. The decoded events table picks up the new parameter as a new column on the next decode run. Steep sees it on the next query. The natural-language layer treats it like any other dimension.
Can I keep my existing dbt models alongside Steep?
Yes. Steep reads the decoded events table directly, but it does not own it. Anything else that consumes the same table — dbt, Looker Studio, custom SQL — keeps working unchanged. Full prerequisites →
What does this cost in BigQuery?
Decode runs are priced through Marketplace. Steep queries run as standard BigQuery jobs, billed by bytes scanned. Because the events table is partitioned and the columns are flat, queries scan less than they would against the raw export. Most small sites land in the $3-8/month range combined.
Deploy in under 5 minutes
Steep on a schema
that does not fight back.
Subscribe via Google Cloud Marketplace, point destination_dataset_id at the dataset Steep reads, and start asking real questions of your GA4 data with SQL that fits on one screen.
Google Cloud Marketplace · Usage-based · No monthly minimum