You Can Self-Host Your Mobile Attribution Stack Now. Here's What It Costs, and What You Give Up.

If you're reading this, there's a decent chance the renewal email arrived this quarter. Branch, AppsFlyer, or Adjust. The new number is bigger than the old one. A lot bigger.

The conversation that follows is always the same. Marketing says we need the data. Finance says we need to cut the line item. Engineering, quietly, says they could probably build it.

For a long time, engineering was wrong. The infrastructure was hard, the SDKs were harder, and the ad-network integrations were a mess nobody wanted to touch. In 2020, "we'll build our own" was a yellow flag.

It's 2026 now and the math has shifted. This post is the version we wish someone had handed us when we were the team staring at a renewal email: what self-hosting an attribution stack actually costs, what it does well, and what you lose when you stop paying the bill.

Why this is a 2026 question, not a 2020 question

A few things changed in the last 18 months.

Firebase Dynamic Links shut down on August 25, 2025. The free fallback option is gone. Every team that was holding out on FDL because it was good enough is now in the market. The shutdown also flushed thousands of how-to articles and Stack Overflow answers to the surface. The deep-linking problem space is more documented today than it has ever been.

Branch and AppsFlyer pricing has moved upward faster than most teams' growth. Tier-hopping at renewal (where a 20% increase in MAU triggers a 60% increase in bill) is now the standard story. The "free" Branch tier still exists; the line where you fall out of it does not move in your favor.

EU and California privacy enforcement keeps getting sharper. Teams that used to wave away the data-residency question now have legal asking specific questions about where attribution data lives, who has access, and what gets sent to ad networks.

The open-source mobile attribution stack actually works now. SDKs for iOS, Android, React Native, and Flutter exist in production-grade quality. Self-hostable backends exist. Self-hostable dashboards exist. None of that was true three years ago.

Cloud infrastructure costs have dropped at the bottom of the curve. AWS in particular has pushed prices down on the foundational services (EC2 with Graviton, RDS, ElastiCache Serverless, S3) and the entry tier for a production web app is meaningfully cheaper than it was even two years ago. A small AWS footprint that would have been $400/mo in 2022 is closer to $150/mo today.

Put it together and the picture changes. Self-hosting is no longer a 12-week engineering project gated on building everything from scratch. It's a deployment decision and a trade-off decision.

What you're actually paying Branch, AppsFlyer, or Adjust for

Before deciding if self-hosting makes sense, you have to know what you're cancelling. The value of an MMP (mobile measurement partner) falls into roughly seven buckets.

1. SDK distribution and maintenance. Keeping a binary that works across every iOS and Android version, every Xcode build, every React Native upgrade. This is not trivial work. It's also commoditized at this point; every major MMP and several open-source projects do it well.

2. Link-redirect infrastructure. The CDN that handles the click between a user tapping yourapp.link/abc and arriving at the App Store. Sub-100ms is the bar. There's real engineering here, but it's a solved problem and the unit cost has collapsed.

3. The attribution engine. The thing that matches a click to an install. Two flavors: deterministic (when device IDs survive the install) and probabilistic (fingerprinting via IP, user agent, timestamp, screen size). The MMPs guard the probabilistic engines like crown jewels. They are also exactly what privacy regulators are squeezing.

4. Ad-network postbacks and integrations. When someone installs via a Meta ad, the MMP fires a callback to Meta so the ad gets credited. There are 300+ ad networks. The MMP maintains those integrations. This is the single thing self-hosted solutions are weakest at. We'll come back to it.

5. The dashboard. Charts, cohorts, funnels, exports. Important for marketing teams. Not technically remarkable, but it's the day-to-day surface of the product.

6. Compliance theater. SOC 2 Type II reports, ISO 27001, GDPR DPAs, signed by the vendor. Your security team wants these. The vendor charges for them.

7. Support, account management, customer success. Real value if you use it. Most teams don't.

When you write the renewal check, you're paying for all seven. The question is whether you actually need all seven.

What "self-hosted attribution" looks like in 2026

A credible self-hosted mobile attribution stack in 2026 means roughly this:

• Mobile SDKs for iOS (Swift), Android (Kotlin), React Native, Flutter. Open-source, MIT-licensed, published to SPM, Maven Central, npm, and pub.dev. You drop them in like any other dependency.
• A backend that handles SDK event ingestion, link redirects, deep-link resolution, attribution matching, and webhook integrations. In our case it's Rails 8 with PostgreSQL, Redis, and Sidekiq. Yours might be different. The point is it's a normal web app. It deploys to EC2 with a Docker image, ECS Fargate, App Runner, or whatever orchestrator you already use. Nothing exotic.
• A dashboard, typically a Next.js SPA that talks to the backend over OAuth. You host it on the same box or on Vercel's free tier.
• A short-link domain of your own. Not yourbrand.app.link. Just yourbrand.link or lnk.yourbrand.com.

That's the entire stack. Three repos, one Docker compose file, one DNS record, one short-link domain.

What you get out of the box: deep linking, deferred deep linking, deterministic install attribution, in-app event tracking, link analytics, push notifications, and a UI your marketing team can use.

What you don't get out of the box, to be honest:

• Pre-built postbacks to 300 ad networks. You'll have postbacks to Meta, Google Ads, TikTok, and the major ones, but the long tail is on you. If your media plan touches 40 networks, this is a meaningful gap.
• A signed SOC 2 Type II report with your vendor's name on it. You'd be the operator. Your SOC 2 is your SOC 2.
• 24/7 named-account support. GitHub issues and a Discord, not a phone line.
• Probabilistic attribution. Most open-source projects, ours included, deliberately skip it. First-party deterministic only. If you depend on probabilistic matching today, this is a substantive change in how attribution works for you.

That last gap is good news if you're EU-regulated or privacy-conscious. It's bad news if you're an ad-buying team that lives on probabilistic data.

The math, at three scale tiers

Here's what the bill comparison roughly looks like. MMP numbers are estimates based on public pricing tiers and standard sales-conversation ranges as of early 2026; your actual quote will vary. The self-host numbers are real infrastructure costs on AWS, the default choice for most production teams and the easiest comparison most engineering orgs will already know how to read.

One note before the tables. AWS isn't the cheapest credible host. The same stack runs on Hetzner, OVH, or DigitalOcean for roughly 40–60% less. We're using AWS because most teams already have an AWS account, an AWS-aware security team, and an AWS bill they understand. If you want to push the savings further, the same arithmetic on Hetzner or DO looks even better than what follows.

50,000 MAU (early-stage app)

At 50k MAU, most teams are still on the free tier of an MMP. Self-hosting saves you essentially nothing on the bill and you take on ops work for the privilege. Skip self-hosting at this scale unless you specifically need the data residency or the SDK control. Use the free tier of an MMP or the free tier of an open-source cloud product.

500,000 MAU (mid-stage app)

This is where self-hosting starts to pencil out. Even at $200/hour of engineering time, the ops cost stays under $12k/yr against a saving of $18k–$85k. At this tier, self-hosting is a real choice. The decision usually comes down to whether you have an engineer who'll own it.

5,000,000 MAU (growth-stage app)

The savings at this tier are still six figures, but the AWS bill is real money now, around $1,350/mo before any Reserved Instance or Savings Plan discount. Apply a 1-year Savings Plan and the EC2 and RDS lines drop by 30–40%, putting the total under $1,000/mo. At this point, the decision shifts from cost to risk. Can you absorb a four-hour attribution outage? Do you have an on-call rotation? Have you ever lost an RDS master key?

None of these are impossible questions. They're real questions that don't have to be answered when an MMP is the one holding the pager.

A second note on AWS specifically: at this scale, where you put things inside AWS matters. The numbers above assume us-east-1 or eu-west-1, the cheapest two regions. The same stack in ap-southeast-2 or sa-east-1 runs 25–35% more. Multi-AZ on RDS roughly doubles the database line; the table above includes it because at 5M MAU you should have it.

A useful decision framework

The short version of how to think about this:

Self-host if:

• You're at 500k+ MAU and your MMP bill is over ~$30k/yr.
• You have at least one backend engineer who can own a Rails or Node app.
• You can live without postbacks to long-tail ad networks (or you only use 3–5 networks).
• You want your attribution data physically located somewhere specific (EU, US, or your own country).
• You don't need a SOC 2 report signed by the vendor. Your own attestation is fine.
• First-party deterministic attribution is enough as your primary model.

Don't self-host (yet) if:

• You're under 100k MAU and on a free or near-free MMP tier.
• Your media plan touches 30+ ad networks and you rely on every postback.
• You need a named account manager and an SLA-backed phone line.
• You don't have an engineer who can adopt a new piece of infrastructure.
• You depend heavily on probabilistic attribution and would consider losing it a downgrade.

There's also a middle path that didn't exist three years ago: use the open-source software, hosted by the people who wrote it. Several projects in this space, including Grovs, ship both. The same code runs in the cloud version and in the self-hosted version. You can start hosted, move to self-host when the bill starts to bother you, or move back if ops becomes a distraction. The lock-in goes away regardless of which side you're on.

The cost nobody writes down

Self-hosting isn't free, even when the software is. The cost nobody writes down is the cost of being the operator.

When the deep-link redirect goes down at 2 AM on a Sunday, nobody else picks up the pager. When Apple changes the App Store Server API for the third time this year, you read the migration guide. When a database index causes a 10× slowdown on link resolution, you debug it.

This is why MMPs exist. They aren't really selling attribution software anymore; that's commodity at this point. They're selling the right to not be the operator.

For some teams, that right is worth $60k a year. For others, $400k. For others still, it isn't worth either number and they should self-host.

We built Grovs as open-source because we think the operator decision should be yours, not your vendor's. Self-host it from github.com/grovs-io if you have the ops capacity and want to keep the bill at infrastructure cost. Use the hosted version at app.grovs.io if you'd rather pay us to run the box. The SDKs are the same, the dashboard is the same, the data model is the same. You can move between them whenever the trade-off shifts.

A small honest disclosure

We built Grovs because the renewal email kept arriving. We're an EU-based product team and we shipped this stack at production scale before we sold it to anyone. The infrastructure numbers in this post (EC2 sizing, RDS pricing, the cost curve from $45/mo to $1,350/mo) come from running this exact platform on AWS. The MMP comparison numbers come from quotes we've seen, public pricing tiers, and conversations with teams that switched away.

We're not unbiased about this, obviously. We think the self-hosting trade-off is more favorable than it was, and we built a product that benefits from people thinking so. The honest summary is that most teams should not self-host below 500k MAU, and most teams above 500k MAU should at least price it out. The MMP industry has counted on customers never running the math. Running the math is straightforward now.

If you want to try self-hosting before you commit, the entire backend, dashboard, and all five SDKs are MIT-licensed at github.com/grovs-io. The Docker Compose setup is one command. You don't have to talk to anyone first.

If you'd rather skip the ops, app.grovs.io is the same software, run by us. The free tier is generous enough to actually evaluate against your current MMP.

Either way, the renewal email doesn't have to be the only option in the conversation anymore.