Do I Need an MMP? SKAN + Warehouse vs a Full MMP
The short version: whether you need an MMP is a scale question, not a matter of principle. A lean single-network iOS shop sitting under Apple's crowd-anonymity thresholds can run on SKAN plus BigQuery and skip the fee entirely. Once you add networks, re-engagement, Android, and ROAS-gated bidding that leans on modeled LTV, the engineering burn quietly overtakes what an MMP charges. So the answer flips at a breakpoint you can actually locate.
Let me walk through where that breakpoint sits, why it moves, and what you're really paying for on either side.
The partner report that changed how I read numbers
A network once handed me conversion values that had drifted away from what Apple actually sent. Nothing dramatic. A coarse bucket where a fine one belonged, a couple of values nudged in a flattering direction. I'd been treating those partner dashboards as ground truth, and that quiet mismatch is what broke the habit.
That gap is precisely what postback-copy validation exists to close. It's not a compliance checkbox. It's the line between paying for installs Apple attributed and paying for installs a network decided to report. AppsFlyer's own SKAN solution guide states it directly: receiving postback copies lets them verify that conversion values in postbacks haven't been manipulated. When people argue the MMP is dead, this is the unflashy work they forget someone still has to own. Keep it in mind, because in a DIY stack that someone is you.
What iOS actually emits
Get the plumbing straight before deciding anything, because a lot of the "you don't need an MMP" chatter misdescribes what the OS sends.
In plain terms: a user taps an ad, the network signs it with a SKAdNetwork identifier, and if an install wins attribution, Apple runs the attribution and fires the postback. Per Adjust's SKAdNetwork documentation, that's one postback per user carrying the final, highest conversion value, with no device-level identifier recorded or shared. No IDFA. No user-level join key you can build on.
SKAN 4 widened the pipe without changing that basic shape. Adjust's breakdown of how SKAN 4 works explains that for iOS 16.1 and ads signed under SKAN 4, you can receive up to three postbacks per winning attribution, each tied to its own window, extending measurement across days 0-2, 3-7, and 8-35.
So both paths, DIY and MMP, start from the same raw feed: a thin stream of anonymous postbacks, up to three per install, spread over 35 days. Everything past that is assembly.
Where the signal thins out
Here's the catch. SKAN 4 doesn't deliver those postbacks at full fidelity. AppsFlyer's SKAN 4 strategy writeup describes four crowd-anonymity tiers numbered 0 through 3, and your campaign's tier tracks its volume. Fall below Apple's undisclosed threshold and Apple begins stripping detail: the fine value, the coarse value, the source identifier, and the source app identifier can each drop out depending on how anonymous your cohort looks.
The fine-grained value is the one worth having. Admiral Media's analysis of SKAN conversion values says it flatly: the fine 0-63 value only arrives in the first postback, and only when crowd anonymity permits, while windows two and three return coarse values at best. Your richest signal lands in the first 48 hours, if your campaign clears the bar at all.
Then nulls. AppsFlyer's SKAN overview notes the conversion value is six bits, giving 64 possible values, and Apple sometimes withholds the real value and returns null to protect privacy. True lifetime value is never directly observed. That's the hand you're dealt: sparse, coarse, and full of gaps.
What "SKAN + warehouse" actually costs
The first myth to bury is that compute is the expense. It isn't. Ad platforms can pipe raw SKAN data into BigQuery, and per CLIMB's writeup of the free tier, on-demand query pricing runs $6.25 per TiB scanned with the first 1 TiB each month free. Google Cloud's own pricing page adds a 300 TiB-per-month bytes-read allowance per billing account under on-demand pricing. SKAN postback volumes are trivial by warehouse standards, so at the scale most apps operate, storage and query cost effectively rounds to zero.
The real bill is engineering time, and it's the line item nobody puts on a quote.
The hours nobody quotes you
Think about the standing work rather than the compute meter. You need a conversion-value schema: what your 64 buckets mean and how you re-derive an LTV proxy from them, revisited every time monetization changes. You need to parse the SKAN payload and handle three windows correctly. You need to dedupe network-reported installs against Apple's postbacks so each install counts once. And the hard one is turning a null or a coarse bucket into a usable estimate.
None of that is a one-time build. SKAN keeps shifting, and AdAttributionKit is arriving as its successor, so a good slice of the effort is maintenance that never ends.
Frame it like any measurement overhead. Build cost is roughly fixed. An MMP fee is roughly variable, scaling with spend. That contrast is the entire argument, because DIY gets cheaper per dollar as you grow while the fee climbs alongside you. The two lines cross somewhere, and finding where is the whole exercise.
What the fee buys on top of raw SKAN
So what does an MMP add? Here's the honest inventory, stripped of the pitch.
Postback-copy validation is first, the thing I opened with. AppsFlyer receives postback copies directly and checks conversion values against manipulation. You can reach for this in a warehouse, but only if the network agrees to send you copies and you write the reconciliation yourself.
Beyond that sits the conversion-value schema tooling, the Conversion Studio-style interface that lets a marketer redefine the 64 buckets without shipping an app update. Cross-network aggregation lands SKAN from many sources into one comparable frame. Single-source-of-truth dedupe reconciles across those networks. A modeling layer converts nulls and coarse windows into an LTV estimate you can bid on.
A warehouse hands you raw materials for all of it, but none arrive assembled. What the MMP actually sells is the assembly, plus the upkeep as SKAN keeps moving underneath. Our reference architecture for a privacy-first stack maps where each of these pieces sits if you want to weigh the decision component by component.
Which path wins, by stage
Here's the framework I'd hand a team asking the question. Read it against your current stage, not the one you're pitching investors.
| App stage / scale | Recommended path | True cost driver | Why the breakpoint flips |
|---|---|---|---|
| Pre-scale, single-network iOS, below crowd-anonymity thresholds | DIY: SKAN + warehouse | Engineering hours; near-zero compute | So little signal survives that heavy tooling has nothing to model; you're mostly counting postbacks |
| Multi-network growth, still iOS-first | MMP starts winning | Cross-network dedupe and aggregation you'd otherwise hand-build | Every added network multiplies reconciliation and postback-copy validation |
| Re-engagement + owned media + Android | MMP | Deterministic Android signal, deep links, owned-channel joins | SKAN doesn't cover Android; you now need Play Install Referrer and deep-link routing DIY can't cheaply assemble |
| LTV-modeling-dependent (ROAS-gated bidding) | MMP | ML on null/coarse conversion values | Modeling nulls into reliable LTV is a standing R&D cost, not a one-time build |
What the table really encodes is signal density and signal spread. The lower rows have more sources, more channels, and more modeling, which means more assembly. That assembly is the thing an MMP owns for you.
Reading the breakpoints
Under the crowd-anonymity thresholds, with one network and no deterministic Android or owned-media need, self-serve wins cleanly. Apple strips so much detail that a model has almost nothing to work with. You count sparse postbacks, re-derive a simple LTV proxy, and a capable data engineer handles it in a warehouse without much fuss.
The line crosses when three forces grow together. Network count rises, so cross-network dedupe and per-network postback-copy validation turn into recurring work. Re-engagement and owned media arrive, which means you need deterministic Android signal, and the Google Play Install Referrer still works well there, plus deep-link routing SKAN never touched. Then ROAS-gated bidding starts demanding modeled LTV from null and coarse values, which is ongoing research rather than a finished build.
Past that point the fixed fee beats the growing burn. Not because DIY became impossible, but because it stopped being the cheaper option. If you do switch providers, our MMP migration playbook covers moving without a measurement gap, and it's worth a read before you're already mid-migration.
The middle is a spectrum
None of this is heavy-MMP-or-bust. Between full DIY and a heavyweight attribution suite there are lighter products. Kixo, for instance, pairs attribution and deep links including deferred deep links with product analytics in one platform, which fits teams that want more than a raw warehouse without signing the largest MMP contract.
Where you land comes down to how much of the assembly you'd rather own than rent. Treating that as a spectrum, not a switch, is how you avoid overpaying in either direction.
My call
The rule I'd act on today: if you're a single-network iOS shop under the crowd-anonymity thresholds, with no Android and no owned-media joins, build it on SKAN plus BigQuery. The signal is too thin to justify a fee and the compute is basically free.
The moment you add a second serious network, or re-engagement, or Android, or ROAS-gated bidding that needs modeled LTV, buy. Not out of loyalty. Because the engineering burn has already slipped past the fee, and postback-copy validation starts earning its keep the first time a partner's numbers stop matching Apple's.
Whichever path you pick, someone has to check Apple's postbacks against what your networks claim. That job doesn't vanish when you skip the MMP. It just lands on your desk.
FAQ
Do I need an MMP if I'm iOS-only and running one network? Probably not yet. Below Apple's crowd-anonymity thresholds, so little fine-grained signal survives that a warehouse pipeline captures most of what's on offer. Compute is trivial. Your only real cost is engineering hours.
Is BigQuery actually cheap enough for a SKAN pipeline? Yes. Per CLIMB's writeup, on-demand queries run $6.25 per TiB scanned with the first 1 TiB monthly free, and Google Cloud adds a 300 TiB-per-month bytes-read free tier. SKAN volumes are tiny against those allowances.
What can't a warehouse do that an MMP does? Out of the box it won't validate postback copies against manipulation, aggregate and dedupe across networks, or model null and coarse conversion values into LTV. You get the raw materials, not the assembled system.
Does Android change the answer? It does. SKAN is iOS-only, so Android measurement leans on the Play Install Referrer and deterministic signal a SKAN-plus-warehouse stack doesn't cover. Adding Android is one of the clearest triggers to buy rather than build.