START HERE
What you will learn
- Map the whole website journey before selecting tools.
- Give stakeholders a concrete decision and deliverable at every stage.
- Separate creating a website from making it maintainable.
Before you start: A business question, an accountable website owner and someone who can make or supervise technical changes. You do not need to use the example providers.
Reference edition: Fictional website walkthrough; providers are examples, not required services. Sources checked 2026-11-13.
Start with the visitor’s task
A website is useful when a visitor can understand what is offered, decide whether it fits and take a clear next action. Start there rather than with a hosting account or a page-generation prompt. Write one primary visitor question and one measurable action, such as completing a relevant enquiry.
This series uses a fictional business with service pages, practical articles and an enquiry form. It is a teaching example, not a client case study or a description of a live implementation. The same decisions apply to a solo operator, a stakeholder-led project or a larger business; the roles and approval depth can differ.
Agree the work before opening the tools
Create a short brief covering audience, purpose, evidence, content owner, brand rules, pages, enquiries and launch criteria. List what the first release excludes. A useful boundary might be “information and enquiries, without accounts, online payments or a customer database.”
Choose who can approve claims, design, technical changes and production release. These may be the same person in a small business, but name the decisions separately. Record the account owner and recovery route for the domain, repository, hosting, email and content editor. Ownership must survive a change of supplier or employee.
Follow seven stages with visible handoffs
First, agree the brief and acceptance checks. Second, turn the brand into a repeatable visual and writing system. Third, build the page and interaction structure. Fourth, prepare the hosting and domain boundary. Fifth, create the checked staging-to-production release path. Sixth, connect and test enquiry delivery. Finally, make future edits possible through a durable, permissioned workflow.
Each handoff needs an artifact: an approved brief, design rules, a preview, an environment record, a release report, an email test record and an update runbook. “We discussed it in a chat” is not a durable handoff. Keep current decisions with the project so another authorised person can pick up the work.
Choose tools by responsibility
A content editor or repository holds approved material. A frontend renders it. A host serves the site. A pipeline checks and publishes releases. An email service sends transactional messages. A dashboard or assistant can help people request changes. These roles remain even when products change.
The later guides use React, a Lightsail-style virtual server, GitHub Actions and Amazon SES as concrete examples. They are not a required bundle. A managed static host may remove server maintenance; another frontend, CI platform or email provider can satisfy the same contracts. Record why an option fits, what it costs to operate and how you would leave it.
Define launch as a checked journey
A successful build is not a launch check. Review the visitor journey on a narrow screen, follow direct page URLs, submit an enquiry, inspect failure messages, check email handling and confirm the public release identifier. Check redirects, metadata, accessibility, privacy choices and recovery as part of the agreed scope.
Use staging to discover mistakes before they reach customers. Staging should avoid live customer data and real outbound mail unless explicitly authorised, and should have access controls where previews are private. Keep a known working release and a tested rollback procedure. After launch, someone still owns patches, content accuracy, delivery failures and access reviews.
What each stage hands to the next
| Stage | Stakeholder decision | Concrete handoff |
|---|---|---|
| Purpose | Who is this for and what should they do? | Approved brief and acceptance checks |
| Brand and design | What should feel consistent and credible? | Design rules and reviewed page pattern |
| Frontend | Can the visitor complete the task? | Working pages and interaction evidence |
| Hosting | Who owns access and recovery? | Environment record and recovery check |
| Release | Which revision may reach customers? | Checked artifact and release approval |
| Where does an enquiry go and how do failures surface? | Delivery flow and test evidence | |
| Ongoing updates | Who may propose, review and publish? | Persistent change workflow and runbook |
Step-by-step process
Write a one-page outcome brief
Name the audience, the question they arrive with, the action they should take and the evidence that will help them decide. Agree what is outside the first release.
Create a project decision record
List owners, accounts, current design rules and where content and code live. Keep secrets in an appropriate secret store, not in the brief.
Build one complete journey
Take one service page through a preview and an enquiry. Resolve the full path before multiplying page templates.
Establish staging and release checks
Require an identifiable revision, functional checks, stakeholder review and a recovery route before the first public release.
Hand over the next change
Ask a second authorised person to propose a small edit, inspect staging and identify the production release using the runbook. Fix the workflow if they need an undocumented personal setup.
FOLLOW ONE EXAMPLE
Worked scenario
A small business launches an enquiry-led site
In this fictional example, a business owner wants three service pages and a practical guide. A stakeholder approves wording and an implementer prepares the technical path.
- They choose one audience and a single enquiry action, excluding bookings and payment from the first version.
- The owner approves a service-page pattern using real draft copy. The implementer builds and tests that pattern rather than generating ten unrelated layouts.
- They publish a staging preview, verify the form and email path with synthetic details, and approve the exact release.
- A later wording change goes through the same saved brief, preview and release record, without relying on the original implementer’s laptop.
What this shows: The result is a repeatable delivery process as well as a website. The example describes decisions and checks, not a claimed performance result.
The process at a glance
Read Mermaid diagram source
flowchart TD B[Purpose and acceptance brief] --> D[Brand and design rules] D --> F[Frontend and content] F --> H[Hosting and domain] H --> S[Staging release] S --> E[Journey and email checks] E --> R[Stakeholder review] R --> P[Approved production release] P --> U[New change request] U --> B
What you should have at the end
- A seven-stage map with owners, deliverables and approval points.
- A first-release scope that includes the enquiry and maintenance journey.
Common mistakes and how to avoid them
Starting with the server
Agree the visitor task and ownership first. Infrastructure choices should serve the requirements.
Treating launch as the final handoff
Prove how someone will make the next edit, receive a failed-enquiry alert and restore a working release.
APPLY THE IDEA
Try it yourself
Your task: Map one website you own from a visitor’s question to an enquiry and then to the next content update.
What to produce: A one-page brief, seven handoffs and an owner for each approval.
Check your understanding: Can a second person find the current approved scope and explain what must happen before a change goes live?
Key terms in plain English
- Acceptance check
- A specific observation that shows whether the intended behaviour works.
- Staging
- A separate preview environment for checking a candidate release.
- Handoff artifact
- A saved output that another person or system can inspect and use.