FAQ and Self-Service Content on Shopify

Definition

Answers a shopper can find without contacting support, rendered by the theme from data the storefront owns: FAQ accordions and product information tabs read from page, product or variant metafields, theme blocks or a Shopify page; help-center corpora moved out of an app into Shopify data; a diagnostic quiz authored as metaobjects; and question-and-answer content that emits FAQPage structured data from the same source the accordion renders.

The Evidence

• Evidence strength: 14 live, Deploi-attributed builds across 3 Shopify storefronts.
• Split by storefront: LUS Brands 6, Three Ships 5, Nudestix 3.
• Split by attribution: 11 Deploi-authored, 3 modifications of vendor theme code — named as such on each build page.
• Evidence quality: 6 carry code plus client working records. 8 are documented from the code; no client-side record of the decision survives.
• Confidence: 4 strong, 10 moderate.
• Surfaces: landing pages first, then the storefront-wide data those pages read, the product page and the blog. One build runs in the cart.
• Status: Live, verified 2026-09-07. Buy-vs-build verdict: build, with one documented move from an app back into Shopify data — see below.

How It's Actually Built

Shopify has no FAQ primitive. There is no question type, no answer store and no accordion in the platform; a page has one body and a product has one description. So every self-service surface here is the same two decisions in the same order: pick a home for the answers, then write the renderer. The renderer is the smaller decision. The home decides who can edit an answer, where else it can render, and whether structured data can be generated from it without a second copy.

Home one: a page metafield. LUS Brands' help center reads page.metafields.custom.faq_sections — sections, each with a name, an items list and an optional nested categories list — and renders it as a two-level accordion inside the shell of the help-center app the page already ran on. Liquid has no groupBy, so where an entry arrives without categories the section derives them (map: 'category' | compact | uniq) and emits uncategorized questions first. Panel ids are composed from section.id, the section's index and a running counter threaded through faq-category-group.liquid by hand, because Liquid won't carry a counter across a snippet boundary; every question also gets a handleized anchor. The kids sub-brand's FAQ page reads the same field and renders it flat — a role="button" trigger into a role="region" panel — so moving a question between the two pages is moving data, not re-authoring it.

Home two: product and variant metafields under the buy box. de_product_info_tabs.liquid resolves How To, Ingredients, FAQs (custom.faqs) and Tips variant-first then product, and computes tab presence server-side from whether each field resolves to anything, so a product with no tips shows no Tips tab. On variant change the section re-fetches itself by section_id through the Section Rendering API and swaps four regions in place, with a recomputed data-has-ingredients flag riding back in the same response — presence and content come from the same Liquid and can't disagree.

Home three: theme blocks, and the Shopify pages they point at. Three Ships' product-page FAQ is the premium theme's own Tabs section. A Text block carries its answer as rich text; a Page block points raw_content at a Shopify page whose body is the answer, so one page serves many products. We left the vendor's schema and collapsible runtime alone and added a mobile reveal past the third row and a FAQPage block that loops section.blocks a second time, emitting one Question per block from the same pages[block.settings.raw_content].content | default: expression the accordion renders, through strip_html and json, gated on request.page_type. The shopper's row and the machine's answer are the same Liquid.

Home four: metaobjects. The curl quiz is self-service content in the strictest sense — nine questions that answer the one a curly-hair shopper can't answer for themselves — and none of it is in the theme. curl-quiz.liquid renders whatever the curl_quiz metaobject contains: one [data-cq-pane] per question, with selection rules projected onto data-cq-min, data-cq-max and per-option data-cq-exclusive for the controller to enforce. Six metaobject definitions and 103 entries carry the model; the theme editor exposes a single setting. Completion is a window-level curl-quiz:results event the results section subscribes to.

One more home, and the loosest fit on this page: theme settings. Nudestix's cart reads settings.free_shipping_txt with a ${addMoreForFreeShip} placeholder the merchandiser writes into the sentence, computes the remainder in Liquid on every render, and shows a signed-out visitor a first-order card that asks them to sign in rather than promising a gift the theme can't verify. It's self-service because the cart answers "how much more?" before anyone emails support. We'd call it a cart build first, and we list it here because the corpus files it here.

The Buy-vs-Build Position

The corpus's own verdict on this capability:

One storefront migrated its FAQ out of a help-center app into metafields and kept the app only as a shell — a documented BUY-to-BUILD move.

That verdict runs the other way from most of the section. The app was already installed and rendering the page; the work moved the corpus into a Shopify page metafield and left the vendor's chrome where it was, as a scope call. The reason was never the accordion. An app's FAQ list is a fine FAQ list until you want the same answers in a product tab, a sub-brand page and a machine-readable format — at which point the content is in the wrong database, and no amount of app features moves it. Our full reasoning, including where an FAQ app is the right purchase, is in the FAQ and self-service center decision.

The Builds

Six of the 14 have published pages. Six of the remaining eight are documented and to follow: a full-page and an embeddable FAQ accordion pair and a shipping-and-returns page on Nudestix, a scroll-spy FAQ template and a guide section on Three Ships, and two structured-data builds whose FAQPage nodes are the markup half of this capability. The other two are folded into build pages already published here.

LUS Brands

• Metafield-driven two-level FAQ accordion grafted into a help-center app's shell — the corpus moved into custom.faq_sections, grouped three ways, every answer anchored. High complexity, landing and storefront-wide data. A modification inside a vendor app's page shell, and the page says so.
• Kids FAQ page: single-level variant of the FAQ engine — the same metafield rendered flat for the kids sub-brand, with its own cross-link and contact prompt. Medium complexity, landing. Built inside the same shell; named as vendor modification.
• Metafield-driven product information tabs with mobile accordion and variant refresh — FAQs beside How To, Ingredients and Tips, with tab presence decided in Liquid and re-resolved per variant. High complexity, product page.
• Curl Quiz 3.0: a nine-step diagnostic quiz rendered entirely from Shopify metaobjects — questions, options and selection rules as metaobjects, one theme-editor setting. High complexity, dedicated quiz page.

Three Ships

• Product-page FAQ accordion: page-backed answers, mobile 'View More' reveal, auto-emitted FAQPage — the vendor's Tabs section with a reveal and structured data generated from its own block loop. Medium complexity, product page, listing pages and blog. An extension of Palo Alto 5.8.0 by Presidio Creative, a paid premium theme.

Nudestix

• Threshold-driven free shipping, deluxe sampling and a first-order gift notice — merchandiser-written threshold sentences with a computed remainder, decided in Liquid on every cart render. High complexity, cart.

What This Rests On

• Liquid section schema and settings — every build here; on the deepest ones the schema is deliberately thin, because the content is not a setting.
• Metafields — the page-level corpus, the product and variant tab sources, and the article FAQ field the blog markup reads.
• Metaobjects — the quiz's entire data model, and the structured FAQ entries the product tabs render.
• Theme blocks — Text and Page blocks on the vendor's Tabs section; the block loop is the single source for the accordion and the markup.
• Section Rendering API — how the tabs re-resolve per variant and how the cart section re-renders after a mutation.
• Structured data — FAQPage emitted from the same Liquid the visible answers come from, never from a second copy.
• JSON templates — page.help-center, page.faq-kids and page.quiz: a dedicated template whose one section owns the route.
• Custom elements — the window-level event that is the whole contract between the quiz and its results.

What Varies by Storefront

The split is lopsided and it tracks content strategy. LUS Brands holds 6 of the 14 because a curly-hair catalog is genuinely diagnostic — which cleanser, which routine, is this safe for a four-year-old — and the brand decided its answers would live in its own data. Two of those six are records of work the other four already carry, so read the six as four distinct pieces of work. That storefront runs Dawn 15.4.1, and three of the four homes on this page appear there: a page metafield, product and variant metafields, and metaobjects. Its two vendor-modified builds are the two pages that render inside a help-center app's shell, and each says so.

Three Ships runs Palo Alto 5.8.0 by Presidio Creative, a paid premium theme, so its FAQ home is the vendor's block model and the work is additive inside vendor files. The distinctive move there is reuse: a Page block pointing at one Shopify page serves the same answer across many product templates, and the structured data is generated from that block loop rather than authored beside it. Its other self-service builds follow the same additive shape.

Nudestix runs Dawn 6.0.2 and holds the lightest end of the capability: accordions authored as section blocks on policy and landing pages, and the cart's threshold copy in theme settings. The answers there belong to a placement rather than a corpus — the right size for a shipping-and-returns page, the wrong size for anything that has to render twice.

Where This Gets Hard

Structure is by convention, because the platform has none. A page metafield holding sections, categories and questions is a shape the theme agreed with the content team, not one Shopify enforces: the section derives categories when they're missing, tolerates two spellings of the answer key, and threads its own counters. Each tolerance keeps a half-migrated field rendering, and each is a rule the theme knows and the admin doesn't show.

The home decides reuse, and each home pays differently. Section blocks are per-placement: a question in a block on one page can't render on another unless the block points at a Shopify page, which is why the premium-theme storefront's answers are pages. Metafields render anywhere but have no preview and no theme-editor representation. Metaobjects give a content team a safe place to edit and hand them a data model someone has to own. Theme settings are global — one sentence, one number, for the whole store.

Markup is only honest when it's generated. An accordion a shopper opens and a FAQPage a crawler reads are the same answers only if they come off the same Liquid. Where a surface renders answers without markup, they're visible to shoppers and invisible to everything else — the help center builds the structure that would make emitting it honest, and stops there.

Accordion semantics are component work, and they aren't free. A role="button" trigger with aria-expanded, a role="region" panel labeled by it, ids composed from section and index so a repeated section doesn't collide, transitions that respect prefers-reduced-motion — at both levels where there are two. A native <details> element gets a flat list most of that for nothing, which is an argument for a flat list.

So there are storefronts we would tell not to build this. A handful of questions on one page is a page body with <details> in it, not a content model. If nobody will fill and maintain the fields, a metafield schema renders as an expensive empty page. If your answers are the same across many products, a block pointing at one Shopify page is the whole solution. Build the metafield or metaobject home when the answers have to render in more than one place, or differ per product and per variant, and someone owns them.

Related Capabilities

• Structured data for AI answers and rich results — the markup half, including the FAQPage graphs authored beside the page rather than generated from it.
• Metafield-driven PDP content blocks — the same merchandiser-owned fields on the product page, where FAQs are one tab among four.
• Variant-aware content and media swapping — why the product tabs re-resolve per variant, and what that costs.
• Guided selling: quizzes, finders and routine builders — the quiz's home capability, and the results engine that listens for its event.
• Editorial blog and content hubs — where article FAQ metafields feed markup.

Answers to Help You Make Smart Decisions

Do I need an FAQ app on Shopify? Not for the accordion, and usually not at all. Native <details> elements or a small section render a question-and-answer list without a script, and the answers can live in a page metafield, product metafields or theme blocks the store already has. What an app adds is a dashboard, and what it costs is that your answers live there instead of in Shopify, where the rest of the theme can read them.

Where should FAQ answers live — metafields, blocks or a page? Wherever they have to render from. Blocks are right for answers that belong to one placement. A block pointing at a Shopify page is right for one answer reused across many products. A page or product metafield is right for a corpus that several templates read, or answers that differ per product and per variant. Metaobjects are right when the content has structure and rules a content team should own.

Can Shopify emit FAQPage structured data without an app? Yes, and it's the more reliable way. A theme section can loop the same blocks or the same metafield it renders and emit one Question per entry, with the answer passed through strip_html and json. Because both outputs come from one source, a merchandiser's edit changes the shopper's answer and the machine's answer at once. An app emitting markup from its own copy is the drift problem with a subscription.

Can one FAQ corpus feed more than one page? Yes, if the corpus is Shopify data. On one storefront a single page metafield holds sections of questions, and two templates read it — the main help center as a two-level accordion, the kids sub-brand's page as a flat list — so a question moves between them by moving data. That's the reason to take a corpus out of an app's dashboard, and it's the thing an app structurally can't offer.

Ready to Answer the Question Before It Becomes a Ticket?

If your best answers are locked in a dashboard the rest of your storefront can't read, moving them is a smaller job than it looks and the one that makes every surface after it easier. Contact us today and we'll tell you which home your answers belong in.