Per-app landing pages, and the SEO problem underneath them (2026-08-16)
Vocabulary note: presets and vpresets have since been abolished and replaced by add-ons: one
apps/<bucket>/<app>/addons/<name>.addon.yamlper add-on, typed by the presence or absence of avapp:key. This document is left as written; the current shape isdocs/app-development/addons.md.
Status: open design. The flagship apps carry landing definitions now. The production gate in §9 is still recorded here. The mechanism described here is built and proven end to end on
/apps/nextcloud; twenty-one other flagship pages are not written. Nothing here has reached production, and §9 says plainly why it cannot yet.
Owner ask, verbatim: “each app in the marketplace should have more than just screenshots. There should be custom HTML or not HTML, custom … some custom, like, I don’t know, animation, attractiveness, uniqueness to that specific app, almost like its own landing page. At least the the the first class ones. The flagship ones. because we really need good SEO.”
That ask contains two requests, and the second one silently invalidates the obvious way of doing the first. This document takes the SEO half as the hard constraint, because a beautiful app page that a crawler cannot read is worth approximately nothing, and today every app page on the storefront is exactly that.
0. What was measured first
Section titled “0. What was measured first”All figures taken 2026-08-16 against the live storefront and against
origin/main at e61d41f6a.
0.1 The store is invisible to anything that does not run JavaScript
Section titled “0.1 The store is invisible to anything that does not run JavaScript”GET https://marketplace.selfhostedcloud.org/apps/nextcloud HTTP 200, 745,261 bytes of document
<title> ABSENT <meta name="description"> ABSENT <link rel="canonical"> ABSENT OpenGraph / Twitter cards ABSENT JSON-LD ABSENT /sitemap.xml 404 /robots.txt 404
visible text in the served document, tags stripped, IN FULL: "SHC Marketplace Catalog About Back to catalog Refresh Self-hosted apps, installed with one command."Ninety-nine characters, and not one of them is the app’s name. The string
“Nextcloud” appears in that 745 KB document six times, every one of them
inside one’s own server-context script echoing the URL back.
0.2 The cause is not “no SSR”; SSR is on and working
Section titled “0.2 The cause is not “no SSR”; SSR is on and working”apps/marketplace/vite.config.ts sets defaultRenderMode: "ssr", and the
served document confirms it: __one_server_context__ carries "mode":"ssr",
and the runtime public-config payload a sibling lane fixed last night is
present and correct.
The cause is that the catalog data never had a server-side path. Every
read went through features/marketplace/src/catalog/useMarketplace.ts, which
is fetch-on-mount inside useEffect, and useEffect does not run on a
server. So the server faithfully rendered a screen that had no data.
apps/marketplace/src/app.ts even records this in a comment: “SSR never
fetches; the catalog hooks are fetch-on-mount”, as a statement of fact
about the plumbing. It is a defect report.
0.3 Why “Google renders JavaScript” is not an answer
Section titled “0.3 Why “Google renders JavaScript” is not an answer”Googlebot’s renderer is a second-pass, best-effort queue: the HTML is indexed immediately, the rendered DOM whenever the render budget allows. Betting 90 product pages on that queue is a bet, not a plan. And it is a bet only against Google. Bing, Perplexity’s crawler, GPTBot and the retrieval crawlers that increasingly decide what an assistant says about “self-hosted Nextcloud” do far less JavaScript execution, or none. For those, the storefront currently publishes one sentence, ninety times.
There is also a discovery problem that no amount of rendering fixes: the
storefront navigates with router.navigate() rather than <a href>, so a
crawler landing on / has no links at all to the 90 app pages. With no
sitemap, those URLs are undiscoverable except by external link. The sitemap is
not an optimisation here. It is the only discovery mechanism.
1. The shape of the answer
Section titled “1. The shape of the answer”Four changes, in dependency order. Only the first is load-bearing; the other three are worth little without it.
- A
oneroute loader on/apps/[app_name], so the server has the listing before it renders. This is the SEO fix. - Per-page metadata and structured data rendered from that data.
sitemap.xmlandrobots.txtas API routes.- A closed landing-block vocabulary in
app.yaml, carried through the seeder to the bench, rendered by a fixed component set. This is the “uniqueness and animation” half, and it is last, because it is the half that would have been worthless on its own.
2. The loader, and what server rendering actually cost
Section titled “2. The loader, and what server rendering actually cost”apps/marketplace/routes/apps/[app_name].tsx now exports a loader that
fetches the listing, its versions and its presets server-side and returns
them; the screen prefers that data and keeps its client hooks as the refresh
path and the native path. Three things fell out of doing this that are worth
more than the change itself.
2.1 Server-to-server removes the CORS problem, for free
Section titled “2.1 Server-to-server removes the CORS problem, for free”The bench serves no Access-Control-Allow-Origin (measured, and recorded in
vite.config.ts), which is why the browser path needs a same-origin proxy. A
loader is a server-to-server fetch: no preflight, no proxy, and the bench
origin need not be exposed to the page at all.
2.2 ★ useMedia() freezes at its SSR value; every desktop visitor got the phone layout
Section titled “2.2 ★ useMedia() freezes at its SSR value; every desktop visitor got the phone layout”This is the biggest hazard in the whole lane and it was invisible before.
ListingDetailScreen branched on useMedia()["max-sm"]. On the server there
is no viewport, so it resolved to the phone branch, and it never
re-resolved. Measured on the first server-rendered build:
| viewport | install button width | app glyph |
|---|---|---|
| 1440 px | 1,209 px (full-bleed) | 63 px |
| 1200 px (after a real viewport change) | 1,114 px | 63 px |
The old code path hid this perfectly, because the markup the server produced was a skeleton the client threw away. The moment the server renders the real screen, the guess is baked in.
The fix is not a better default. A JavaScript-resolved breakpoint is the
wrong tool for a page whose entire job is to be correct before any JavaScript
runs. Tamagui’s responsive style props compile to real CSS media queries:
right at first paint, right for a crawler, right for Cumulative Layout Shift.
useMedia() is now gone from this screen, base values are the phone values,
and $sm (min-width 640, the mobile-first convention packages/themes
documents) carries the desktop step.
This generalises. Any screen that is server-rendered for SEO has to move
off useMedia() first. CatalogScreen still uses it and would need the same
treatment before the home page is server-rendered with data.
2.3 A second latent bug: the SSR’d icon URL pointed at a private address
Section titled “2.3 A second latent bug: the SSR’d icon URL pointed at a private address”With the server rendering icons for the first time, og:image, <img src>
and <link rel=preload as=image> all came out as
http://localhost:8002/files/nextcloud.svg, while the same document’s
__mp_public_config__ carried the correct public origin. useAppIconSrc
resolves against the FrappeProvider base, which src/app.ts computes once
at module scope, before the serving process has its runtime config.
Hydration corrected it, so nobody could see it while nothing was server-rendered. But view-source carried the wrong URL, and the browser fired a real preload request at a private address on every page load. The detail page now builds image URLs from the loader’s known public origin, and refuses a loopback address rather than emitting one; no image beats a broken one in a social card. The underlying module-scope resolution is still wrong for the catalog grid and is filed as a separate defect.
3. Metadata and structured data: what is actually still worth shipping
Section titled “3. Metadata and structured data: what is actually still worth shipping”Two of the three obvious schema types have been retired since this codebase was started. Checked on 2026-08-16 rather than assumed, because shipping markup for a rich result that no longer exists is how SEO work becomes cargo cult.
| Type | Status | Shipped? |
|---|---|---|
| SoftwareApplication | Live. Still in Google’s Search Gallery as “Software app”. Requires name + offers with price/priceCurrency; price: "0" is the documented value for free software. | Yes |
| BreadcrumbList | Live, supported, and the one that visibly changes the SERP line today. | Yes |
| FAQPage | Retired in Google Search on 2026-05-07. Restricted to authoritative gov/health publishers in Aug 2023, then dropped for everyone. | Yes, but not for Google |
| aggregateRating | Live, and the field that draws the stars. | NEVER |
Two of those rows are decisions, not facts:
-
FAQPage is emitted anyway, and not for Google. It remains a valid schema.org type parsed by Bing and by the retrieval crawlers. It buys zero Google SERP real estate and this proposal should not be read as claiming otherwise. The part that still works in Google is the visible Q&A copy, through featured snippets and AI Overviews, which is why the FAQ block renders always-open rather than behind a disclosure.
-
aggregateRatingis never emitted, and that is enforced by a test. We have no ratings. Synthesising one is a structured-data spam violation with a manual action attached, and it is a lie told to a visitor who will find out during the install. When the store grows real reviews, that is where they go; until then the absence is the correct value.
Also shipped: per-page <title> (length-capped to what Google renders, with a
degradation order that drops the descriptor before it drops the app name),
<meta name="description">, <link rel="canonical">, OpenGraph and
twitter:card (summary, not summary_large_image; the only per-app art we
own is a square logo, and declaring the large card against a 96 px SVG renders
a smeared banner).
No head library was needed. React 19 hoists <title>/<meta>/<link>
into <head> during server rendering, and one renders through
renderToReadableStream. one’s own Head export is a pass-through
component for exactly this reason.
3.1 The JSON-LD is a text child, and that is a security property
Section titled “3.1 The JSON-LD is a text child, and that is a security property”The usual advice is to inject JSON-LD with React’s raw-markup prop. Measured
on React 19.2.5, that advice is both unnecessary and dangerous here; an FAQ
answer containing </script> would break out of the element. React’s actual
behaviour:
React.createElement("script", { type: "application/ld+json" }, JSON.stringify({ name: 'A "quoted" & <b>bold</b> </script> thing' }))
→ <script type="application/ld+json">{"name":"A \"quoted\" & <b>bold</b> </script> thing"}</script>React does not HTML-escape inside <script> (quotes and ampersands pass
through, so the JSON stays parseable), and it does neutralise the one
breakout sequence, rewriting </script as </script, which is still a valid
JSON string escape. Both halves solved by the renderer, with no sanitizer and
no markup string anywhere. Changing that line to inject markup would be a
regression in a security property, not a refactor.
4. sitemap.xml and robots.txt
Section titled “4. sitemap.xml and robots.txt”Both are API routes (routes/sitemap.xml+api.ts, routes/robots.txt+api.ts),
generated per request with a one-hour cache, not baked at build time. The
catalogue is data on the bench, not in the image: a seed run adds a listing
without rebuilding the storefront, and a build-time sitemap would go stale
silently, in the direction that hides new apps from search.
Proven output: 92 URLs (90 published listings plus / and /about),
with <lastmod> from each row’s modified. limit_page_length=0 is
load-bearing; without it Frappe’s default cap would have shipped 20 of 90,
which is the kind of bug that looks like it works.
Presets are deliberately excluded for now. The sibling lane’s ~77 App
Preset rows render as a section of the app page, not as their own URLs. A
sitemap listing URLs that resolve to a page-with-a-fragment is a
duplicate-content report filed against yourself. They belong in the sitemap
the day /apps/<app>/presets/<preset> is a real route with its own canonical,
which is a genuinely good SEO idea (77 more long-tail pages) and is out of
scope here.
5. ★ Where per-app content lives, and the authoring-format ruling
Section titled “5. ★ Where per-app content lives, and the authoring-format ruling”This is the load-bearing design decision and the one the owner has to sign off.
5.1 Transport: the bench, following the icon lane
Section titled “5.1 Transport: the bench, following the icon lane”The icon lane’s argument applies unchanged: the catalogue is data and the
bench is its system of record. Baking landing copy into the storefront image
would make one wording change need a frontend rebuild, an image publish and a
manual production deploy, where every other catalogue change needs only a seed
run. So landing: is authored in app.yaml, validated and serialised by
import_catalog.py, and stored in one new landing_json Long Text field on
App Listing.
Deliberate departures from the icon precedent:
- A field, not a new DocType. The content is 1:1 with a listing and the bench-migrate trap (§9) makes every new DocType more expensive than a field.
- A JSON blob, not a child table. The blocks are a heterogeneous nested
list a child table cannot express, and the preset lane already measured the
other reason: Frappe rewrites a child table wholesale on every parent PUT,
which would churn rows and
modifiedstamps on every seed run against production, against a seeder whose whole contract is that a re-run writes nothing. - Validation lives in CI, not in Frappe. The bench is a transport here,
not an editor. The seeder’s
--dry-runruns on every main push and refuses a malformed block there.
5.2 ★ Format: a closed block vocabulary. Not HTML. Not markdown. Not MDX.
Section titled “5.2 ★ Format: a closed block vocabulary. Not HTML. Not markdown. Not MDX.”The recommendation is a fixed set of typed YAML blocks, and the argument is that the marketplace is a store.
App packages are authored by us today. A paid-app program is ruled. The moment a third party can author a package, everything that package carries is untrusted input rendering on a page every visitor loads.
- Raw HTML is a stored-XSS hole with a supply chain in front of it. Not a
hypothetical: the icon lane already found this shape and screens SVGs for
<script>before storing them, because/files/is served from the bench’s own origin. - Markdown is not much better. Every mainstream markdown renderer passes raw HTML through by default. “Markdown” in practice means “HTML plus a sanitizer you must never misconfigure”, and that sanitizer becomes a security-critical dependency on the render path forever.
- MDX is worse again. It compiles and executes JavaScript. An author-supplied MDX file is arbitrary code running in the seeder or the build.
With a closed vocabulary, every author string reaches the DOM as a React text child, which React escapes by construction. There is no sanitizer to misconfigure because there is never a markup string to sanitize. The worst a hostile author can do is write rude prose, a moderation problem, not a security one.
The cost is accepted deliberately: an author cannot invent a layout.
Adding a block shape is a code change to landing/blocks.ts and its
renderer, reviewed like any other code. That is the trade: expressiveness
spent to buy a render path with no injection surface, and a page set that
looks like one designed store rather than 22 different blog posts.
The vocabulary as built: hero, highlights, metrics, steps, faq,
cta.
The gate is enforced twice, on purpose. The seeder is the write-side gate
(fails CI, loudly); parseLandingBlocks is the read-side gate (drops silently,
so a page still renders). The seeder cannot be the only guard; the bench
field is writable by any System Manager and a future vendor portal will write
it. The storefront cannot be the only guard; a bad package should fail in CI,
not render as nothing in production.
Refusals proven by mutation (§8): unknown block type, colour injected through the accent field, non-string field, missing required copy, over-length copy, too many blocks, too many items, over-budget total, and ten kinds of garbage.
One thing an author can set that touches CSS: the hero accent. It is a name from a list of six, resolved to a class the repo owns. Author-supplied colour strings are a styling injection vector, and there is no reason to accept one for a palette of six hues.
6. Animation, and the byte budget it has to live inside
Section titled “6. Animation, and the byte budget it has to live inside”apps/marketplace/landing.css, ~2 KB of hand-written CSS: a rise-in with
staggered delays, a slow 18-second gradient drift on the hero wash, a
hover-only card lift gated on (hover: hover) so a phone does not paint a
stuck hover state on tap.
No animation library. The storefront’s last performance defect was 16.5 MB of decompressed CSS, and the SSR smoke now caps the document at 1,200,000 decompressed bytes and any linked stylesheet at 20,000. A motion runtime would put JavaScript on the critical path of a page whose entire job is to be readable with JavaScript switched off. Measured after: the linked stylesheet is 1,815 bytes, comfortably inside its ceiling.
Reduced motion is opted out in one place, not per rule (a new keyframe
cannot be added that forgets it), and elements are pinned to the animation’s
end state, so a cancelled rise leaves content visible rather than stuck at
opacity: 0, which is the bug that makes “reduced motion” mean “blank page”.
6.1 ★ The real cost, measured, and the cap it forced
Section titled “6.1 ★ The real cost, measured, and the cap it forced”| page | document (decompressed) | gzip | visible text |
|---|---|---|---|
live prod /apps/nextcloud (today) | 745,261 | 76,824 | 99 chars |
this branch, /apps/minio (no landing blocks) | 736,001 | 70,172 | 476 chars |
this branch, /apps/nextcloud (six blocks) | 919,118 | 81,277 | 12,934 chars |
(Both rows off the same build, served by the same process; an earlier measurement quoted here used two different builds and overstated the amplification by 10%.)
Two things to read off that table.
A page with no landing content got smaller and vastly more indexable. 736,001 against today’s 745,261, because the server now renders the real screen instead of a loading skeleton. Every one of the 90 apps gets a title, a meta description, a canonical, structured data and its own name in the HTML, for negative bytes. The landing blocks are strictly opt-in on top.
And the amplification is brutal:
document cost of the exemplar's landing content : 183,117 byteslanding_json that produced it : 3,774 bytesAMPLIFICATION : 48.5 document bytes per landing_json byteThat is not the copy; 12,458 characters of prose is 12 KB. It is Tamagui’s atomic class attributes, which is what server-rendering a styled tree costs.
Which means the per-field caps alone were not enough, and this lane caught it before shipping. 8 blocks × 6 items × (600 + 160 chars) is 36,480 characters of permitted copy ≈ 536,000 document bytes on a 736,000-byte base, over the ceiling. And the SSR smoke would not have caught it, because the smoke only renders the root route.
So the total budget is derived, not chosen:
1,200,000 ceiling - 736,001 generic detail page = 463,999 headroomless 200,000 reserved for catalogue growth and for whatever the next lane adds to this page = 263,999/ 48.5 = 5,440 bytesmax_landing_json_bytes = 5000, rounded down from 5,440, because the
amplification is a measurement of one page and not a constant. The exemplar
serialises to 3,774, so the cap is not tuned to fit the one page that exists;
it has a quarter of its budget spare. Raising it means re-measuring the
amplification first.
Known gap: the SSR smoke tests / only, so nothing in CI would catch a
detail page going over. Extending it needs a fixture bench in CI. Filed in
§10.
7. Degradation: 68 apps must not look unfinished
Section titled “7. Degradation: 68 apps must not look unfinished”LandingSections returns null on an empty list, and every block renders
only from its own items. An app with no landing: renders no heading, no
empty state, no “coming soon”, byte-for-byte the page it rendered before
this feature existed, plus the SEO head it now gets for free. Proven on
/apps/minio: no shc-hero-wash in the document, 736,001 bytes, full
metadata.
8. Proof
Section titled “8. Proof”Built with pnpm --filter @app/marketplace build; served with the same
node one/run.mjs serve the image’s CMD runs.
The bench data is real production data. A local proxy forwards every
request verbatim to https://api.marketplace.selfhostedcloud.org and injects
exactly one thing: landing_json on the nextcloud listing, because that field
cannot exist on the live bench yet (§9). So this proves the whole render path
(app.yaml → validated JSON → bench wire shape → server loader → SSR’d HTML),
with the Frappe upsert itself the only untested link, and that link is
blocked on someone else’s landing.
8.1 What a crawler that runs no JavaScript receives
Section titled “8.1 What a crawler that runs no JavaScript receives”$ curl -sS http://127.0.0.1:3799/apps/nextcloud # no JS executed
document bytes (decompressed) : 919,118 ceiling 1,200,000 headroom 280,882 gzip -9 transfer bytes : 81,277 <title> : Nextcloud: self-hosted collaboration · SHC Marketplace occurrences of "Nextcloud" : 67 (was 6, all of them URL echoes) visible text chars : 12,934 (was 99) JSON-LD @graph types : SoftwareApplication, BreadcrumbList, FAQPage
"Your files, your server, your rules" in HTML: YES "Single sign-on that actually signs out" in HTML: YES "Do I need Keycloak to run this?" in HTML: YES "Install it on your own infrastructure" in HTML: YES
$ curl -sS http://127.0.0.1:3799/sitemap.xml → 200, 15,016 bytes, 92 <url>$ curl -sS http://127.0.0.1:3799/robots.txt → 200, Sitemap: …/sitemap.xml8.2 Guards
Section titled “8.2 Guards”scripts/ci-marketplace-ssr-smoke.sh OK: 735,873 bytes (ceiling 1,200,000)scripts/check-ssr-bundle-selfcontained.sh ssr bundle is self-containedlinked stylesheet _layout-*.css 1,815 bytes (ceiling 20,000)import_catalog.py --dry-run 90 packages, 77 presets, every row buildspnpm vitest run (features/marketplace) 11 files, 122 tests passedpnpm lint clean (pre-existing no-console warnings only)pnpm typecheck (@features/marketplace, @app/marketplace) clean8.3 Mutation proofs
Section titled “8.3 Mutation proofs”Write side (import_catalog.py), each refused with a specific message:
unknown block type · accent: "red; background:url(//evil)" · 300-char
headline over a 120 cap · non-string field · 9 blocks over the 8 cap ·
38,025-byte total over the 5,000-byte budget.
Read side (parseLandingBlocks, 12 cases): unknown type dropped · iframe
dropped · injected accent dropped while the rest of the block survives ·
non-string dropped · missing required copy dropped · over-long copy truncated
with an ellipsis · block and item caps · byte budget stops early · never
throws on ten kinds of garbage · whitespace collapsed.
SEO side (13 cases): title ≤ 60 chars and drops the descriptor before the app
name · description ≤ 160 · canonical absolute and percent-encoded, no double
slash · aggregateRating/ratingValue/reviewCount never appear ·
offers exactly as Google requires · FAQPage only when there are pairs ·
empty keys pruned · JSON stays parseable when author copy contains ", &,
<b> and </script> · sitemap escapes XML, skips nameless rows, omits empty
<lastmod>.
8.4 Browser, four states, looked at
Section titled “8.4 Browser, four states, looked at”.seo-shots/: 1440 px and 390 px, light and dark, real Chrome.
- Desktop light/dark: install action top-right at its natural 44 px, glyph
112 px, H1 32 px, hero headline 38 px,
shc-driftrunning, gradient resolved. Hero → highlights (4-up) → metrics → steps → FAQ → CTA → the technical sections below. - Phone light/dark: single column, full-width install,
documentElement.scrollWidth==innerWidth== 390; no horizontal overflow. - Console: no hydration errors, no React warnings. (The CORS errors present are an artefact of the local harness pointing the client at the real cross-origin bench, and they incidentally prove the SSR path is self-sufficient: the page renders completely with every client fetch failing.)
8.5 ★ A defect found and NOT caused by this lane
Section titled “8.5 ★ A defect found and NOT caused by this lane”The Install button (the store’s primary call to action) is illegible in light mode. Measured on the rendered page:
label rgb(255,255,255) on fill rgb(238,236,249)contrast ratio 1.17 : 1 (WCAG AA large text needs 3.0 : 1)Confirmed identical on the live production page, so it predates this branch;
dark mode renders correctly. theme="accent" is resolving to a near-white
fill in the light theme while the label is pinned to #ffffff by
ListingDetailScreen. Not fixed here because the cause is in the theme
package and touching it risks the console. It should be fixed before anyone
is driven to these pages by search.
9. ★ This does not reach production yet, and the reason is not this lane
Section titled “9. ★ This does not reach production yet, and the reason is not this lane”deploy/shc/marketplace/compose.yaml’s bench-init never runs bench migrate.
A newly declared DocType field is therefore silently dropped on redeploy:
the image is right, the site DB is stale, and the deploy reports SUCCESS.
landing_json is a new field. Until the sibling lane fixing bench-init
lands, the seeder will write landing content that the bench cannot store, and
every app page will render exactly as it does in §7, correct, indexable, and
with no landing blocks. That is a safe failure mode, and it is why the
exemplar was proven against an injection proxy rather than by claiming a green
deploy.
Everything else in this lane (the loader, the metadata, the JSON-LD, the
sitemap, robots.txt, the media-query fix, the icon-origin fix) needs no
schema change and would take effect on the next storefront deploy.
10. Follow-ups this lane deliberately did not do
Section titled “10. Follow-ups this lane deliberately did not do”- Write the other 21 flagship landing pages. Editorial work, ~4 KB each, and every claim has to be checkable against the package’s own files.
- Extend the SSR smoke to a detail route. It renders
/only, so nothing in CI would catch a landing page going over the ceiling. Needs a fixture bench. - Move
CatalogScreenoffuseMedia()before the home page is server-rendered with data; same freeze (§2.2). - Fix the module-scope base-URL resolution in
src/app.ts; the catalog grid still SSRs icon URLs pointing atlocalhost:8002(§2.3). - Fix the Install button contrast (§8.5).
- Give presets their own routes (
/apps/<app>/presets/<preset>) and put them in the sitemap: 77 more long-tail pages. - Serve brotli. The edge serves gzip only; the storefront’s atomic CSS compresses ~46× under gzip and materially better under brotli. Free, and not this lane’s file to edit.
11. Questions only the owner can answer
Section titled “11. Questions only the owner can answer”-
★ Is the closed block vocabulary the ruling, or do you want markdown? This decides who can write these pages and how much safety machinery is needed. Closed blocks: anyone can write copy, no sanitizer ever, pages stay visually coherent, and adding a shape needs a code review. Markdown: more expressive, and it permanently puts a sanitizer on a path that renders third-party content to every visitor. This proposal recommends closed blocks and has built them; the answer is reversible now and expensive later.
-
Do you want a “flagship” tier that is visibly different, or should any app be allowed a landing page? Today the field is open to all 90; the difference is purely who bothers to write one. If flagship should look like a tier, that is a design decision to make now (extra block types, a wider layout) rather than after 22 pages exist.
-
Who writes the copy, and who checks the claims? Everything in the Nextcloud exemplar is verifiable against that package’s own files, on purpose. A store page that overstates is worse than no store page, because the reader finds out during the install. Is there a review step for marketing claims, or is the “must be checkable” rule enough?
-
Is
price: "0"the right thing to publish? It is required for the Software app rich result and it is true today. When a paid-app program exists, this becomes a real commerce declaration and the offers block will need real prices and terms. -
How much of the byte budget do you want spent on landing copy?
max_landing_json_bytes = 5000reserves 200 KB of the ceiling for catalogue growth. Richer pages are possible, and the honest way to buy headroom is to reduce the 48.5× markup amplification, not to raise the ceiling.