Best Practices for Your Store Listing

Lesson 50 told you what fields exist. Lesson 51 told you how to measure. This lesson is about craft: how to make each part of a listing actually good. A strong listing tells one clear story in several places at once: the icon, the title, the screenshots, the graphic and the words all say the same thing, in a way that a stranger understands in a few seconds.

This is Module 3: Best practices for creating your store listing of the Google Play Store Listing Certificate (https://playacademy.withgoogle.com/certificate). We teach the practices in our own words and with our own examples, and the official course and exam remain the authority. No guidance here guarantees installs or rankings.

Honesty note. Asset specifications and policy limits change. Check the upload dialogs in Play Console and the Play Console Help for the current numbers. Good design cannot rescue a poor app, and misleading assets are a policy violation and a trust problem.

By the end you will be able to:

• Define a brand story and keep it consistent across all assets.
• Design a clear icon, a feature graphic, and screenshots with captions that explain benefits.
• Write effective title, short and full descriptions with natural keywords.
• Plan a promo video (if you make one).
• Localise a listing properly, not just translate it.
• Use ratings and reviews wisely, and reply to them.
• Audit a listing with a repeatable scorecard.

Big idea: a visitor should be able to answer three questions in five seconds: What is it? Who is it for? Why should I install it?

• Store listing fields and policies (lesson 50).
• Conversion rate and experiments (lesson 51).
• Accessibility and contrast (lessons 46–48): the same rules make assets readable.
• Basic design ideas (Material 3 colours and typography, lesson 40).

Think of your listing as a shop front with several windows. If the sign says "bakery", one window shows tyres and another shows shoes, a customer is confused and leaves. A strong shop front shows bread everywhere.

        BRAND STORY (one sentence)
  "Class Register helps teachers take attendance in seconds, even offline."
            |
   +--------+--------+----------+-----------+---------------+
   |        |        |          |           |               |
 Icon     Title   Short desc  Feature    Screenshots     Full description
 (a tick  (name + (benefit)   graphic    (one benefit    (features + proof
  on a     what)               (tagline)   per image,      + how it works)
  register)                                 captions)

The three-layer message

Know your audience

Write down, in two or three lines, who you are speaking to. "Primary-school teachers in Oyo State who use a mid-range Android phone with limited data and take attendance daily" leads to different choices (offline emphasis, big buttons, Yoruba and English text) than "university lecturers using tablets". Everything below applies to your audience, not to an imaginary average user.

The icon is your most seen asset. It appears in search results, home screens, notifications and recent apps, often at a very small size.

Principles

1. One simple idea. A single recognisable shape, not a scene. Test by shrinking it to 48 × 48 px: if it becomes a blur, simplify.
2. Distinct. Browse your category on Play. If all competitors use a blue shield, a blue shield will not stand out, but do not be strange for the sake of it.
3. Meaningful. The symbol should hint at what the app does (a tick on a register page, a naira note and a magnifier for a price checker).
4. No text, or very little. Small text is unreadable. A single letter or short brand mark can work.
5. No store badges or claims. No "free", "new", "#1", star ratings or "Download now".
6. No extra rounded corners or shadows. Provide a full square (512 × 512 px, 32-bit PNG). Google Play applies the rounding and shadow. Your adaptive icon inside the app (lesson 21) uses a foreground and a background layer; make the Play icon match its look.
7. Colour with contrast. A bold background against a lighter symbol. Check it on both light and dark backgrounds, and in grayscale.
8. Consistent with the app. The user should recognise the icon when the app opens.

Quick test script

If you work with raster files, this script shows how your icon looks at the sizes that matter (needs pip install pillow):

from PIL import Image
icon = Image.open("icon-512.png").convert("RGBA")
sizes = [192, 96, 48, 32]
sheet = Image.new("RGBA", (sum(sizes) + 20 * (len(sizes) + 1), 220), "white")
x = 20
for s in sizes:
sheet.paste(icon.resize((s, s), Image.LANCZOS), (x, 20), icon.resize((s, s), Image.LANCZOS))
x += s + 20
sheet.convert("RGB").save("icon-sizes.png")
print("Saved icon-sizes.png. Look at it from arm's length.")

If the smallest version is not recognisable, redesign. Then test icon variants in a store listing experiment (lesson 51).

Title (30 characters)

Examples for our hypothetical app: Class Register: Attendance works because "Class Register" is the brand and "Attendance" is the main search word.

Short description (80 characters)

It appears in search results and at the top of the page, so write it as a benefit sentence, using the verb the user would use:

Rules: lead with the benefit; keep it concrete; use plain words; no repetition of the title; no claims that need proof.

Many people never read the description. They look at the first two or three screenshots. Treat them as a short slide show that tells your story.

Planning the sequence

Screenshot 1: THE PROMISE      "Take attendance in one tap"        (the main screen, close-up)
Screenshot 2: HOW IT WORKS     "Works without internet"            (offline indicator, sync)
Screenshot 3: THE RESULT       "Share reports with parents"        (the report screen)
Screenshot 4: TRUST / DETAIL   "Large text and TalkBack support"   (accessibility, privacy)
Screenshot 5: EASY START       "Set up your classes in minutes"    (onboarding)

Rules of thumb

1. One message per screenshot, in a short caption (3–6 words) in large readable type, at the top or bottom.
2. Show the real UI, not a fantasy. Captions explain, they do not misrepresent. Policy requires screenshots to reflect the app.
3. Put the best two or three first. The first image is usually seen without scrolling.
4. Consistent style: same fonts, colours, margins and device frame (or no frame) across the set.
5. Use real, realistic data (Nigerian names, naira amounts) so the user can imagine themselves using it. Do not show private data of real people.
6. Check text size on a phone. If you cannot read the caption on a small phone screen from 30 cm away, make it bigger.
7. Accessibility: captions must have high contrast (lesson 47).
8. Different devices: provide tablet screenshots if you support tablets (lesson 58 on adaptive apps) and Wear OS or TV where relevant.
9. Localise caption text for each language market (below).
10. Update screenshots when the UI changes. An out-of-date screenshot is a mismatch the reviewers and users will notice.

Generating screenshots

Take screenshots from the emulator (the camera icon in the emulator's side toolbar) or your device, then add captions. You can use a design tool, but a small script keeps results consistent and repeatable, which helps when you localise into five languages:

from PIL import Image, ImageDraw, ImageFont
def caption_screenshot(src, dst, caption, bg="#1B6B3A", fg="#FFFFFF"):
shot = Image.open(src).convert("RGB")
w, h = shot.size
pad_top = int(h * 0.18)
canvas = Image.new("RGB", (w, h + pad_top), bg)
canvas.paste(shot, (0, pad_top))
draw = ImageDraw.Draw(canvas)
font = ImageFont.truetype("DejaVuSans-Bold.ttf", size=int(w * 0.07))
# center the text horizontally
bbox = draw.textbbox((0, 0), caption, font=font)
draw.text(((w - (bbox[2] - bbox[0])) / 2, pad_top / 3), caption, font=font, fill=fg)
canvas.save(dst)
caption_screenshot("raw/main.png", "out/en-1.png", "Take attendance in one tap")

Check that the final size still meets the Console's rules (for example the long side no more than twice the short side; the script above makes the image taller, so test with check sizes as in lesson 50). Always keep the un-captioned originals.

Feature graphic (1024 × 500 px)

It sits at the top of the listing and can be shown in other Play surfaces. Rules:

• Keep the key content in the safe centre: edges may be cropped or covered by a play button if you have a video.
• Short tagline or none. One idea, big letters, high contrast.
• No screenshots collage of tiny UI, no store badges, no download-button imitations.
• Match brand colours and the icon.
• Include the icon or logo only if it helps recognition.

Promo video

Optional but powerful, since it can autoplay silently on the listing in some placements.

• Short: aim for 30 to 120 seconds, with the main value shown in the first five to ten seconds.
• Show the app in real use, with captions for people watching without sound.
• Hosted on YouTube, public or unlisted, not age-restricted, with monetisation and ads off; you enter the URL in the Console.
• Landscape orientation is the usual recommendation for the player; check the current guidance.
• No misleading content: show how the app actually works.
• Consider multiple language versions if you target several languages.
• Test whether a video helps with an experiment: for some apps it raises conversion, for others it distracts.

A simple storyboard:

0-5 s    Problem: a teacher with a paper register at the door, noise, queue.
5-15 s   Solution: taps present/absent in one tap on the phone.
15-30 s  Result: weekly report shared with the head teacher in seconds.
30-35 s  Call to action: "Class Register: free on Google Play" (only if true).

The full description (4,000 characters) helps people who want detail and helps search understand your app. Use a template:

[Opening, 2-3 lines]  What it is, who it is for, the main benefit. Plain words.

[Key features, 4-7 bullets]  Benefit-first: "Works offline, so a bad network never stops your register".

[How it works, 3 steps]  Numbered; shows simplicity.

[Proof, optional]  Real facts only: "Used in 40 schools in Oyo State during the 2025 pilot".
                    No fake awards, no unverifiable numbers.

[Requirements or notes]  "Needs Android 7.0 or later. Internet needed only for syncing."

[Support and contact]  Email, website, privacy policy link.

Using keywords the right way

• Write for people first. Use the words real users type: "attendance", "register", "school", "teacher", "class list".
• Put the most important keywords early and use them naturally, a few times, in different sentences.
• Do not repeat the same word many times, list unrelated search terms, or mention other brands.
• Keep the description consistent with the category and tags you selected.
• Update the text when features change; remove claims that no longer apply.

Formatting

The Play description supports plain text with limited formatting (line breaks, bullets typed as characters, and some basic formatting tags on some surfaces). Test how it looks on a phone. Avoid walls of text; use line breaks and short sections. Avoid ALL CAPS beyond short headings.

Translation converts words. Localisation adapts the whole experience to a place: language, examples, currency, images, cultural references, and even which features you highlight. Done well, it can increase conversion in that market; done carelessly (machine translation with errors), it damages trust.

Steps

1. Decide where the value is. Look at your acquisition report (lesson 51): which countries and languages send visitors? Which have traffic but low conversion?
2. Add a language in the store listing (the Console offers Manage translations). You can add translations by hand, or use Google's translation services as a draft only.
3. Translate all fields: title, short description, full description, and the screenshots' captions and feature graphic text. A listing in French with English screenshots feels half-finished.
4. Localise content, not only words: currency (naira, cedi, CFA franc), date formats, examples, and photos. Show interface screenshots in that language if your app supports it.
5. Have a native speaker review, especially for tone and idioms.
6. Mind right-to-left languages such as Arabic (text direction, mirrored layout) and long words in German or Hausa that may overflow image captions.
7. Test with a localised experiment (lesson 51).
8. Support the language in the app itself. A listing promising Yoruba support must deliver it (see the per-app language preferences in Android 13+ and strings.xml per locale, lesson 15).

A simple checker for missing translations

When you keep your listing text in files by language, this script lists missing or over-long fields:

from pathlib import Path
LIMITS = {"title.txt": 30, "short.txt": 80, "full.txt": 4000}
languages = [p.name for p in Path("listing").iterdir() if p.is_dir()]
for lang in sorted(languages):
for name, limit in LIMITS.items():
f = Path("listing") / lang / name
if not f.exists():
print(f"{lang}: MISSING {name}")
continue
n = len(f.read_text(encoding="utf-8").strip())
if n > limit:
print(f"{lang}: {name} TOO LONG ({n}/{limit})")
print("check finished")

Lengths in other languages can be longer than English, and some scripts count characters differently, so always check against the Console.

Ratings influence both conversion and visibility. You cannot fake them (policy), but you can earn them honestly.

• Ask at the right moment, after a success (a completed register for the week), not at the first launch. Use the in-app review API (com.google.android.play:review-ktx; look up the current artifact and the quota rules in the docs). It shows the system review sheet without leaving the app and is rate-limited.
• Do not incentivise ratings (no rewards for five stars) and do not gate: asking "are you happy?" and sending only happy users to the review prompt is considered manipulation.
• Read reviews every week: they are free user research. Tag them (bug, feature request, confusing, praise).
• Reply, politely and specifically: thank, acknowledge, explain what you did or will do. Public replies are seen by future users. Never argue, never share personal data. Users can update their rating after a fix.
• Fix the top complaint first, then mention the fix in your release notes.
• Ratings by version and country are visible: a poor rating on an old version may be solved by an update.

A tiny code sketch for asking for a review at a good moment:

import android.app.Activity
import com.google.android.play.core.review.ReviewManagerFactory
fun maybeAskForReview(activity: Activity, weeksCompleted: Int) {
 if (weeksCompleted < 3) return // only after real use
 val manager = ReviewManagerFactory.create(activity)
 manager.requestReviewFlow().addOnSuccessListener { info ->
 manager.launchReviewFlow(activity, info) // system decides whether to show it
 }
}

The system may choose not to show the dialog (quotas), and the call gives no result, so never build UI that depends on it.

Use this checklist to audit your own listing or a competitor's. Score each line 0 (poor), 1 (ok), 2 (strong).

CLARITY (5 seconds)
[ ] I can tell what the app does from icon + title + first screenshot
[ ] I can tell who it is for
[ ] The short description states a concrete benefit

ICON
[ ] Simple, recognisable at 48px, distinct in its category
[ ] No text claims, badges or extra rounded corners

SCREENSHOTS
[ ] First 3 tell the main story, one message each
[ ] Captions are large, short, high-contrast
[ ] Real UI, consistent style, up to date, localised

GRAPHICS AND VIDEO
[ ] Feature graphic readable in the centre safe area
[ ] Video (if any) shows the product in the first 10 seconds, with captions

TEXT
[ ] Title is brand + natural descriptor, no stuffing
[ ] Full description opens strongly, uses bullets, is accurate
[ ] Contact, privacy policy and requirements present

TRUST
[ ] Rating and recent reviews are healthy; reviews are answered
[ ] Data safety matches reality

LOCALISATION
[ ] Top three markets have localised text AND screenshots

A score of 24–28 is excellent, 16–23 is good with clear fixes, below 16 means rework. Use the audit to pick one experiment for next month (lesson 51).

Mistake #1: Icon with tiny text. Fix: a single shape or letter; test at 48 px.

Mistake #2: Screenshots that are all the same screen. Fix: one story step per image.

Mistake #3: Captions too small to read. Fix: large type, high contrast.

Mistake #4: Using device frames that hide the UI. Fix: minimal frames or none.

Mistake #5: Keyword stuffing. Symptom: policy trouble and a spammy look. Fix: natural writing.

Mistake #6: Machine-translated listing without review. Fix: native review.

Mistake #7: Translating text but not screenshots. Fix: localise every asset.

Mistake #8: Asking for a rating at launch. Fix: after a success moment, using the in-app review API.

Mistake #9: Ignoring negative reviews. Fix: reply and fix.

Mistake #10: Never updating assets. Fix: review the listing every release.

Question 1. What three questions should a visitor be able to answer within seconds?

Question 2. Why should an icon avoid small text?

Question 3. What is the difference between translation and localisation?

Question 4. What makes a screenshot effective?

Question 5. How can you ask for ratings honestly?

Go deeper: official resources

• Google Play Store Listing Certificate
• Google Play Console Help
• Prepare your app for release
• Android Basics with Compose course