How to Monetize a Mobile App with Programmatic Ads
The Aditude Team
You built a mobile app. People are using it. Now you want to turn that usage into revenue — without ruining the experience that made users show up in the first place.
Programmatic advertising is one of the fastest ways to get there. Done right, it generates recurring revenue that scales with your traffic. Done wrong, it tanks your ratings and drives users away. This guide covers the full setup process, from picking your approach to monitoring performance after launch — including the mistakes worth avoiding along the way.
Before You Start: What You'll Need
To get going, you'll need a live app on iOS, Android, or both; a developer account on the App Store and/or Google Play; a bank account or payment entity for ad network payouts; access to your app's source code; and at least a few hundred daily active users (DAUs), since most SSPs require a traffic minimum to approve your account.
That last point matters. If your app is brand new with minimal traffic, build your user base first. Most supply-side platforms won't approve accounts without meaningful volume, and even if they do, earnings will be negligible until you have real scale.
Step 1: Choose Your Monetization Model
There are three main approaches to in-app advertising, and the right one depends on your technical comfort level and traffic volume.
Direct SDK integration means connecting directly to a single ad network like Google AdMob. It's the simplest starting point — one SDK, one dashboard, one payment relationship. The tradeoff is that you're limited to one demand source, which typically means lower eCPMs and fill rates.
Mediation sits on top of multiple ad networks and automatically selects the highest-paying ad for each impression. This is what most serious publishers use. Mediation layers — like Google's or MAX by AppLovin — run a real-time waterfall or auction among your connected networks, driving up competition and revenue. More setup upfront, but significantly better long-term monetization.
Programmatic via an SSP gives you access to open market demand — thousands of advertisers bidding on your inventory in real time. This is where Aditude's Mobile SDK fits in: it connects your app to premium programmatic demand with a lightweight integration and publisher-first controls. For publishers ready to grow beyond a single network, SSP access is the step that meaningfully moves eCPMs.
If you're just starting out, begin with mediation. If you want to maximize revenue and have at least a few thousand DAUs, go SSP-connected programmatic from day one.
Step 2: Choose Ad Formats for Your App Type
Not all ad formats work for all apps. Mismatched formats produce poor user experience, low engagement, and weak eCPMs.
Banner ads are the lowest-friction format — they run at the top or bottom of the screen without interrupting the user. eCPMs are typically the lowest of any format, but fill rates are high and implementation is straightforward. Best for utility apps, tools, and content readers.
Interstitial ads are full-screen ads that appear at natural transition points — between game levels, after completing a task, before a new screen loads. eCPMs are significantly higher than banners. Best for mobile games and apps with clear session breaks.
Rewarded video is the highest-eCPM format in mobile. Users opt in to watch a video in exchange for in-app currency or an unlocked feature. Because it's opt-in, it doesn't disrupt the experience. Best for games and apps with virtual economies.
Native ads match the look and feel of your app's interface, blending in rather than interrupting, which typically produces higher engagement. Best for content apps, news readers, and social apps.
Start with one or two formats that fit your app's natural flow. You can add formats later once you've confirmed the core integration is working.
Step 3: Set Up Your SSP Account
Once you've picked your approach and formats, create an account with an SSP or ad network. Submit an application through the publisher portal — you'll need your app's store URL, expected monthly impressions, and payment details. Approval typically takes 1–5 business days.
Once approved, create an ad unit for each placement in your app. Each placement (for example, "main menu banner" or "post-level interstitial") gets its own ad unit ID. Note your App ID and Ad Unit IDs — you'll need them during SDK setup.
If you're working with Aditude, the onboarding process includes account configuration support.
Step 4: Integrate the SDK
This is the technical step. If you're not the developer, hand this section off — but understanding what's involved helps you scope the work accurately.
For detailed implementation instructions, see: How to Set Up an SDK for Mobile Ad Monetization
At a high level, SDK integration involves adding the SDK dependency to your project (via Gradle for Android, CocoaPods or Swift Package Manager for iOS); initializing the SDK on app launch with your App ID; loading and displaying ad units at the placement points you defined; and handling callbacks for ad load success, failure, and impression events so your app responds gracefully when ads don't load.
Most SDKs ship with sample code and documentation. Allow a few hours for a clean integration; plan for a full day if you're juggling multiple formats.
Step 5: Set Floor Prices
Floor prices are the minimum CPM you'll accept for an impression. Skip this step and you'll end up serving low-value ads at pennies — or training buyers that your inventory is cheap.
Start with modest floors, not zero. A floor of $0.50–$1.00 CPM for banners and $2–$5 for interstitials is a reasonable baseline for most apps. Rewarded video floors can go higher, often $5–$15 depending on your audience.
Set floors by format and placement. A premium placement — the first screen a user sees — should have a higher floor than a lower-traffic one.
Don't set floors too high at launch. If your floors exceed what the market will pay for unknown inventory, you'll get zero fill. Build your demand history first, then raise floors as buyers see your data.
Your SSP's UI will have a floor price section in each ad unit's settings. Revisit these after your first few weeks once you have real eCPM data.
Step 6: Test and QA Before Going Live
Never push a live ad integration without testing it first. A broken implementation is worse than no ads — it can cause app crashes, blank screens, or rejected app store submissions.
Before launch: use test ad unit IDs during development (never request live ads in a dev environment); verify ads display correctly on multiple device sizes and orientations; confirm ads don't overlap navigation, buttons, or critical UI elements; test the "no fill" path to confirm the app handles a missing ad gracefully; test deep links and click-through behavior; and switch to live ad unit IDs before submitting to the App Store or Google Play.
Test on real devices, not just simulators. Ad rendering can behave differently on hardware.
Step 7: Monitor eCPM and Fill Rate Post-Launch
Once you're live, your two most important metrics are eCPM (effective cost per thousand impressions) and fill rate (the percentage of ad requests that result in an actual ad being served).
In your first 30 days: fill rate below 70% suggests floors are set too high or your SSP account needs more demand sources connected. eCPM well below your floor usually means floor settings aren't configured correctly. High fill but low eCPM suggests you need to raise floors or add more premium demand. Crashes or ANRs spiking after launch warrant an investigation into the SDK version and initialization order.
Most SSPs have a 24–48 hour reporting lag, so don't make major changes in the first 48 hours. Let data accumulate before optimizing.
For benchmarks on what to expect, see: What Is a Good eCPM for Mobile App Ads?
Step 8: When to Add More Demand Sources
Once your first SSP is running and stable — typically after 30–60 days — it's time to add demand. More buyers competing for your impressions drives eCPMs up.
The typical progression: months 1–2, run one SSP or network and establish baseline eCPMs and fill rates. Months 2–3, add a second demand source through mediation and compare performance by placement. Month 3 and beyond, introduce header bidding or a unified auction to replace the waterfall with real-time competition.
Each new demand source adds some complexity — more SDKs to update, more dashboards to monitor. Working with a managed platform like Aditude means demand management, floor optimization, and SDK maintenance are handled without coordinating it all manually.
Common Mistakes to Avoid
Too many ads, too soon. More ad placements don't automatically mean more revenue. Overcrowded ad experiences increase uninstalls and hurt app store ratings, which reduces new downloads. Start conservative.
Ignoring consent and privacy requirements. If your app has users in the EU or California, you need a consent management platform and proper GDPR/CCPA handling before serving ads. Skipping this isn't just a legal risk — many premium advertisers won't bid on non-consent-compliant inventory.
Never updating the SDK. Ad tech SDKs release regular updates. Running an outdated version means missing performance improvements, security patches, and compatibility fixes.
Optimizing too early. Let your data breathe before making major changes to floors, formats, or demand sources. Decisions made on three days of data often get reversed after three weeks.
Getting from zero to a working programmatic ad setup is a multi-step process, but it's manageable with the right guidance and tooling.
