Feature‑Card Automation: A 90‑Minute Repo→JSON‑LD Sprint to Keep Feature Metadata Fresh
Written by AppWispr editorial
Return to blogFEATURE‑CARD AUTOMATION: A 90‑MINUTE REPO→JSON‑LD SPRINT TO KEEP FEATURE METADATA FRESH
If you ship features from a git repo, you can make each feature self-describing and machine‑readable without a separate CMS. This post gives a tight, repo‑first workflow — validated CI, semantic feature IDs, changelog generation, and automatic JSON‑LD builds — that turns a single feature commit into an updated feature card in about 90 minutes. Included: templates you can drop into a repo, GitHub Actions snippets, and safe rollback guidance.
Section 1
Why a repo‑first feature card matters
Product teams ship features from code, but the surface systems that need feature metadata (marketing pages, product directories, in‑app help, search engines, and AI indexers) often rely on stale manual entries. A repo‑first approach keeps the canonical record inside the thing you already change: the feature commit and its files.
By baking structured metadata into the repo and producing JSON‑LD automatically at CI time, you create one source of truth that powers human pages and machine consumers (search, assistants, internal catalogs). Use schema.org types like SoftwareApplication or CreativeWork as the base vocabulary so external parsers have a standard interpretation. See schema.org and Google's SoftwareApplication guidance for fields search engines consume.
- Single source of truth: metadata lives with the code that created the feature.
- Machine-ready output: JSON‑LD that search engines and internal agents can consume.
- Low cognitive overhead: write a short structured file alongside the feature.
Section 2
90‑minute sprint: what you’ll add to your repo
This sprint focuses on four deliverables you can implement in an hour and a half: (1) a feature metadata template file, (2) a commit convention and semantic ID pattern, (3) a small CI job to validate and build JSON‑LD, and (4) changelog automation to capture the human narrative.
Keep the feature metadata file intentionally small and human‑editable — a single YAML or JSON file per feature in a directory like /features/*.yaml. Use semantic IDs that are stable and URLable (for example: feature:auth/passwordless → feature-auth-passwordless). Commit messages should follow a lightweight conventional‑commits style (feat(scope): short subject) so automation can classify entries for changelog generation.
- Feature file: /features/<semantic-id>.yaml (meta fields + short description).
- Commit message convention: use conventional commits to enable changelog tooling.
- CI job: validate against a JSON Schema, produce an aggregated JSON‑LD bundle, and deploy it to your site or CDN.
Sources used in this section
Section 3
Practical templates and CI snippets (drop into your repo)
Feature metadata template (YAML). Save as /features/feature-<id>.yaml. Keep fields minimal: id, title, summary, author, dateIntroduced, status, tags, and optional changelog entry. A tiny example will be easier for engineers to adopt than a large schema-heavy file.
Validation and build: add a GitHub Action that runs on pushes to main and on pull requests. Steps: (1) run a JSON Schema validator against the feature files, (2) generate JSON‑LD from the validated YAML/JSON (use a small Node/Python script or an action), and (3) commit or publish the generated bundle to your website (or to a dedicated branch/artifact). Use an off‑the‑shelf JSON schema validator action to keep the CI concise.
- Minimal feature YAML fields: id, title, description, dateIntroduced, status, tags, url, relatedFeatures.
- GitHub Action essentials: checkout → validate (jsonschema) → build script → publish artifact or deploy to site/branch.
- Prefer publishing generated JSON‑LD to a read‑only folder (e.g., /public/feature-cards/) to avoid edit conflicts.
Section 4
Changelog and semantic IDs: make history useful
Automated changelogs are valuable but noisy if they include every small commit. Use Conventional Commits and either a conservative changelog tool or a curated step. Tools inspired by Keep a Changelog and Common Changelog conventions give you a human‑readable CHANGELOG.md while your CI can still emit raw entries for machine consumption.
Semantic IDs should be deterministic and collision‑resistant: prefer a normalized slug of the feature title prefixed with a domain‑safe namespace (for example appwispr:feature:auth-passwordless). Record creation date and source commit SHA in the generated JSON‑LD to make rollbacks and audits straightforward.
- Use conventional commit messages (feat/fix/docs) to classify changelog entries automatically.
- Changelog generation: draft entries from commit messages, but require a human review step before publishing to external changelogs.
- Include metadata: createdBy (commit SHA), dateModified, and predecessor/successor references for lineage.
Sources used in this section
Section 5
Rollback, safety, and long‑term maintenance
Treat the generated JSON‑LD as a build artifact, not the canonical source. That means rollbacks are a matter of reverting the feature metadata file or the commit that introduced it. Keep the generated bundle in a commitable artifact location (CI can open a PR or push to a branch) so normal git tooling handles rollbacks.
For maintenance, add schema validation to protect consumers from accidental breaking changes, and schedule a quarterly check to reconcile feature files with live product state. Also include lightweight tests that assert required fields exist for every feature file to catch omissions early in CI.
- Generated JSON‑LD is a derived artifact — revert the metadata file or the originating commit to rollback.
- Add CI validation gates (JSON Schema + tests) to prevent malformed output from reaching production.
- Quarterly reconcilers: script that verifies features in the repo match the product (status flags, dates).
Sources used in this section
FAQ
Common follow-up questions
Which schema or JSON‑LD type should I use for a feature card?
Start with schema.org's SoftwareApplication or CreativeWork as a base and include a concise feature-specific object inside (featureList or custom properties). The SoftwareApplication guidance from Google highlights fields search engines care about; use applicationCategory, featureList, dateModified and url to help external consumers understand the feature.
How do I keep changelog automation from publishing low‑value commits?
Use Conventional Commits to categorize messages and configure your changelog tool to include only types you consider notable (for example feat, fix, perf). Draft changelog entries automatically but gate the public CHANGELOG.md update behind a human review step or a specific release PR.
Where should generated JSON‑LD live so consumers can find it?
Publish the generated JSON‑LD to a predictable public path on your site (for example /feature-cards/feature-auth-passwordless.json) or push it as a versioned artifact to a dedicated branch. Keep a sitemap or index file that lists available feature cards so crawlers and internal agents can discover them easily.
What happens if a feature file schema changes and breaks consumers?
Schema validation in CI should catch incompatible changes before deployment. If a breaking change slips through, revert the feature metadata commit or restore the previous generated artifact from your CI artifacts or git history. Include the commit SHA and dateModified inside the JSON‑LD so you can quickly identify the originating commit.
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.
Software App (SoftwareApplication) Schema | Google Search Central
https://developers.google.com/search/docs/appearance/structured-data/software-app
schema.org
SoftwareApplication - Schema.org Type
https://schema.org/SoftwareApplication
JSON-LD Working Group
JSON-LD 1.1
https://json-ld.github.io/json-ld.org/spec/latest/json-ld/
GitHub Marketplace
JSON Schema Validate · Actions · GitHub Marketplace
https://github.com/marketplace/actions/json-schema-validate
Referenced source
Keep a Changelog
https://keepachangelog.com/en/2.0.0/
Referenced source
Common Changelog
https://common-changelog.org/
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.