Playable Ad QA Checklist Before You Upload
Most playable ad rejections and wasted spend trace back to problems a short test pass would have caught. This checklist covers the build, devices, interaction, end card, store links and packaging.
Key takeaways - Test the exact ZIP you will upload, unzipped into a clean folder, not your working project. - Run the full flow three ways: play it properly, do nothing, and tap wildly. Each exposes different bugs. - Check on real phones for touch, audio, safe areas and orientation. Desktop previews hide most of these problems. - The end card and the store click-through are the parts that earn the install. Verify them last, and verify them carefully. - Keep a written sign-off list so QA stays the same from one creative to the next.
Why playables need their own QA
A video ad either plays or it doesn't. A playable is a small program running inside someone else's app, on hardware you don't control, with a person poking at it in ways you didn't plan for. That gives it more ways to fail, and most of those failures are quiet. The ad loads, looks fine, and then a tap does nothing, the sound blares at the wrong moment, or the end card button sits under the notch.
Quiet failures cost money because the network keeps serving the ad. You see weak results and blame the concept, when the real problem was a button that didn't respond on half the devices.
The checklist below is ordered the way a player experiences the ad. Work through it top to bottom, and write down what you tested and on which device.
Before you start: set up the test properly
Test the final file. Export the ZIP, move it somewhere else, unzip it into a fresh folder, and test from there. This catches broken relative paths, assets that were only in your project folder, and requests to external servers that will be blocked or slow in production.
Pick your devices in advance. A reasonable minimum is one recent iPhone, one recent Android phone and one older or lower-end Android phone. If your audience skews toward a particular region or device tier, include a device typical for it.
Test in the environment that matters. A playable opened in a desktop browser is not the same as one inside an ad network's webview in a publisher's app. Use the network's preview or test tooling at the end, not just your own browser.
1. Load and first frame
The first seconds decide whether anyone plays. Check:
- The first frame is meaningful. No blank screen, no half-loaded art, no unstyled text flashing before the layout settles.
- It loads on a slow connection. Throttle the network or switch to mobile data. If the start is slow, the player has already swiped away.
- No console errors. Open the browser developer tools on desktop and look for failed requests or script errors. A red error on load is rarely harmless.
- No external dependencies you forgot about. Fonts, scripts or images pulled from a third-party host are a common source of failures and policy problems. Everything the ad needs should travel inside the package.
If the build is heavier than you expected, the playable ad specs article explains which constraints to check against each network before you export.
2. Interaction and tap targets
Playables live or die on responsiveness.
- Every tap does something visible. A tap should produce immediate feedback, even a small one: a highlight, a movement, a sound.
- Tap targets are comfortably large. If you have to aim carefully with a thumb, a lot of real players will miss. Test with your thumb, not a mouse.
- Multi-touch and rapid taps don't break state. Tap two things at once. Tap the same button ten times. Drag off a button and release. Games often mishandle these cases. If your build uses pointer or touch events, the MDN reference on pointer events is useful for understanding how they differ.
- Scrolling and zooming don't hijack the ad. Double-tap, pinch and swipe should not scroll the page behind it or zoom the canvas.
- Hint and idle behaviour works. If the player does nothing, does a hint appear? Or does the ad just sit there?
3. Devices, orientation and safe areas
Run the same flow on every test device and check layout, not just function.
- Aspect ratios. Very tall phones and shorter phones expose cropped backgrounds and misplaced buttons.
- Notches and rounded corners. Key buttons and text must stay clear of the screen edges and system overlays.
- Orientation. Decide whether the ad supports portrait, landscape or both. If it supports both, rotate mid-play and confirm nothing resets or breaks. If it supports one, confirm what the player sees when they rotate.
- Text legibility. Read all on-screen copy at arm's length on the smallest screen you have.
4. Sound
Sound is a frequent source of complaints and a frequent source of bugs.
- Silent start is handled. Many mobile browsers and webviews restrict audio until the first tap. Make sure the ad doesn't depend on sound to be understood.
- Volume is sane. Compare your effects and music against a typical app or video. Sudden loud sound in a public place is a reason for people to close the ad.
- Mute behaviour. If the device is on silent, the ad shouldn't misbehave or throw errors.
- Sound doesn't continue after the ad ends or after the player closes it.
5. Tutorial and core loop
This is where you review the experience, not just the code. The playable ad best practices article covers the design side. For QA, you are checking that the design survived the build.
Run the ad three ways:
- Play it as intended. Does the first action teach itself? Could a stranger understand the goal without reading instructions?
- Do nothing. Does the ad guide the player, advance on its own, or eventually reach the end card? Or does it freeze?
- Tap randomly and fast. Can you break the sequence, skip a required step, soft-lock the game, or reach the end card in a broken state?
Also check for fail states. If the player can lose, what happens next? A dead-end screen with no way forward is a bug, even if it's technically intentional.
If you generated the first version automatically from a store listing, spend extra time here. The article on reviewing generated playable output covers what to look for in the art, mechanics and copy.
6. End card and call to action
The end card is where the install happens, so give it its own pass.
- It appears reliably. Reach it by finishing the playable, by failing, and by timing out.
- The CTA is obvious and tappable. Test on the smallest screen with a thumb.
- Copy matches the app. App name, icon and promised features should match the store listing. Mismatches confuse players and can cause review problems.
- No dead ends. Can the player replay, if you offer it, without breaking anything?
- Nothing overlaps the network's own controls, such as a close button, that will be drawn on top of the ad.
For design guidance on this screen, see Playable Ad End Card: Design the Last Moments.
7. Store links and click-through
A beautiful playable with a broken click-through is the most expensive kind of bug.
- Every call to action routes through the click-through mechanism your network requires. Different networks expect different approaches, so confirm against the network's current documentation rather than reusing an old build's setup.
- Every tappable element that should go to the store does. That includes the CTA button, the end card background if it is meant to be tappable, and any in-game prompts.
- The destination is right. Check the correct app, the correct platform store for the device, and any tracking parameters you rely on.
- Previews often simulate the redirect. Confirm in the preview that the click-through call fires, then verify the final destination with the network's test tools or a small live test.
8. Packaging and file structure
Many rejections have nothing to do with how the ad plays.
- The entry file is where the network expects it. Typically that means an HTML file at the root of the package, but check the current spec.
- File names and paths are clean. Watch for wrong capitalization, spaces, and paths that work on your operating system but not on a server.
- No stray files. Remove system files, source files, notes and unused assets.
- Total size is within the network's limit. Check the current limit in the network's documentation instead of relying on memory.
The HTML5 ZIP structure guide walks through a clean package, and HTML5 Ad Disapproved in Google Ads lists the causes of rejection that show up most often.
9. Final sign-off
Before you upload, answer these with a clear yes:
- Did I test the unzipped final package, not the project folder?
- Did I play it normally, idle, and with chaotic input?
- Did it work on at least one iPhone and two Android devices?
- Does the end card appear every time, with a working CTA?
- Does the click-through fire, and is the destination correct?
- Is the package free of external requests and stray files?
- Did I check the network's current spec rather than my memory of it?
Keep this list in a shared document and add to it every time something slips through. Over time it becomes the most valuable page in your production process.
When to re-test
Re-run the relevant part of the checklist whenever you:
- change the end card, even only copy
- localize text into another language
- swap art or audio
- update the store listing the ad promotes
- export for a different network
Small edits are where regressions hide. Variants that look identical often are not.
A calm way to use this list
You don't need a QA department. You need a repeatable pass, a few real devices and the discipline to test the file you will actually upload. If you build playables in PlayableRun, the same checklist applies to the exported ZIP, because the network will judge the file, not how it was made.
If you'd like to see what a finished playable should feel like before you start testing your own, browse the live demos, or create a free account and run this checklist on your first export.
Frequently asked questions
›How long should playable ad QA take?
For a single playable, a focused pass on two or three real devices usually fits in under an hour. Most of the time goes to repeating the full flow with different behaviours: tapping early, not tapping at all, and rotating the phone. Adding more variants adds time mostly for the creative differences, not the technical checks.
›Do I need to test on real devices, or is a desktop browser enough?
Desktop is fine for a first look, but it is not enough for sign-off. Touch handling, audio policies, safe areas, memory limits and in-app webviews behave differently on phones. Test at least one recent iPhone and one Android device, ideally including a lower-end one.
›What is the most common mistake teams make before uploading?
Testing the working folder instead of the exact file they upload. A build that runs from a local project can break once it is zipped, because of wrong relative paths, missing assets or external requests. Always unzip your final package into a clean folder and test that.
›Should I test the store link if the preview does not open the store?
Yes, but in the right place. Many preview tools block or simulate the store redirect. Check that the click-through call fires in the preview, then confirm the final destination in a live test or the network's own test tooling before scaling spend.
›Can I skip QA when I am only changing the end card text?
Not entirely. Small edits can shift layout on narrow screens or change how text wraps in other languages. A short pass covering the end card on a small and a large device, in both orientations if supported, is enough for minor changes.
Sources
Turn your store listing into a playable
Paste an App Store or Google Play link and get an HTML5 playable you can test in minutes. The first one is free.
Keep reading
- Production & QA
Playable Ad Production Time: Brief to Live in Days
7 min read
- Production & QA
Playable Ad Assets Needed: From Screenshots to Playable
6 min read
- Production & QA
How to Reduce Playable Ad File Size Without Losing Polish
8 min read