START HERE

What you will learn

  • Separate content records, page templates and interactive state.
  • Explain which frontend decisions affect publishing and maintainability.
  • Review accessibility, direct page access and form behaviour before release.

Before you start: An approved page pattern and someone able to implement React and TypeScript. Stakeholders can use the checks without writing code.

Reference edition: Fictional website walkthrough; providers are examples, not required services. Sources checked 2026-11-13.

Draw the component map before building pages

List the shared shell, navigation, footer, page heading, service card, article body and enquiry form. Give each component a clear responsibility and define which content it receives. A service-page template should not duplicate the same layout code for every service.

Build the static content and layout first, then add the interaction states the visitor needs. Keep a simple form’s input and status near the form rather than scattering them across unrelated global state. The implementation should make the approved design easier to maintain, not make every text edit require understanding the component tree.

Use a content model that editors can understand

A service record might contain a title, summary, audience, evidence references and the next action. An article adds a slug, revision date, author or owner, body and related reading. Store the authoritative content in structured files, a repository-backed editor or a CMS that fits the organisation’s needs.

TypeScript can catch some missing or incorrectly shaped fields during development. It does not verify facts or validate untrusted submissions at runtime. Validate external content before publishing and treat rich HTML carefully; do not render arbitrary user-provided markup as trusted page code.

Choose how complete pages reach readers

A React interface can be delivered using different rendering approaches. For an information-led site, prerendering or server rendering can provide useful page HTML before JavaScript runs. A client-only app needs deliberate routing, metadata and loading behaviour. Choose the approach against direct access, discoverability, accessibility and hosting requirements.

Test the deployed URL of an article directly, not just navigation from the homepage. Confirm page titles, canonical URLs, structured data where relevant, sitemap entries, asset paths and genuine missing-page responses. Staging should use its own indexing policy and should not accidentally promote preview settings to production.

Keep secrets and mail delivery on the server

The browser may know a public form endpoint or feature flag. It must not contain SMTP passwords, cloud keys or a secret used to authorise release. Frontend build variables are not a secret store; Vite variables exposed to client code can be inspected by visitors.

The enquiry form sends validated input to a server-side handler. That handler applies limits, decides approved recipients and invokes the mail provider. Show accurate states such as sending, accepted for processing and failed. Do not tell a visitor that an email reached an inbox merely because the browser received a successful response.

Review states, not only the happy path

List each interaction’s idle, editing, invalid, submitting, success and error states. Ensure every input has a real label, errors explain what to fix, keyboard focus remains usable and repeated clicks cannot easily duplicate a request. Use responsive images and reserve their dimensions to reduce layout movement.

For stakeholder review, use a short checklist: can a reader understand the page, complete the next action and recover from an error on a small screen? Technical review adds build, type, component and integration checks appropriate to the implementation. Record unresolved issues rather than assuming a successful build proves usability.

Technical examples

Separate a content record from a page component

Illustrative TypeScript/React structure, not a complete application. Content review and runtime input validation remain separate responsibilities.

type ServiceContent = {
  title: string;
  summary: string;
  enquiryPath: string;
};

function ServiceIntro({ content }: { content: ServiceContent }) {
  return (
    <section aria-labelledby="service-title">
      <h1 id="service-title">{content.title}</h1>
      <p>{content.summary}</p>
      <a href={content.enquiryPath}>Discuss your next step</a>
    </section>
  );
}

Step-by-step process

  1. Map the approved design to reusable components

    Identify the shared shell, page templates, content fields and interaction boundaries. Give each a named owner.

  2. Build one static page from real content

    Confirm the visual hierarchy, semantics and responsive structure before adding form logic.

  3. Implement explicit form states

    Connect the browser to a server-side endpoint and provide usable validation, progress and failure messages.

  4. Choose rendering and routing deliberately

    Check direct URLs, page metadata, missing pages and staging indexing against the public-site requirements.

  5. Review the built output

    Run the agreed checks and inspect actual built pages with keyboard, text resizing and a narrow viewport.

FOLLOW ONE EXAMPLE

Worked scenario

A new service should not require a new layout

In this fictional example, an owner needs a fourth service page and a stakeholder wants to change enquiry wording across the site.

  1. The owner adds an approved content record with its title, summary and destination rather than copying another page component.
  2. The template renders the new service in a preview and a validation step flags a missing required summary.
  3. The shared enquiry component receives the revised label once, and its success and error states are reviewed.
  4. The build verifies the new direct URL and navigation before the change enters staging.

What this shows: The separation reduces accidental inconsistency while preserving review of facts, accessibility and behaviour.

The process at a glance

Content and design feed reusable page templates. Enquiry input crosses a server boundary before email is requested, keeping credentials out of the browser.
ProcessDecisionHuman checkpoint
Read Mermaid diagram source
flowchart TD
 C[Reviewed content records] --> T[Typed page templates]
 D[Design tokens] --> T
 T --> H[Rendered HTML and assets]
 U[Visitor input] --> F[Form state and browser checks]
 F --> A[Server validation and limits]
 A --> E[Email adapter]
 A --> S[Accurate visitor status]
 H --> R[Staging journey review]

What you should have at the end

  • A reusable component/content boundary and a deliberate rendering choice.
  • A tested enquiry interaction whose visible status matches the actual system state.

Common mistakes and how to avoid them

Copying pages to add content

Prefer a reviewed template and validated content records where the layout is shared.

Putting a provider secret in a frontend variable

Assume browser-delivered values are public and move secret-bearing operations behind a server boundary.

Testing only the development server

Review the production build and direct URLs; hosting and routing can behave differently after deployment.

APPLY THE IDEA

Try it yourself

Your task: Take one page and list its content fields, reusable components and all enquiry-form states.

What to produce: A component map, a sample content record and a narrow-screen journey checklist.

Check your understanding: Can an editor add an approved service without modifying the shared layout or receiving an email-provider credential?

Key terms in plain English

Component
A reusable piece of interface with defined inputs and behaviour.
Prerendering
Producing page HTML ahead of requests, usually during a build.
Frontend state
Information that determines what the interface displays during an interaction.

Sources and further reading