Dilshat Rakhimov
July 2026 · 12 min read

The question always arrives in the same shape: "we already have GA4 — do we actually need Amplitude?" And it's the wrong question, because the two tools don't answer the same thing, and because in every superapp project I've worked on the tool was never the expensive part. The taxonomy was.

I've done this from both ends. I've cleaned up an Amplitude install at a bank insurance business that was sending 200+ event types with 18-plus naming prefixes, and I've written the vendor-selection memo for a fintech that dropped Amplitude over price and needed somewhere to land. Neither project turned on a feature comparison. Both turned on how many events the product genuinely emits, where the data has to physically live, and who was going to own the schema afterwards.

So this is the honest version: where GA4 actually breaks at superapp scale, what Amplitude is really charging you for, and how to tell which side of that line you're on.

GA4 vs Amplitude cover

They answer different questions, and it's not a subtle difference

GA4 is an acquisition and session tool with an ads integration bolted to the front of it. It's excellent at "which campaign, which channel, which landing page, what did that cost" — and it's the only tool in this comparison that natively feeds Google Ads bidding. That is not a small thing when a meaningful slice of your budget sits in App campaigns and Performance Max.

Amplitude is a user-centric event store with a product team's questions baked into the UI: funnels with arbitrary step ordering, retention curves, behavioural cohorts, path analysis. Its unit of thought is a person moving through a product over weeks, not a session with a source attached.

In a superapp, both questions are live at once, and they're asked by different people. Marketing needs channel truth. The product team needs to know why 115,000 claims-flow errors a month are happening on one step. Those are not the same query, and pretending one tool covers both is how you end up with a GA4 property nobody in product opens and an Amplitude project nobody in marketing trusts.

The real decision isn't GA4 or Amplitude. It's whether the second tool earns the taxonomy work it forces you to do.

Where GA4 actually breaks at superapp scale

Not in the UI — in the quotas. These are the standard-property limits, and every one of them is documented:

LimitGA4 standardGA4 360
Event-scoped custom dimensions50125
User-scoped custom dimensions25100
Event parameters per event25100
Audiences100400
Data retentionup to 14 monthsup to 50 months
BigQuery daily export1M events/daybillions/day
Sampling threshold in explorations10M events per query1B events per query

Read that custom-dimension row against a real superapp schema. The taxonomy I built for a bank insurance line runs on a mandatory product_type with 23 possible values, plus around 16 flat properties that analysts genuinely segment by — screen_name, step_number, step_name, error_type, error_severity, error_source, payment_method, and so on. In GA4, every property you want to break a report down by has to be registered as one of your 50 event-scoped custom dimensions. One product line eats a third of the budget. A superapp has thirteen of them.

Then volume. On that same property, the top event alone was 11.2M page views in 30 days, and api_error was another 4.5M. The full stream runs comfortably past 20M events a month. The free BigQuery export is capped at 1 million events per day — so on a standard property the raw export, which is the one part of GA4 you'd genuinely want at that scale, silently stops being complete. Streaming export has no volume cap but is billed per gigabyte, and it doesn't give you the same daily tables.

And cardinality: any dimension that goes wide — full URLs, ids, free-text error strings — gets bucketed into an (other) row once the daily unique-value limit is passed. On a product where the interesting question is which of 80 photo-upload failures is spiking, that's the exact data you lose.

GA4 360 lifts all of it. It's also not published as a self-serve price; the figure that circulates in the market is entry around $50k/year, negotiated. Which means the honest framing of "GA4 is free" is: GA4 is free until your event volume makes it not a database, and at that point the fix costs more than the Amplitude plan you were avoiding.

What Amplitude is actually charging you for

Amplitude's public pricing moved to event volume rather than tracked users. As of July 2026 the free tier is 2M events/month, Plus starts at $0 with the first 2M events free and scales up to 70M events, and Growth and Enterprise are quoted on volume. Seats are unlimited on all of them, and the extras — session replay, experiments, guides — are priced as add-on packages layered on the platform plan.

Two consequences that matter more than the sticker.

First: your bill is your taxonomy. The install I inherited was sending 30-plus variants of a single payment event, a generic client-side payment at 154K/month, a stray revenue_amount at 94K/month, and 80-odd separate events for one photo-upload step. Consolidating that estate into 35 events — one screen_viewed, one technical_error with severity and source as properties, one payment_completed sent server-side after the payment-gateway callback with the Revenue API fields inline — cut the event count hard and made the reports answerable. On event-based pricing, schema hygiene is a line item, not a nicety.

Scattered event types consolidating into one ordered schema

Second: the cost cliff is real, and it isn't always worth climbing. A Kazakh auto-lending fintech I wrote a selection memo for had already left Amplitude on price. 22,000 MAU, 40–60 events per user per month, so roughly 0.9–1.3M events a month. Small, by superapp standards. The recommendation was not "go back on a bigger plan" — it was to re-run the choice from scratch, because two constraints dominated: a hard zero budget, and a data-residency question that a regulated lender in Kazakhstan can't wave away. Self-hosted PostHog came out on top (one VM at that volume, product analytics plus session replay plus feature flags in one box, data physically in-country), with Mixpanel's free tier as the no-DevOps fallback. That memo is a recommendation, not a shipped migration — but the reasoning is the point: at 1M events/month with a residency constraint, neither GA4 nor Amplitude was the right answer.

Whatever you pick, the thing that survives vendor changes is the schema. Tools get swapped. A clean 35-event taxonomy with flat properties ports in a week; a 200-event mess ports never.

The mistake that costs more than either licence

Sending the same broken taxonomy into both tools.

I've walked into installs where GA4 and Amplitude each received their own hand-rolled event stream, with different names for the same user action, nested property objects (data.event_info.utm.*) that neither tool can segment on cleanly, and national ID numbers sitting in raw event properties in plain text. The reconciliation meetings that follow are unwinnable, because there is no version of the truth — just two tools disagreeing.

The fix isn't a tool. It's four decisions, made once:

  • One schema, flat properties. Root-level utm_source, not data.event_info.utm.source. Everything that routes reports — product_type, step_name, is_success — is a first-class property with a declared type.
  • Money server-side. payment_completed fires from the backend after the gateway callback, with an idempotency key, never from the browser. It's the only payment event, and it carries revenue.
  • No PII in the analytics tool. Analytics gets a UUID. The CRM holds the UUID→identity mapping. Joins happen in BI under role-based access. That's the pattern I've shipped, and it's the one thing regulators actually check.
  • Governance switched on. Planned-schema enforcement, property type validation, alerting on unplanned events, and an automatic block on any field matching a PII pattern. Amplitude has this natively; in GA4 you approximate it with a tag-manager review process and a lint step.

Do those four, and the vendor question gets much smaller — which is the real reason I always argue the taxonomy first.

When to pick which

GA4 alone is enough when: you're web-first or Google-Ads-first, under roughly a million events a day, and the questions being asked are channel, campaign, and landing-page questions. If no one in product is asking for D7 retention by cohort, a second tool is a subscription you'll spend eighteen months justifying. Put BigQuery under it on day one anyway.

GA4 + Amplitude when: you're multi-product (a superapp is by definition), a product team owns funnels and retention as their daily instrument, you need cohorts sliced by product_type across a dozen product lines, and — non-negotiably — someone has been named owner of the event schema. GA4 keeps the ads integration and channel truth; Amplitude carries the product questions. Both feed the warehouse.

Neither, look at a third, when: budget is hard-capped, or data has to stay in a specific jurisdiction, or you want product analytics plus session replay plus feature flags without three contracts. That's the self-hosted PostHog case, and at 20–100k MAU it runs on a single VM. Mixpanel's free tier is the low-effort alternative if you can live with US-hosted data.

And in every one of these cases: the warehouse sits underneath. GA4 exports to BigQuery, Amplitude exports to the same place, the MMP lands raw data next to them, and the arbiter of any disagreement is a SQL table you own rather than a vendor's dashboard. That part isn't a preference — it's what keeps the whole stack replaceable.

The takeaway

GA4 is free until superapp volume turns its quotas into your architecture: 50 event-scoped custom dimensions against a 23-value product catalogue, a 1M-events-per-day free BigQuery export cap against a stream doing 20M a month, and an (other) bucket swallowing exactly the high-cardinality field you were investigating. Amplitude answers the product questions GA4 structurally can't, and it prices on events — so a 200-event estate is both a bad report set and a bigger invoice than the 35-event version of the same product. Fix the taxonomy first: it's the only asset in this comparison that survives changing your mind about the tool.

If you're not sure which side of the line you're on, three numbers settle it faster than any vendor demo: your real monthly event volume, how much of your custom-dimension budget is already spent, and how many variants of your payment event are live in production right now. That count is the first hour of a tracking audit, and you can do it yourself before you talk to anyone.

Sources