Install Attribution for Developers Who Actually Ship

The problem we're solving (and the problem we're not)

When an iOS or Android app gets installed, the developer usually asks three things: where did this person come from, will they still be using the app in a week, and if they came through our performance marketing, which partner earned the credit?

Enterprise tools handle this through sprawling data pipelines and weeks of onboarding. They're built for teams with dedicated analytics staff and marketing budgets in the millions. For someone running a studio with five people, or a solo indie developer, those tools are overkill and financially out of reach.

Attribr answers those three questions directly. We don't try to be everything. We're not a fraud-detection service standing alone. We're not a fingerprinting system that relies on probabilistic matching as its only weapon. Instead, we layer deterministic matching (the hard signal from ad networks that actually know who clicked) with probabilistic matching (pattern recognition when deterministic data isn't available) to get you clarity on install sources without asking your users for permission.

Why deterministic plus probabilistic beats the either-or argument

When we started building attribution for indie scale, we faced a real choice. We could build purely deterministic (relying only on ad networks passing us click-to-install data) or purely probabilistic (using device signals, timing patterns, and fingerprinting). Both have limits.

Deterministic matching is reliable but only works if the ad network or partner passes you the data. Not all do. Probabilistic matching picks up the rest of the installs, but it's inherently less precise. Fingerprinting alone feels like guessing at scale.

We chose to use both. When an install comes through an ad network that supports deep linking, we know exactly where it came from. When it doesn't, we look at device characteristics, install timing, and patterns we can observe from your other installs to make an informed inference. This hybrid approach lets us answer 'where did this install come from' for almost every install, without needing ATT permission on iOS 14.5 and above.

The result is practical. You get the confidence of deterministic data where it exists, and reasonable inference where it doesn't. No black box. No single point of failure.

What changes when you know your retention cohorts

Installing the SDK is three lines of code. Swift or Kotlin. That's real. We've removed the integration ceremony.

But the actual value emerges once you start seeing cohorts. You can track which sources deliver users who are still active at day 7, day 14, or day 30. That's where decisions get made. It's the difference between 'we got 200 installs' and 'we got 200 installs, but only the 47 from source X are still active a week later.'

A studio we work with realised their highest volume channel was driving the lowest retention. They'd been optimising for installs without seeing the full picture. Once they could see retention by source, they shifted spend. Their effective cost per retained user dropped by 38 per cent in two weeks.

That's not magic. That's just information. The kind of information that enterprises have always had, but indie developers rarely do, because the tools were gatekept behind enterprise pricing.

The Rippl bridge - why we built a direct line to performance marketing

Attribr has a feature most indie attribution SDKs don't mention: a direct bridge to Rippl, a performance marketing platform built for community-driven CPI campaigns.

This matters because it closes a loop. You can see not just that an install came from Rippl, but which specific promoter in the Rippl network drove it. That promoter's earned CPI goes into their account. You get the install. The attribution sits in one place, not spread across three tools.

We didn't add this because it's trendy. We built it because we realised indie developers often fund growth through smaller, community-driven networks before (or instead of) going to AppStore Search Ads or Meta. Those networks needed a way to prove performance. Those developers needed a way to see which promoter was actually converting. The SDK bridge lets both happen without you managing sync jobs or dealing with discrepancies.

Keeping it light, keeping it honest

The SDK itself is 50KB. No third-party dependencies. Your app launch overhead is less than 50 milliseconds. These aren't buzzwords. They're constraints we designed around because they matter to indie developers who run on real devices, real networks, and real user hardware.

We also built the dashboard itself to be useful without noise. Cohort charts. Funnel charts. Retention breakdowns by source. You can see your data in minutes, not hours. The Free tier covers 1,000 installs a month, which is enough to run an early-stage project and understand patterns. Growth and Pro tiers scale from there without locking you into enterprise contracts.

Fraud signals and custom ad-network integration are available on Pro because they're tools you graduate into as you scale. Not everyone needs them at 5,000 installs a month. But they're there when you do.

A question worth sitting with

The biggest change we've seen since launching Attribr isn't technical. It's behavioural. Developers who never had access to install-source data start asking better questions about their growth. Not 'how many installs' but 'which installs matter'. Not 'which channel is biggest' but 'which channel is stickiest'.

If you're building an app and you've never had clear visibility into where your users come from and whether they stick around, what decisions have you been making blind?