All articles SDK

Ad SDK Go-Live Testing: A Checklist for Mobile App Developers

By the Adrop team
Checklist beside a phone screen with test status marks

When an untested mediation SDK reaches production, ad requests can report errors as fill rate drops, callbacks can arrive at the wrong time, and main-thread initialization can trigger ANRs. Shipping a broken integration means crashes, poor reviews, and revenue data you cannot trust for weeks while the issue is diagnosed.

This checklist follows the Adrop integration failures we see most often, from credentials through pre-launch smoke tests. It does not replace SDK documentation, but covers failure modes documentation rarely calls out.

Step 1: Credentials and Configuration

Before writing initialization code, confirm that the SDK key maps to the correct app and ad unit IDs in the dashboard. A key in code that points to another registered app is the most common silent initialization failure. The SDK reports success, but no demand partner receives a bid request because the app ID cannot resolve.

If the app previously used another mediation SDK, remove its initialization calls before adding Adrop. Two mediation SDKs starting in the same app lifecycle can conflict, causing intermittent fill failures instead of an obvious crash.

Step 2: Initialization Placement and Threading

Start mediation initialization as early as possible in the app lifecycle, but off the main thread. On Android, use the application lifecycle hook with the asynchronous callback variant. On iOS, use the corresponding lifecycle hook with an async completion handler.

Android (Kotlin):

iOS (Swift):

Wait for a successful initialization callback before loading ads; initialization should complete within 3 seconds, and a longer delay usually points to a configuration or threading issue. An earlier request can enter an error state that some SDKs report as fill failure rather than initialization failure, producing misleading early test data.

Step 3: Ad Request and Fill Testing

Run every ad format in test mode before enabling production serving. Test mode supplies real creatives from sandbox inventory, letting you check rendering, layout, and callback flow without real impressions. Moving to production takes one flag change and a build increment.

Also exercise failed requests for every format. Handle the callback, or its equivalent, gracefully. A rewarded video button should be disabled or hidden when no fill exists. A tap that produces an error state will create support contacts.

Step 4: Floor Price Verification

When eCPM floors are configured in the dashboard, confirm they apply to test auctions. Turn on SDK debug logging and inspect the bid request and response cycle. Bid prices should be reported against the floor, while impressions below it return no-fill rather than filling at a subfloor price.

A missing floor usually indicates that the request placement ID differs from the dashboard placement tied to the floor. Placement IDs are case-sensitive, so check the exact string.

Step 5: Lifecycle and Memory

Ad views retain context and activity references. On Android, destroy banner views when their host Activity or Fragment is destroyed to prevent leaks. For interstitials and rewarded video, do not retain a loaded ad object beyond the Activity lifecycle in which it loaded.

On iOS, make ad delegates weak when the presenting view controller is the delegate. A strong cycle between the ad object and view controller is a common mediation memory leak.

Step 6: Pre-Launch Smoke Test

Before production serving, run the sequence on a physical device, not an emulator or simulator, using a cellular connection:

Physical cellular testing matters because emulators and simulators can hide networking and rendering edge cases. Some creatives render differently on GPU hardware, and some network failures appear only with real latency.

This checklist targets the failure modes we see most often, not every possible issue. Your app architecture may add patterns it does not address. Documentation remains necessary; the checklist makes testing concrete enough to prevent skipped steps under deadline pressure. A broken live integration costs far more to diagnose and fix than careful pre-launch testing.