AppWispr

Find what to build

Spec‑First Feature Pages: A 7‑Field PRD That Publishes Copy, JSON‑LD, a 60s Demo, and Acceptance Tests

AW

Written by AppWispr editorial

Return to blog
P
PT
AW

SPEC‑FIRST FEATURE PAGES: A 7‑FIELD PRD THAT PUBLISHES COPY, JSON‑LD, A 60S DEMO, AND ACCEPTANCE TESTS

ProductAugust 21, 20265 min read1,014 words

Ship fewer drafts and fewer meetings. This post gives founders and product builders a compact, opinionated 7‑field PRD template — written as a single spec — that you can copy into a CMS to produce: (1) the feature landing page copy, (2) valid JSON‑LD for search, (3) a 60‑second demo script, and (4) Given/When/Then acceptance tests. Each field maps to export snippets you can paste into code, content, and QA workflows.

spec-first-feature-pagesPRD templateJSON-LDacceptance testsproduct demo scriptfeature landing page

Section 1

Why 'spec‑first' feature pages beat copy‑then‑spec workflows

Link section

Marketing copy and engineering specs are different animals. When you write copy first you recreate product meaning in another pass; when you write specs first, you capture intent once and derive artifacts from it. That reduces handoffs and prevents the product and page from drifting apart as engineers ship changes.

A spec‑first approach treats the PRD as the single source of truth: content writers and search markup generators read the same seven fields engineers use to build the feature. This enables consistent messaging, accurate structured data (JSON‑LD), and acceptance tests that are traceable to the same sentences on the page.

  • Fewer rewrites: one authoritative doc instead of separate copy & spec drafts.
  • Automated exports: generate JSON‑LD and demo scripts from the same fields.
  • Traceability: acceptance tests read like the landing page, reducing discrepancies.

Section 2

The 7‑field PRD (what to write and why)

Link section

Keep the PRD deliberately small. Each field maps to a publishing artifact and must be short enough to be consumed programmatically. The seven fields are: Title, One‑line Promise, Problem, How it Works (3 steps), Key Benefits (3 bullets), Target Persona & Context, Acceptance Criteria (Given/When/Then).

Write each field as a single atomic unit: Title becomes the page H1 and the JSON‑LD name; One‑line Promise becomes meta description and the first paragraph; How it Works becomes the demo script steps and the 'featureList' in JSON‑LD; Acceptance Criteria become the source for automated tests.

  • Title → H1, JSON‑LD name
  • One‑line Promise → meta description, lead paragraph
  • Problem → short paragraph that explains the cost of inaction
  • How it Works → 3 numbered steps used for demo & featureList
  • Key Benefits → 3 bullets used in page highlights and schema keywords
  • Persona & Context → audience targeting and demo persona line (for scripts)

Section 3

Export rules: copy, JSON‑LD, 60‑s demo script

Link section

Map fields to outputs with simple templates. Use the Title, One‑line Promise, Problem, and Key Benefits to assemble the page copy. For JSON‑LD, use schema.org's SoftwareApplication or Product structure and populate fields like name, description, featureList, datePublished, and offers when relevant. Google’s developer docs show practical SoftwareApplication and Product examples you can model.

For a 60‑second demo script, convert How it Works (3 steps) into a three‑act script: 10s setup (persona + problem), 35s walkthrough (each step 10–12s with one benefit), 15s close (result + CTA). Keep language executable: 'Show login → click Create Template → show generated JSON‑LD preview'.

  • JSON‑LD: map 'How it Works' → featureList, 'Title' → name, 'One‑line Promise' → description.
  • Demo: 10s setup, 35s walkthrough (3 steps), 15s close — total ≈ 60s.
  • Copy: first paragraph = One‑line Promise + Problem sentence; bullets = Key Benefits.

Section 4

From Acceptance Criteria to automated tests (practical patterns)

Link section

Write acceptance criteria in Given/When/Then (GWT) format. Each GWT scenario in the PRD becomes one acceptance test that QA or your CI framework can run or validate. Keep scenarios specific: include the persona, preconditions, the action, and the measurable outcome.

Use the same examples on the page as the fixtures in tests. When tools (Cucumber, SpecFlow, Robot Framework) parse Gherkin‑style scenarios, your engineering team can implement step definitions that call production code or run against a staging environment. That keeps behavior, documentation, and tests aligned.

  • One acceptance criterion = one GWT scenario → one automated test.
  • Include example data in the PRD so tests are executable without ambiguous stubs.
  • Prefer few, high‑value scenarios that cover happy path, key edge, and a failure mode.

Section 5

Examples and copyable snippets (how to export quickly)

Link section

Below are compact export templates you can implement as small scripts in your CMS or product tooling. The idea: paste the 7 fields and the system emits three outputs. Use whatever templating system your stack supports (Liquid, Handlebars, or a small Node/Python script).

Export snippet patterns: JSON‑LD using SoftwareApplication/Product, demo script assembly rule, and Gherkin acceptance test generation. These are intentionally short so you can paste them into a generator or a CMS field that performs the transformation.

  • JSON‑LD snippet pattern: populate @type, name, description, featureList, datePublished (follow Google schema guidance).
  • Demo script pattern: [Persona] (10s) → Step 1 (12s) → Step 2 (12s) → Step 3 (11s) → Close (15s).
  • Acceptance test snippet: Gherkin scenario with Given/When/Then filled from Acceptance Criteria.

FAQ

Common follow-up questions

Can I use the same PRD for multiple feature pages?

Yes — write one authoritative PRD per feature and derive language variants for separate pages. If two pages target different personas, keep a single core PRD and add an optional 'persona variant' field that contains the alternate One‑line Promise and CTA so exports can produce tailored pages.

How do I make sure my JSON‑LD is valid for Google?

Follow schema.org vocabularies (SoftwareApplication or Product) and Google's structured data docs. Include required fields (name, description) and test output with Google's Rich Results Test or Search Console. Ensure datePublished/dateModified reflect reality and avoid blocking the JSON‑LD in robots.txt.

How many acceptance tests should I write per PRD?

Focus on the minimal set that proves the feature works: typically 3–6 scenarios covering the happy path, one core edge case, and one negative/failure case. Acceptance tests should be executable and traceable to PRD lines.

Can non-technical founders write testable acceptance criteria?

Yes. Use the Given/When/Then template and provide concrete example data. Pair early with an engineer or QA to translate wording into test steps; over time the team will converge on language that reads clearly both for humans and test parsers.

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.