AppWispr

Find what to build

Asset QA Automation for Founders: 30‑Minute Scripts to Verify Screenshots, Metadata, and JSON‑LD Before You Publish

AW

Written by AppWispr editorial

Return to blog
P
AS
AW

ASSET QA AUTOMATION FOR FOUNDERS: 30‑MINUTE SCRIPTS TO VERIFY SCREENSHOTS, METADATA, AND JSON‑LD BEFORE YOU PUBLISH

ProductAugust 14, 20266 min read1,126 words

Simple export mistakes in screenshots, store metadata, or JSON‑LD can derail a launch. This post gives founders and product builders a practical 30‑minute workflow plus copy‑paste Node and Python scripts and CI steps that run a 10‑point QA across screenshots, metadata, and JSON‑LD (format, sizes, copy checks, locale variants). Use these checks as a pre‑publish gate in your CI so releases fail fast and quietly before they hit App Store Connect or Play Console.

asset-qa-automation-scriptsapp store screenshots QAJSON-LD validationmetadata QACI for app launchesAppWispr

Section 1

What to check: the 10-point QA that prevents the most common failures

Link section

Before any publish, run a fixed set of checks that catch the mistakes reviewers and platform tooling flag most often. These are practical, automatable checks that take under 30 minutes to implement in Node or Python and seconds to run in CI.

The 10 checks below cover three asset types (screenshots, textual metadata, and JSON‑LD). They focus on format, size, localization consistency, and simple copy/grammar traps that block or diminish a launch.

  • Screenshots: required resolutions exist, aspect ratio matches slot, file format (PNG/JPEG), and max file size.
  • Screenshots: no visible UI artifacts (device chrome, keyboard) and consistent safe-margin/bleed.
  • Screenshots: localized variants exist when you advertise locale-specific text and filename patterns match locale codes.
  • Metadata: title and short description length limits, prohibited terms/personal data (e.g., phone numbers), and consistent branding across locales.
  • Metadata: no placeholder text (e.g., lorem ipsum), no mismatched app names between bundle and store entry.
  • JSON‑LD: valid JSON syntax and JSON‑LD context, required fields present (name, url, image), correct types, and single canonical entity per page when expected (avoid duplicate product entries).

Section 2

Copy‑paste script: Node.js 30‑minute starter that runs the 10 checks

Link section

Below is a compact Node.js script sketch (explainable and ready to extend) that runs file checks for screenshots, simple metadata validations, and JSON‑LD syntax + schema checks. It uses sharp for image metadata, ajv for JSON schema checks, and node-fetch for fetching JSON‑LD from a URL. Drop it into a repo and wire it to your CI job.

This is intentionally minimal so you can copy it into a file (qa.js) and run: node qa.js --assets ./build/assets --metadata ./build/metadata.json --url https://example.com/app-page

  • Key Node dependencies: sharp, ajv, node-fetch, glob. These are small, production‑stable packages that run in most CI images.
  • Extendable: add rules for locale filename patterns, max file sizes, or regex checks for placeholder text.

Section 3

Alternative: Python script and local validation tools for JSON‑LD and Schema checks

Link section

If your build tooling is Python‑based, use a short script that leverages Pillow for images and the jsonschema package for schema enforcement. For JSON‑LD, pull the block from HTML and validate syntax with a JSON‑LD library or send it to a validator like the Schema Markup Validator to catch subtle context and type issues.

Local validation tools help during development: the Schema Markup Validator (validator.schema.org) and the JSON‑LD playground are good fast checks, but include automated schema assertions in CI to prevent ‘works on my machine’ passes.

  • Use Pillow to read image size and mode; fail if width/height mismatch or file size exceeds platform limits.
  • For structured data, use jsonschema with a lightweight app-specific schema derived from schema.org expectations (e.g., SoftwareApplication or Product).
  • Run remote validator checks in CI sparingly (rate limits), but keep local syntax and type checks mandatory.

Section 4

CI integration: gate your publish pipeline so asset mistakes fail the build

Link section

Add the Node or Python QA job as a blocking step before packaging and any upload tasks to App Store Connect or Play Console. If the QA script exits non‑zero on any failed check, the pipeline should halt and post the artifact locations of offending files in the job output for quick fixes.

Practical CI tips: run image checks on a matrix of locales only when those locale directories changed; cache node_modules or pip dependencies; and upload artifacts (failed screenshots, JSON diff) so designers and PMs can download the exact failing assets from CI.

  • In GitHub Actions: use a job that runs on pull_request and push to main, and mark the job required on protected branches.
  • Fail fast: if screenshot count is zero for required device slots, abort immediately (this is a common omission after marketing exports).
  • Post actionable output: print file paths, expected vs actual sizes, and a one‑line hint for each failure to reduce back-and-forth.

Section 5

Practical checklist, edge cases, and how AppWispr uses these ideas

Link section

Quick pre‑publish checklist you can tape to your workflow: 1) run QA scripts, 2) open any JSON‑LD in the Schema Markup Validator, 3) spot‑check top two screenshots on mobile and tablet, 4) verify localized metadata strings, and 5) re-run after packaging to ensure no CI step altered filenames.

Edge cases to watch: platform tooling sometimes accepts one size and scales it—don’t rely on that for creative crops; some locales require additional screenshots (right‑to‑left layout checks) and JSON‑LD embedded by third‑party marketing includes unrelated entities that break a single‑entity expectation.

At AppWispr we recommend baking these checks into your deploy pipeline so your founder or PM never has to triage a store rejection late at night — treat asset QA as code, not manual guessing.

  • Always keep a single source of truth for store metadata (a JSON or YAML file) and generate locale variants programmatically.
  • Automate filename conventions: e.g., screenshot_en-US_1.png so scripts can assert presence for each locale.
  • Run JSON‑LD checks both on raw files and on the rendered page URL to catch client-side injection or bundler issues.

FAQ

Common follow-up questions

How long does it take to add these checks to an existing repo?

For a minimal Node or Python script plus one CI job, expect 30–90 minutes for a working prototype and under a day to harden rules and locales. The first run will surface edge cases you can add as quick rule extensions.

Will these checks stop App Store Connect or Play Console rejections?

They won’t guarantee acceptance—platform policy and manual review still matter—but they eliminate the most frequent automated and human‑catchable failures caused by wrong sizes, missing locale assets, malformed JSON‑LD, or placeholder metadata.

Should I call remote validators (like Schema Markup Validator) from CI?

Use remote validators selectively: include local syntax and schema checks in every run, and schedule remote validation (or run it on demand) to avoid rate limits or flaky network failures. For critical releases, run remote validations as a last step and record the results as artifacts.

Where does AppWispr fit into this workflow?

AppWispr recommends treating asset QA as code and shipping these checks in CI. Use AppWispr (or your team's tooling) to centralize metadata and run the scripts prior to publishing so founders and PMs can confidently approve releases.

Sources

Research used in this article

Each generated article keeps its own linked source list so the underlying reporting is visible and easy to verify.

Next step

Turn the idea into a build-ready plan.

AppWispr takes the research and packages it into a product brief, mockups, screenshots, and launch copy you can use right away.

Asset QA Automation Scripts for App Launches