Why a 50KB SDK Matters More Than a Feature List

The tyranny of bloat

If you've integrated Branch or AppsFlyer, you know the feeling. Your app builds. Your app runs. Then suddenly it's thirty megabytes heavier and your cold start time has doubled. You ask yourself: why does attribution need to cost so much?

The honest answer is that most attribution platforms were built for scale that indie developers don't have. They're designed for agencies managing dozens of campaigns across multiple channels. They're built to handle fraud detection at scale, cross-device tracking, and integration with every ad network on earth. All of that weight is real. It's just not relevant when you're trying to keep your app under 50MB or when you're working with one or two marketing channels.

We made a different choice. Instead of building a platform that does everything, we asked ourselves: what does an indie developer actually need to know? Where did each install come from? Are those users still opening the app next week, next month? If they came through Rippl, which promoter drove them? Three questions. One 50KB SDK. Zero third-party dependencies to manage.

That last part matters more than it sounds. When you don't depend on other libraries, you don't inherit their bugs. You don't wait for their updates. You don't suddenly find yourself on the wrong side of a deprecation notice.

Speed is a feature that hides itself

We tested our SDK on a Moto E from 2019, a phone that has no business running modern apps. App launch time overhead was under 50 milliseconds. You can't measure that. You won't see a chart about it. But a user will feel it in their bones the moment your app responds faster than their muscle memory expects.

I spent three weeks chasing a single millisecond off that number because I knew the indie developers using us would care. Not because it mattered to them in isolation. But because they're building for budget devices, for emerging markets, for people who judge an app on whether it feels responsive or sluggish. Attribution shouldn't be the reason their app feels slow.

That's a design philosophy that doesn't show up in a feature comparison sheet. But it changes everything about whether a developer recommends you to someone else.

The ATT permission thing

iOS 14.5 broke deterministic attribution for most indies. Apple gave you the right to ask users for permission. If you don't ask, or if they decline, you lose device identifiers. Most attribution platforms threw their hands up and said you needed probabilistic matching instead. That's fingerprinting. Some people hate it. Some people needed it. Most people don't want to ask users for permission just to understand which ad drove an install.

We built both. Deterministic matching when you have identifiers. Probabilistic when you don't. The SDK figures it out on its own and you don't have to explain the privacy trade-off to users. If someone's determined to be installed through a particular source, great. If we're confident but not certain, we say so. If we're guessing, we tag it as probabilistic. You see it all in the dashboard.

That honesty is rare in attribution. Most tools hide their confidence scores. They don't want you thinking about whether you can actually trust the number. We did the opposite.

Integration as philosophy

I had a developer integrate Attribr in eleven minutes. She sent us a screenshot. She'd added three lines of Swift code and the dashboard was already running. I asked her why she'd bothered. She said: 'I wanted to see if you meant it when you said three lines.'

She did mean it literally. Not three lines if you count configuration files and plist changes. Three actual lines of code. Because we chose to embed sensible defaults instead of making you customise everything. Your analytics platform. Your Rippl setup. Your retention thresholds. We guessed right for 90% of use cases and we wrote code that lets the other 10% override it without ceremony.

Most software makes integration easy by lying about how easy it is. They count setup steps that aren't really steps. They praise their documentation as though reading is the same as shipping. We wanted someone to add Attribr to a shipping build in the time it takes to drink coffee. That happened on Friday. It shaped how we think about every other decision.

The Rippl bridge is actually different

Every attribution platform will tell you it integrates with ad networks. That's the table stakes. With Attribr, we went one step further: if an install came through a Rippl promoter, we tell you which one. That's not common. Most platforms don't know about your CPI network. They know about Facebook and Google and Snapchat. They don't know your community.

That matters if you're running a small studio and you're paying real money to real people in your community to drive installs. You want to know which promoter drove which user. Are they good enough to keep going? Did they refer someone worth keeping? That loop closes inside Attribr. You see the promoter name in the retention cohort. You see which of their installs are still active at day 7 and day 30.

It's a bridge that only makes sense for indie developers and small studios. Adjust doesn't have it because their customers are agencies. AppsFlyer doesn't have it because their customers are building at scale. We have it because it's what you actually need.

The size of the thing is the philosophy

When someone asks me what makes Attribr different, they expect a feature answer. Retention cohorts. Fraud signals. Deterministic plus probabilistic matching. All true. All useful. But the real difference is that every feature got built inside a 50KB constraint. That forced us to think about priority. What actually matters? What can go somewhere else? What deserves to stay?

That constraint is why we don't have a web version that tracks every pixel across the internet. That's why we don't fingerprint devices with exotic techniques. That's why we don't integrate with every ad network. We picked the ones that matter for your scale and we did those well.

Size isn't the point. It's proof that we understand what you need and what you don't. You don't need complexity that costs you performance. You don't need features you'll never use. You need to know where your installs came from, whether those users are still there, and how to find more like them. Fifty kilobytes does that.