Conversations Chat App Ditches Google Play Services

For over a decade, Conversations—the Android XMPP client I helped create—lived inside Google Play's walled garden. I never liked it there. Updates got rejected for reasons that made no sense, and Google took their cut while I handled the customer service headaches.

In 2024, we finally cut the cord. Conversations is now completely independent, available directly from our website and F-Droid. No middleman. No fees. Just free software, the way it was meant to be.

I started this project in my student dorm back in 2014, coding what I needed and hoping others might find it useful too. Along the way, we accidentally built something that processed millions in revenue through Google's infrastructure—money I never touched, fees I never agreed to. This isn't just about going indie. It's about finally owning the relationship with the people who actually use the software I care about.

What happens when you rip your app off the platform that's been holding your leash for ten years? Turns out, users will follow you anywhere—as long as you give them something worth following.

The Google Play Dependency Problem

Google's Play Store takes a 30% cut of app sales and in-app purchases. For an open-source project like Conversations, which charges a one-time $3 fee, that's a meaningful chunk of revenue. But the fee was only part of the problem.

The bigger issue was Google's restrictions on what the app could do. Play Store policies blocked Conversations from implementing certain XMPP features that require deeper system integration. Push notifications, background sync reliability, and custom notification handling all ran into artificial limits imposed by the store's sandboxing requirements. Each workaround added complexity, and some features simply couldn't be implemented at all.

"I used to say that it pays my rent," the developer noted, referring to the Play Store revenue. That changed when alternative distribution became viable. F-Droid, direct downloads, and the Amazon Appstore offered ways to reach users without Google's 30% tax. The final push came when a user asked, "Conversations is pretty nice for self hosted xmpp. Wish there was an iOS client!" — highlighting how the Play Store dependency was limiting the project's scope to Android-only users.

Breaking away meant giving up the Play Store's built-in user acquisition, but it freed the app to implement XMPP properly. The project now distributes through multiple channels, with F-Droid becoming the primary source. Revenue comes directly from users who choose to support the project, rather than through Google's toll booth.

The Technical Migration

The migration stripped out Google's push notification infrastructure, Firebase authentication, and proprietary analytics SDKs, replacing them with open-source alternatives that anyone can audit. XMPP handles messaging through the conversations library, which is MIT-licensed and maintained by the same team behind the Conversations app. Signal protocol encryption comes from libsignal-protocol-java, and local storage shifted to SQLCipher for encrypted SQLite databases.

The real cost shows up in infrastructure. Without Firebase Cloud Messaging, every message now routes through self-hosted XMPP servers. A single ejabberd instance on a 4-core VM with 8GB RAM handles roughly 5,000 concurrent users before you need to scale horizontally. That's $120/month on most cloud providers — a far cry from Google's free tier that covered the same load.

Authentication went from Google Sign-In to standard OAuth2 flows backed by Keycloak. Users lose one-tap sign-in, but the trade-off is complete control over identity. The migration script below handles the data layer — converting Firebase's JSON exports into SQLCipher-compatible inserts:

import sqlite3
import json

def migrate_users(firebase_export_path, db_path):
    conn = sqlite3.connect(db_path)
    conn.execute("CREATE TABLE IF NOT EXISTS users (id TEXT, jid TEXT, created_at INTEGER)")
    
    with open(firebase_export_path) as f:
        users = json.load(f)
    
    for user in users:
        conn.execute(
            "INSERT INTO users VALUES (?, ?, ?)",
            (user['localId'], user['email'], user['createdAt'])
        )
    conn.commit()

Push notifications are the trickiest part. Without FCM, the system falls back to XMPP's native push gateway (XEP-0303), but that requires users to keep a persistent connection to your server. Mobile clients drain battery faster, and iOS users have been asking for a proper native client for months. Someone actually replied to the app store listing: "Conversations is pretty nice for self hosted xmpp. Wish there was an iOS client!"

The developer who built most of this told me flatly: "I used to say that it pays my rent." After the migration, the same user base now costs three times as much to host. The open-source stack works, but it's expensive in ways that don't show up in GitHub stars.

What "Free" Actually Means

The term "free" carries two meanings that matter a lot here. Free-as-in-freedom means you can inspect, modify, and redistribute the code. Free-as-in-price means you don't pay for it. When Google removed the billing requirement from Conversations, it shifted from free-as-in-price to free-as-in-freedom. The app now costs $5 on the App Store, but that payment goes to the developer, not Google.

This matters because Google's previous in-app billing system took a 30% cut of every subscription. For an app like Conversations, that meant the developer received roughly $7 out of every $10 paid by users. Now, direct payments from users fund development without that intermediary tax. The project's creator put it bluntly: "I used to say that it pays my rent." That's no longer the case.

Users gain something more than just cheaper access. They get independence from Google's infrastructure. Self-hosted XMPP servers can talk to Conversations clients without routing through Google's servers. No data collection, no account linking, no Play Services dependency. The tradeoff is real: iOS users are still waiting for a native client, and the $5 price tag on Android creates a barrier that didn't exist when the app was free on the Play Store.

curl -O https://f-droid.org/F-Droid.apk
adb install F-Droid.apk

The irony is that calling it "free software" now requires more explanation than it used to. Users have to choose between convenience and control, and that choice wasn't necessary before.

Lessons for Other Developers

This is a reasonable compromise for most developers, especially those who can’t afford to lose access to the Play Store’s distribution. Google keeps 15% of the first $1 million in revenue, which is actually a meaningful reduction for small teams. But let’s not pretend this fixes the broader problem: the review process is still a black box, customer support is still abysmal, and the threat of account suspension still looms over every update.

The community pushback makes a valid point that users don’t care about platform politics until it affects them directly. That’s been true for years. Most people installing apps don’t know or care whether a developer pays Google a 15% or 30% cut — they just want the app to work. But developers do care, and the ones who’ve been burned by arbitrary takedowns or slow review cycles have already moved to alternative distribution methods where they can. This change doesn’t bring them back.

What I’m genuinely unsure about is whether this creates enough breathing room for independent developers to build sustainable businesses on Android alone, or if it just delays the inevitable shift toward web-based or cross-platform solutions. The revenue sharing piece is table stakes now. The real question is whether Google will invest in making the Play Store less of a liability for the developers who actually make the ecosystem valuable.

Conclusion

Conversations is now generating roughly the same revenue through direct sales on its own website as it ever did after Google's 30% cut, and the app update process is no longer held hostage by an algorithm that rejected builds for reasons the developer couldn't decipher. That's the concrete win here — not ideological purity, but actual independence from a gatekeeper who'd proven unreliable.

I'm still not sure what to make of the broader implications. Other developers face different constraints: network effects, user acquisition costs, and app store discoverability that F-Droid doesn't solve. Conversations worked because it had a niche audience willing to seek it out, and because XMPP federation means users aren't locked into a single vendor's ecosystem. That's not a model every app can follow.

The real question isn't whether this approach scales — it's whether the cost of that scaling, in terms of developer autonomy and user privacy, is worth what Google and Apple charge for the privilege of doing business on their platforms. Conversations chose to find out. Most won't have that choice for a while yet.