The install we could not match

Why one missing install broke our confidence

Most attribution companies would've dismissed this. Eleven out of twelve is a 91.6% match rate, which is honestly solid by industry standards. But this developer wasn't calling to complain about accuracy. She was calling because she knew exactly where that twelfth user came from. A Rippl promoter had sent her a direct message with the app link. The install had happened within minutes of that message. It was as certain as installs get.

We'd built Attribr with deterministic and probabilistic matching. Deterministic catches installs via deep links and exact tracking parameters. Probabilistic fills the gap by cross-referencing timestamps, device signals, and behaviour across the Rippl network. But this one install slipped through both methods because it lived in a gap we hadn't planned for: a promoter-direct install with no parameter and no traceable signal chain.

The question that kept me up that night wasn't "how do we fix this?" It was "how many other installs are we missing in this exact same way?". And then: if Rippl exists, and we're both serving indie developers, why aren't we talking to each other?

The problem with being almost right

When you're building attribution software, 91% accuracy feels like you've won. Every competitor claims similar numbers. The math is easy to defend. But indie developers don't think in percentages. They think in user cohorts. They think in retention curves. If you tell them "we track 91% of installs accurately," what they hear is "one in every eleven users will vanish from your retention reports." That's not an edge case. That's a blind spot in their funnel.

We started digging into our own logs. We found that Rippl-driven installs were our weakest area. Not because Rippl's platform is opaque (it's not). But because our matching logic had no reason to know that a certain install came from a certain promoter. We had timestamps and device data, but no direct link between the two systems. It was like trying to connect two pieces of a puzzle without looking at where they fit.

That's when we decided to stop trying to infer the connection and build it instead.

Building a bridge instead of patching a gap

We approached Rippl with a simple proposal: what if we created a direct integration where their platform could tell us, in real time, which promoter had sent a user to download an app? Rippl's team moved fast. Within weeks, we had a working prototype. When a user installs an app after clicking a Rippl promoter link, Attribr now receives that signal directly. No fingerprinting. No inference. Just a clean handoff from one system to another.

The integration shipped in Attribr Pro. It's still the only attribution SDK with a direct bridge to Rippl's performance-marketing network, which means if you're working with Rippl (and many indie developers are), you get something no other tool offers: complete visibility into which promoters are driving which users, and whether those users stick around at day 7, day 14, day 30.

That missing eleventh install is now accounted for. More importantly, every install from every Rippl promoter is now attributed correctly, without workarounds or probabilistic guesswork.

What this taught us about building for indie scale

The reason that one missing install mattered so much is that indie developers don't have the margin for error that enterprise teams do. When you're running a £40 campaign, every user counts. When you have fifty thousand monthly active users (not million), a 1% tracking error means five hundred users you can't categorise. That's real money you can't account for. That's a retention cohort you can't explain.

Most attribution tools are engineered backwards from enterprise needs. They're built to handle hundreds of millions of installs, integrate with dozens of ad networks, and survive being retrofitted into year-old production systems. That bulk and complexity ends up being a burden for developers who just need a lightweight answer: where did this install come from, is this user still here, and did I spend my money well?

Attribr's entire philosophy is different. Fifty kilobytes. Zero third-party dependencies. Integration in three lines of code. Sub-50ms launch overhead. No ATT permission required on iOS 14.5 and up. These constraints exist because we're building for the people who actually need to know this stuff, not the people who have a team to implement it.

That one missing install from Brighton forced us to extend that philosophy one layer deeper. Instead of building a better algorithm, we built a better conversation between two systems that indie developers actually use.

The roadmap shifted because the problem was real

We had planned to spend Q2 on fraud signal detection and ad-network roll-up reports. Those are the features growth teams ask for. But after that one conversation, we axed half the planned work and pivoted. The Rippl bridge became priority one. Fraud signals and network roll-up still shipped (they're in Pro now), but they shipped later, and they're secondary to the core thing we'd learned: indie developers need their tools to talk to each other, not reinvent each other.

That decision was scary because it meant saying no to feature requests from people we respect. But it was the right call because it was rooted in something real. Not a roadmap item. Not a competitor feature we felt we needed to match. Just one developer, one missing install, and the realisation that we'd built the wrong bridge.