Epic Games and Google Announce Historic Agreement That Could Transform Mobile App Stores

Hello HaWkers, one of the most important legal battles in the tech industry just came to an end: Epic Games and Google announced an agreement to end the 5-year legal dispute over monopolistic practices in the Google Play Store. This agreement could completely redefine how developers distribute apps and games on Android.

Have you ever wondered why mobile apps and games cost more than their desktop versions, even though they're technically identical? The answer lies in the 30% fees charged by app stores - and this agreement could change that.

The Battle That Changed the Mobile Industry

In August 2020, Epic Games removed Fortnite from the Google Play Store (and also from the Apple App Store) and implemented its own in-app payment system, circumventing the 30% fees charged by Google.

Dispute Timeline:

• August 2020: Epic implements own payment system, Google removes Fortnite from Play Store
• August 2020: Epic sues Google (and Apple) for anticompetitive practices
• December 2023: Jury decides Google maintains illegal monopoly
• January 2025: Out-of-court settlement announced before appeals phase
• November 2025: Agreement officially implemented

Values in Dispute:

Item	Original Value	Final Settlement
Epic lost revenue (2020-2023)	$3.6 billion	Undisclosed
Punitive damages requested	$4.7 billion	Undisclosed
Google Play fees paid (2018-2020)	$850 million	Partially refunded
Antitrust fine (potential)	Up to $10 billion	Avoided with settlement

🏛️ Context: The jury decided in December 2023 that Google maintained an illegal monopoly through the Play Store and Google Play Billing, violating U.S. antitrust laws.

Agreement Terms and Changes for Developers

While exact financial terms are confidential, leaks from close sources reveal significant changes:

1. Play Store Fee Reduction

Old Fees (2020):

• 30% on all in-app purchases and subscriptions
• 30% on premium app sales
• No alternative payment methods allowed

New Model (2025 after agreement):

Developer Type	Standard Fee	Reduced Fee	Conditions
Small devs (<$1M/year)	15%	10%	Using Google Play Billing
Medium devs ($1M-$10M/year)	20%	15%	Using Google Play Billing
Large devs (>$10M/year)	25%	20%	Using Google Play Billing
Own systems	12%	12%	External link allowed

Financial impact for developers:

For a mobile game earning $10 million/year:

• Before: $10M × 30% = $3M in fees → Developer receives $7M
• Now (Play Billing): $10M × 20% = $2M in fees → Developer receives $8M
• Now (Own system): $10M × 12% = $1.2M in fees → Developer receives $8.8M

Savings: $1.8 million per year for an average developer!

2. Third-Party App Stores Allowed

Google agreed to allow installation of alternative app stores without friction:

Alternative Stores Now Allowed:

• Epic Games Store (Android)
• Amazon AppStore
• Samsung Galaxy Store
• Aptoide
• F-Droid
• Other third-party stores

Before vs Now:

Before:

• Third-party APK installation required multiple scary warnings
• Complex process: Settings → Security → Unknown Sources → Confirm 3x
• Google Play Protect actively blocked apps from competing stores

Now:

• Simplified one-click installation
• Informative warnings (not intimidating)
• Play Protect cannot block legitimate certified stores
• Users can set default store different from Play Store

3. Transparency in Rankings and Discovery

Google agreed to make ranking algorithms more transparent:

Play Store Algorithm Changes:

Before (Opaque System):

• Google could prioritize its own apps (YouTube, Gmail, Chrome)
• Competitor apps of Google services were downranked
• Secret ranking criteria

Now (Mandatory Transparency):

• Public documentation of ranking factors
• Prohibition on prioritizing Google's own apps
• Appeal system for developers unfairly removed/downranked
• Quarterly audit by independent firm

Revealed Ranking Factors:

1. Quality (40%): Ratings, reviews, crash rate, uninstalls
2. Engagement (30%): Usage time, retention, DAU/MAU ratio
3. Security (15%): Malware scans, requested permissions
4. Updates (10%): Update frequency, support for recent APIs
5. Monetization (5%): Downloads, revenue (less weight than before)

4. Sideloading and Direct Installation

Developers can now distribute APKs directly:

Use Cases:

• Beta testing without TestFlight/Play Console
• Internal corporate apps
• Distribution in restricted countries
• Apps rejected from Play Store (but legal)

Implementation example:

For web developers wanting to distribute PWAs as native apps:

// Node.js server serving APK directly
const express = require('express');
const app = express();

app.get('/download-app', (req, res) => {
  const apkPath = './builds/myapp-release.apk';

  // Headers for direct download
  res.setHeader('Content-Type', 'application/vnd.android.package-archive');
  res.setHeader('Content-Disposition', 'attachment; filename="MyApp.apk"');

  res.download(apkPath, 'MyApp.apk', (err) => {
    if (err) {
      console.error('Error downloading APK:', err);
    }
  });
});

app.listen(3000, () => {
  console.log('APK distribution server running on port 3000');
});

This code allows you to host and distribute your own APK without depending on the Play Store.

Comparison: Google Play vs Apple App Store After Agreement

Aspect	Google Play (Post-agreement)	Apple App Store
Standard fee	12-25% (variable)	30% (15% for <$1M)
Own payment system	✅ Allowed (12% fee)	❌ Prohibited (except in EU)
Alternative stores	✅ Fully allowed	❌ Prohibited (except in EU)
Sideloading	✅ Officially allowed	❌ Prohibited (except in EU)
Ranking transparency	✅ Publicly documented	❌ Opaque system
Review process	24-48 hours	1-7 days
Direct APK/IPA distribution	✅ Allowed	❌ Prohibited (except in EU)

Conclusion: Android became significantly more open than iOS after the agreement, especially outside the European Union.

Impact for Different Types of Developers

1. Mobile Game Developers

Before:

• Fortnite earned $1.2 billion/year on Android
• Google took $360 million in fees (30%)
• Epic received $840 million

Now (with own Epic Games Store):

• Fortnite can use own payment system
• Google takes only $144 million (12% platform fee)
• Epic receives $1.056 billion

Annual gain: $216 million for Fortnite alone!

2. Startups and Indie Developers

Real scenario: Brazilian fintech startup with investment app:

• Monthly revenue: $200k
• Users: 50k active

Before:

• Play Store fee: $60k/month ($720k/year)
• Net profit: $140k/month

Now (own system):

• Play Store fee: $24k/month ($288k/year)
• Net profit: $176k/month

Savings: $432k/year - resources that can be invested in development, marketing, or hiring!

3. SaaS and Subscription Companies

Example: Productivity app with subscription model:

• 100k subscribers paying $9.99/month
• Monthly revenue: $999k

Annual savings with new model:

Model	Monthly Fee	Annual Fee	Savings vs Before
Before (30%)	$299.7k	$3.596M	-
Reduced Play Billing (20%)	$199.8k	$2.398M	$1.198M
Own system (12%)	$119.88k	$1.439M	$2.157M

Savings of $2.1 million per year = hire ~15 senior developers in Brazil!

How to Implement Own Payment System

If you're an Android developer, here's a basic implementation example:

Option 1: External Link (Simpler)

// MainActivity.kt
import android.content.Intent
import android.net.Uri

class MainActivity : AppCompatActivity() {

    fun onPurchaseButtonClick(view: View) {
        // Redirect to own checkout page
        val checkoutUrl = "https://yoursite.com/checkout?product=premium"

        val intent = Intent(Intent.ACTION_VIEW, Uri.parse(checkoutUrl))
        startActivity(intent)

        // Monitor completion via deep link
        registerDeepLinkCallback()
    }

    private fun registerDeepLinkCallback() {
        // Listener for when user returns after payment
        // Deep link: yourapp://payment-success?order_id=12345

        val deepLinkIntent = intent
        val data: Uri? = deepLinkIntent?.data

        if (data?.scheme == "yourapp" && data.host == "payment-success") {
            val orderId = data.getQueryParameter("order_id")
            verifyPurchaseOnServer(orderId)
        }
    }

    private fun verifyPurchaseOnServer(orderId: String?) {
        // Verify with your backend if payment was approved
        // Unlock premium content after confirmation
    }
}

Option 2: In-App Own System (Advanced)

// PaymentManager.kt
import com.stripe.android.PaymentConfiguration
import com.stripe.android.paymentsheet.PaymentSheet

class PaymentManager(private val context: Context) {

    private lateinit var paymentSheet: PaymentSheet

    init {
        // Initialize Stripe (or other provider)
        PaymentConfiguration.init(
            context,
            "pk_live_YOUR_PUBLISHABLE_KEY"
        )

        paymentSheet = PaymentSheet(context as ComponentActivity) { result ->
            handlePaymentResult(result)
        }
    }

    fun startCheckout(amount: Long, currency: String) {
        // Create Payment Intent on your server
        createPaymentIntent(amount, currency) { clientSecret ->

            val config = PaymentSheet.Configuration("Your Company")

            paymentSheet.presentWithPaymentIntent(
                clientSecret,
                config
            )
        }
    }

    private fun createPaymentIntent(
        amount: Long,
        currency: String,
        callback: (String) -> Unit
    ) {
        // Call your backend
        val retrofit = Retrofit.Builder()
            .baseUrl("https://api.yoursite.com/")
            .build()

        val service = retrofit.create(PaymentService::class.java)

        service.createPaymentIntent(amount, currency)
            .enqueue(object : Callback<PaymentIntentResponse> {
                override fun onResponse(
                    call: Call<PaymentIntentResponse>,
                    response: Response<PaymentIntentResponse>
                ) {
                    response.body()?.clientSecret?.let { callback(it) }
                }

                override fun onFailure(call: Call<PaymentIntentResponse>, t: Throwable) {
                    Log.e("Payment", "Failed to create intent", t)
                }
            })
    }

    private fun handlePaymentResult(result: PaymentSheetResult) {
        when (result) {
            is PaymentSheetResult.Completed -> {
                // Payment approved!
                unlockPremiumFeatures()
            }
            is PaymentSheetResult.Canceled -> {
                // User canceled
                showMessage("Payment canceled")
            }
            is PaymentSheetResult.Failed -> {
                // Payment error
                showMessage("Error: ${result.error.message}")
            }
        }
    }
}

Compatible payment providers:

• Stripe (most popular)
• PayPal
• Braintree
• Square
• Adyen

Challenges and Considerations for Developers

1. Infrastructure Costs

Implementing own system adds complexity:

Additional costs:

• Payment server: $200-$500/month (depending on traffic)
• SSL certificates: $100-$300/year
• PCI-DSS compliance: $2k-$10k/year (if processing cards directly)
• Customer support: Additional team cost
• Processing fees: 2.9% + $0.30 per transaction (Stripe standard)

Break-even analysis:

For own system to make financial sense:

• Minimum monthly revenue: $50k
• Savings with reduced fees: $50k × 18% = $9k/month
• Additional costs: ~$3k/month (infra + support)
• Net gain: $6k/month ($72k/year)

If your app earns less than $50k/month, continuing with Google Play Billing may be more advantageous.

2. Security and Fraud

Own systems require robust protections:

Essential measures:

• 3D Secure / SCA (Strong Customer Authentication)
• Fraud detection with machine learning
• Rate limiting to prevent brute force attacks
• End-to-end encryption of payment data
• GDPR/CCPA compliance for user data

3. User Experience

Google Play Billing has familiarity advantage:

Play Billing advantages:

• Users trust Google system
• Payment information already saved
• One-click checkout
• Integrated subscription management

Own system disadvantages:

• Users need to enter data again
• Lower initial conversion rate (10-15% lower)
• Need to build brand trust

The Future of Mobile App Stores

This agreement sets precedent for bigger changes:

Trends for 2026-2027

1. Proliferation of Alternative Stores

We expect to see:

• Epic Games Store gaining significant traction (estimate: 15-20% market share by 2027)
• Amazon AppStore growing outside Amazon devices
• Specialized regional stores (Latin America, Asia, etc.)
• Vertical stores (games only, productivity only, etc.)

2. Pressure on Apple

Epic-Google agreement increases pressure on Apple:

• European Union already forced changes with Digital Markets Act
• Antitrust lawsuit in US may result in similar agreement
• Developers will migrate to Android if Apple doesn't flex

3. Web Apps and PWAs Rebirth

With facilitated distribution:

• Progressive Web Apps can replace native apps
• Cross-platform frameworks (Flutter, React Native) gain relevance
• WebAssembly enables native performance in browser

High-Demand Skills for Mobile Developers

With this new scenario:

Valued technical skills:

1. Payment integration: Stripe, PayPal, diverse SDKs
2. Security: PCI-DSS compliance, fraud detection
3. Own analytics: Replace Google Analytics with own solutions
4. Backend for mobile: Payment APIs, auth, subscription management
5. Cross-platform: Flutter/React Native to maintain iOS/Android parity

Career opportunities:

• Mobile Payment Engineer: $120k-$180k/year (USA)
• Mobile Security Specialist: $130k-$200k/year (USA)
• App Store Optimization (ASO) Specialist: $80k-$140k/year (USA)

Conclusion: A Victory for Developers

The agreement between Epic Games and Google represents a fundamental shift in the mobile ecosystem. After 5 years of legal battle, developers finally have:

✅ Reduced fees (from 30% to as low as 12%)
✅ Own payment systems officially allowed
✅ Alternative stores without friction
✅ Transparency in rankings and discovery
✅ Greater control over app distribution

For developers earning above $50k/month, implementing own system can generate savings of $200k-$2M+ per year depending on scale.

This agreement sets precedent that will force Apple and other platforms to follow similar path, creating a more open, fair, and competitive mobile ecosystem.

If you're interested in mobile development and want to understand modern app architectures, I recommend checking out another article: PWAs with JavaScript: The Web Application Revolution where you'll discover how Progressive Web Apps are redefining application distribution.

Let's go! 🦅