How a Professional Web Designer Plans a Site Step by Step
Planning a website is a business exercise first and a visual exercise second. Looks count, but they follow purpose and measurement. Good planning reduces risk, controls costs, and lays foundations for search visibility, speed, and conversion. It also keeps the project honest about what matters and what does not.

At a high level, the journey is straightforward. Set goals. Understand users and their tasks. Map the structure. Plan the content. Bake in SEO from day one. Make the right technical choices, including hosting and integrations. Prioritise performance and accessibility. Define a build workflow with version control, staging, and repeatable deployments. Run QA on real devices and in real scenarios. Launch in a controlled way. Maintain, monitor, and iterate. The specifics will vary by business, and that is fine – the aim is clear, testable decisions over trends.
A website project starts with the business case, not the colour palette. The aim is a site that supports real goals and can be measured. Good planning lowers risk, keeps costs under control, and sets up search visibility, speed, and conversion from the start.
Here is the path I use on client builds: set goals, understand users and their tasks, map the structure, plan the content, design the SEO foundations early, choose hosting and integrations with care, prioritise performance and accessibility, define a build workflow with version control, staging, and repeatable deployments, run QA on real devices in real scenarios, launch in a controlled way, then maintain, monitor, and iterate. The specifics will differ by business and sector – that is expected. What matters is making clear, testable decisions rather than chasing trends.
1. Clarify goals, constraints, and success
Turn business objectives into measurable outcomes before any design happens. If this step is fuzzy, everything after it drifts.
Audiences: small business owners, service companies, professionals, and founders in the UK and abroad. Value proposition: fast, well structured, SEO ready WordPress sites that generate qualified enquiries and are straightforward to maintain.
Primary goals and KPIs
- Generate qualified enquiries and bookings – KPIs: tracked form submissions, call tracking, CRM-qualified leads, conversion rate.
- Grow non-brand organic traffic to key service pages – KPIs: clicks and impressions for priority terms, average position, click-through rate, index coverage.
- Improve lead quality and sales efficiency – KPIs: lead source quality in CRM, proposal win rate, time to first response.
- Speed and reliability – KPIs: Core Web Vitals pass rate, LCP and INP targets, uptime, TTFB on UK users.
- Content discoverability – KPIs: internal search success rate, page depth, engagement rate on cornerstone content.
- Compliance and trust – KPIs: accessibility checks passed, privacy and cookie controls implemented, security scans clean.
Targets should be realistic and tied to baseline data. If there is no baseline, we set one in the first weeks after launch and adjust.
Non-goals and early trade-offs
- Non-goal: chasing a trend or an award. The site exists to serve users and the business.
- Non-goal: using design to fix a weak offer or pricing. That is a separate problem.
- Non-goal: replicating every legacy page. Dead weight hurts crawl budget and clarity.
- Non-goal: heavy animation. It usually slows pages and adds little.
- Trade-off: speed to launch vs scope. If time is tight, ship the core and schedule the rest.
- Trade-off: visual novelty vs accessibility and readability. Clarity wins.
- Trade-off: extreme CMS flexibility vs performance and governance. Guardrails prevent mess later.
- Trade-off: bespoke build vs proven plugins. Custom only where it creates real value.
Must-haves vs nice-to-haves
Sort features into two buckets. Be strict. It lowers risk and keeps the team honest.
- Must-haves: clear service pages and contact paths, fast templates, on-page SEO basics, schema for services and FAQs, accessible patterns, analytics and consent implemented correctly, CRM or email integration, redirects and canonical strategy, backups and security monitoring, editorial guide and reusable blocks.
- Nice-to-haves: advanced animations, interactive tools and calculators, personalisation, complex landing page builder, multilingual, blog migration of low value archives, deep third-party integrations.
Constraints to acknowledge
- Budget – defines scope and level of custom work. We choose where it has the most impact.
- Time – hard deadlines mean phased releases and a trimmed backlog.
- Content – who writes, edits, and approves. If internal bandwidth is limited, plan fewer pages with higher quality.
- Internal resources – availability of a subject matter expert, a legal reviewer, and someone to own the CMS after launch.
- Data access – analytics, CRM, and search console must be available for measurement.
- Stakeholder input – decision makers and their response times. Fewer voices, faster progress.
A quick note: preferences are fine, but they sit behind objectives. If a choice hurts speed, clarity, or conversion, we drop it. Write these decisions on a single page, circulate it, and refer back during design and build.
2. Understand users and conversion paths
Before visuals, we map who the site serves, what they need to do, and how they become a lead. This keeps design honest and prevents noise.
User segments and jobs to be done
- Owner-operator or founder – needs a fast, credible site that brings enquiries. Job: confirm fit, see typical budgets and timeline, book a call.
- Marketing manager – cares about structure, SEO, governance, and reporting. Job: check capabilities, process, and how content will be handled. Request a proposal with scope.
- Operations or office manager tasked with the website – wants clarity and low maintenance. Job: see WordPress editing approach, reusable blocks, training and support. Ask about handover.
- Technical founder or agency partner – needs performance, clean build, and sane plugin policy. Job: review stack, Core Web Vitals approach, deployment workflow. Share a brief or spec.
- International client with UK presence – wants timezone coverage and compliance. Job: validate experience, data handling, accessibility, and ongoing support arrangements.
We design for jobs to be done, not demographics. Role and intent guide the content and the calls to action.
Primary and secondary journeys mapped to conversions
- Primary – Non-brand organic to a service page – skims value, scans deliverables and budgets, checks work, then books a discovery call. Conversion: schedule a call or submit a scoped enquiry.
- Primary – Referral or brand search to homepage – jumps to Services or Work, then Contact. Conversion: request a proposal with a short brief upload.
- Secondary – Content or guide visit – reads, clicks internal links to the relevant service, then CTA. Conversion: download a briefing template or start a quote request.
- Secondary – Paid or directory landing – focused page with proof and next step. Conversion: book a call or complete a short form. No detours.
Each journey ends on a simple decision screen. One main action, a supportive alternative, and no distractions.
Top tasks to prioritise in navigation and layout
- Find services fast – clear Services in the primary nav with direct links to key offers.
- See typical budgets and timelines – use ranges or qualifying signals. If pricing is contextual, say how it is scoped.
- Validate capability – case studies with problem, approach, outcomes, and the stack used.
- Understand process – short, scannable steps from discovery to launch and aftercare.
- Check performance and SEO approach – how we hit Core Web Vitals and handle structure, schema, and redirects.
- Know who they will work with – a lean About page with roles, not fluff.
- Contact quickly – Book a call, Request a proposal, and a phone option for urgent matters. Visible in header and page ends.
If a task helps users decide, we surface it. If it adds noise, we move it down or drop it.
Conversion events defined and trackable
- Book a call – calendar embed or link. Track clicks and confirmed bookings as events. Send to CRM with source and campaign.
- Enquiry form submission – short form with file upload for briefs. Track successful submits on a thank you URL and as an event.
- Call click and phone enquiries – click-to-call events and number-level call tracking. Attribute to channel in CRM.
- Proposal request started and completed – multi-step tracking to see drop-off.
- Resource downloads – briefing template, capability sheet, or checklist. Track download events and tie to lead records.
- Micro-conversions – pricing link clicks, case study expand, email reveal, chat open. Useful for diagnosing intent.
We implement GA4 events with clear names, consent-aware tags, and CRM integration. Clean thank you pages help with validation and reporting.
Offline context that affects the journey
- Referrals and shortlists – people arrive warm. Give a direct path to book and a concise PDF one-pager when procurement asks.
- Internal approval – budget holder, legal, and IT will skim. Provide clarity on deliverables, support, data handling, and accessibility.
- Timing pressures – launches linked to campaigns. Show realistic lead times and phased options.
- Post-call follow up – proposals and SOWs often circulate offline. Make the site reinforce them with matching language and a private link hub if needed.
- Phone-first users – some prefer to talk. Keep the number visible and use simple IVR or a human line during UK hours.
What we avoid
- Designing for demographics alone – role, intent, and tasks drive decisions.
- Copying competitors without context – their model, margins, and audience may differ.
- Hiding contact or pricing signals – it slows decisions and hurts trust.
- Vague calls to action – every key page gets one clear primary action and a sensible secondary.
Clarity wins. When in doubt, make the next step obvious and measurable.
3. Information architecture and navigation
Keep the structure simple, scalable, and easy to crawl. Humans should find the next step in one or two clicks. Search engines should see one clear home for each topic.
Draft sitemap with parent-child logic
Two levels max for core pages. Deeper content lives via filters, tags, or internal links, not nested menus.
- Home
- Services
- Web design
- WordPress development
- Performance and Core Web Vitals
- Technical SEO setup
- Care plans and support
- Work
- Case studies (listing)
- Case study detail (template)
- Process
- Pricing and timelines
- Approach to SEO and performance
- About
- Who you work with
- Tools and stack
- Resources
- Guides
- Briefing template
- Checklist
- Blog
- Categories (kept lean)
- Post detail (template)
- Contact
- Legal
- Privacy
- Terms
- Accessibility
Notes:
- Do not nest beyond two levels. If a new section needs more, reconsider the grouping.
- Each service gets its own page. No multi-topic walls that try to do everything.
- Blog uses post-name URLs. Categories guide discovery but do not control permalinks.
- One primary category per post for cleaner breadcrumbs.
Navigation patterns – desktop and mobile
Navigation mirrors top tasks. Labels are plain English. No cleverness.
- Desktop primary: Services, Work, Process, Pricing, SEO and performance, About, Resources, Blog, Contact.
- Primary CTA in header: Book a call. Secondary: Request a proposal.
- Services menu: simple panel listing key services with one-line descriptors. No mega menu unless content genuinely warrants it.
- Utility items (Privacy, Terms) live in the footer only.
- Search limited to Blog and Resources to avoid noise in core pages.
- Mobile: hamburger menu with drill-down. Services expands as an accordion.
- Sticky header with logo, menu, and a compact Book a call button.
- Optional sticky footer bar on mobile: Call and Book. It helps phone-first users.
- Tap targets at least 44px high. Focus states visible. Skip-to-content link for keyboard users.
Breadcrumbs plan
- Shown on all indexable pages except Home and Contact.
- Pattern: Home > Section > Page. For posts: Home > Blog > Category > Post.
- Services with children: Home > Services > Service.
- Case studies: Home > Work > Case study title.
- Last item is not a link. Keep labels short and aligned with page H1.
- Output server-side with BreadcrumbList schema. No client-only rendering.
Internal linking rules for priority pages
- Every blog post links to exactly one primary service using natural anchor text near the top third of the content.
- Service pages cross-link to related services and at least two relevant case studies.
- Case studies link back to the parent service and the contact path. Avoid dead ends.
- Resources and guides link to services where the intent matches. Do not force links where it does not.
- Header and footer include only high-intent links. No dumping grounds.
- When a new page launches, add 3 to 5 internal links from existing strong pages. Update sitemaps the same day.
- Avoid exact-match anchors in every instance. Vary phrasing, keep it readable.
If a page does not receive any internal links, it probably should not be published. Or it belongs as a file download rather than a page.
Canonical and pagination strategy
- One canonical URL per piece of content. Always HTTPS. Single host (choose non-www or www and 301 the other).
- Trailing slash convention set sitewide. WordPress default trailing slash is fine. Enforce with 301s.
- Self-referencing canonical on all indexable pages and posts.
- Avoid multiple URLs for the same page: no mixed case, no duplicate slugs, no session IDs. UTM parameters are ignored for canonicals.
- Blog and archive pagination uses /page/2/ etc. Each page canonicalises to itself. Provide next and prev links in the HTML and clear pagination UI.
- Filtered or sorted listings that do not add unique value get meta robots noindex, follow, and canonical to the unfiltered base.
- Tag pages only if they serve a real discovery purpose. If thin, set noindex or do not generate them.
- Use a primary category for posts. Keep categories stable to avoid URL churn. Prefer post-name permalinks.
- If content must exist in two places, pick one as canonical and link the other clearly as an alternate path. Better still, consolidate.
Simple rule: fewer, stronger URLs beat many weak ones. If in doubt, fold content up and point to the best page.
4. Content model and page types
Design the content before visuals. It prevents messy builds, rework, and bloated pages. We plan page types, fields, and patterns first, then layer the design on top.
Page templates and key components
Lean set, clear purpose, consistent structure.
- Home template
- Hero with value line and primary CTA
- Services overview grid (pulls child Services pages)
- Selected case studies
- Latest article from Blog or Resources
- Trust strip (logos or short quotes)
- Service template (for Services and sub-services as Pages)
- Hero with plain-English summary
- Who it is for and outcomes
- Deliverables and process steps
- Pricing notes or ranges if appropriate
- FAQs (Details blocks)
- Related case studies and next steps CTA
- Sidebar local nav for service siblings
- Work index (Case studies archive)
- Filter by Industry and Service
- Case study cards with summary
- Case study single
- Project snapshot (client, sector, goals)
- Approach and solution
- Outcomes and evidence
- Link back to the parent service and Contact
- Blog index and Post single
- Clear categories and author info
- Primary service link near the top third
- Related reading
- Resources index and Resource single (guides, checklists)
- Topic filters
- Lead-in summary
- Download block if relevant
- About
- Positioning, team highlights, approach
- Process
- End-to-end steps with realistic timelines
- Pricing
- Pricing models and what affects cost
- SEO and performance page
- Methods, tooling, and what clients can expect
- Contact
- Short form, direct email, phone, booking link
- Legal pages
- Privacy, Terms
- Search results, 404, and a simple Campaign landing template (no header nav option)
Custom post types and taxonomies
Services stay as Pages to keep URLs clean and breadcrumbs simple. We add CPTs only where it helps authors and listings.
- Case studies (CPT)
- Why: different workflow, archive needed, custom fields for snapshots
- Taxonomies: Industry (custom, non-hierarchical), Service focus (custom, mirrors Services to aid filtering)
- Resources (CPT) – only if content is distinct from Blog and needs its own archive
- Why: long-form guides, tools, downloads
- Taxonomy: Topic (shared with Blog via a custom taxonomy to unify discovery)
- Blog uses Posts with a primary Category (already planned). Keep tags minimal or off unless they aid discovery.
Testimonials as a CPT only if there are many and you need rotation and filtering. Otherwise use a reusable testimonials block in context. Simpler is better.
Reusable blocks and patterns
- Hero – compact page header with breadcrumb slot, H1, 1-2 line summary, primary and secondary CTAs
- Process steps – numbered list with short labels and one-line explains
- Deliverables grid – 2 to 4 column list with concise items
- Outcome bullets – client-facing benefits, plain English
- CTA strip – short pitch, button to Book a call
- Trust strip – client logos or one-line quotes
- FAQ block – Details blocks, one question per item
- Case study card – image, title, sector, short result line
- Related content – pulls by taxonomy or service reference
- Contact prompt – short text, two buttons: Book a call, Request a proposal
Lock patterns where layout must not drift. Leave text and links editable. If a block makes authors nervous, it will gather dust.
Structured fields for key content
- Service pages (Pages)
- Hero summary – 1 to 2 sentences
- Primary CTA label and URL
- Audience – short list
- Outcomes – short list
- Deliverables – list
- Process steps – ordered list with short descriptions
- Related service links – 2 to 4 internal links
- Case studies (CPT)
- Client name
- Sector (Industry taxonomy)
- Primary service reference (link to the Service page)
- Goals – short list
- Approach – short paragraph
- Outcomes – qualitative summary; if metrics exist, list them, but avoid placeholders
- Feature image with alt text
- Excerpt – used on cards
- Resources (CPT) or Posts
- Reading level or audience note (optional)
- Primary service link (internal)
- Download URL if applicable
- Topic taxonomy term
- Global
- Social share image (per post/page)
- Breadcrumb title override when needed to keep labels short
Implement with block templates and minimal meta fields. Use pattern placeholders to collect these items in a predictable order so archives and related blocks can rely on them.
Content governance and ownership
- Services – owned by the principal consultant. Reviewed quarterly for clarity and scope. Changes trigger updates to related case studies and CTAs.
- Case studies – owned by the project lead. Must link to a parent service and the contact path. Reviewed after each project and annually for relevance.
- Blog – owned by the SEO lead. Every post links to one primary service. Edit cycle includes fact check, internal links, and accessibility checks.
- Resources – owned by the content lead. Update schedule set per item. If no updates for 18 months and traffic is low, consolidate or remove.
- About, Process, Pricing – owned by the founder. Reviewed twice a year or after material changes.
- Legal – owned by operations. Update on legal advice only.
- Publish workflow – draft in staging, peer review, performance and accessibility checks, then live. Add 3 to 5 internal links from existing strong pages on the same day.
- Retirement rules – if a page cannot earn internal links or serve a journey, fold it into a stronger page and redirect.
Avoid unstructured freeform pages and content locked inside decorative blocks. Keep the editor simple. A small set of clear patterns beats a drawer of one-offs.
5. SEO research and entity mapping
We plan for search before design. Topics first. Clear mapping. Clean on-page structure. It feels slower at the start. It saves months later.
Topics and intent clusters, not just keywords
Search intent is the reason behind a query. Someone wants to hire, compare, learn, or find a brand page. We group queries by that intent and plan clusters around them.
- Talk to the business. What do buyers ask before they sign. What do they ask after.
- Check sales emails, proposals, and support tickets for real phrases.
- Review search results. See what Google shows for a theme. Service pages, guides, FAQs, or comparisons.
- Build clusters. One core page per intent, with supporting content around it.
- Pick topics that fit the service. Do not chase volume that will never convert.
For a web design service in London, core clusters often include hiring a designer, WordPress performance, process and timelines, pricing factors, and proof. Each gets one strong page, then supporting posts where needed.
Entity relationships and supporting content
An entity is a clearly defined thing or concept. Think people, places, services, platforms, and outcomes. Search engines map how these connect. We make those connections obvious.
- Services – web design, WordPress development, site speed optimisation, technical SEO.
- Locations – London, UK, remote. Be honest about where you actually serve.
- Platforms – WordPress, WooCommerce, hosting, analytics.
- Audiences – small businesses, professional services, founders.
- Problems and outcomes – slow sites, poor conversions, content structure, Core Web Vitals.
- Proof – case studies, testimonials, process detail.
We reflect these entities in headings, internal links, and supporting articles. Short explainers, FAQs, comparisons, and checklists work well. Keep names consistent across the site.
Keyword-to-page mapping by template
One main topic per URL. No duplicates. We map each target phrase to a page type so the site stays tidy.
- Service pages – target the primary hiring intent for that service. Use variants naturally in subheadings. Link to related case studies and resources.
- Case studies – focus on client, sector, and service combination. Capture long-tail terms like industry plus solution. Always link back to the parent service and to contact.
- Process, About, Pricing – answer common evaluation questions. Map to queries about how you work and what affects cost. No price bait.
- Blog and Resources – answer specific questions that support the service. Each piece links to one primary service. If two posts overlap, merge and redirect.
- Location – if location matters, build one strong page that proves relevance. Avoid thin city pages with swapped names.
I keep a simple sheet for this. Nothing fancy. Just URL, primary topic, intent, template, internal links in and out, and status.
Title, meta, headings, and internal link rules
Meta title and meta description are the bits shown in search results. They should match the page and give a reason to click.
- One H1 per page. It should reflect the main intent clearly.
- Meta title – lead with the primary topic. Add the brand at the end. Keep it short and readable.
- Meta description – plain English summary with a next step. No fluff. No keyword lists.
- Headings – use H2 and H3 to cover subtopics and related entities. Make the structure scannable.
- Copy – write for people first. Include important terms where they belong. If it feels stuffed, it is.
- Internal links – use descriptive anchor text. Link up to services, down to case studies, and sideways to related guides. Avoid orphan pages.
- URLs – short, stable, and human. Use words, not codes.
- Do not split the same topic across multiple URLs. Consolidate and redirect weaker pages.
Schema markup plan for key types
Schema markup is extra code that labels the type of page. It helps search engines understand context and sometimes unlocks rich results like FAQs. We add it where it makes sense.
- Site wide – Organization, Website, and BreadcrumbList.
- Home and Contact – ProfessionalService or LocalBusiness if you meet clients in London. Include correct name, address, and contact details.
- Service pages – Service, with the provider set to your Organization.
- Case studies – CaseStudy, linked to the relevant Service.
- Blog posts and resources – Article or BlogPosting.
- FAQs on a page – FAQPage. Only for real, visible questions and answers.
- How to guides – HowTo, when the content is a genuine step-by-step.
- Reviews – Review and AggregateRating only if you have real, verifiable ratings on that page.
We validate markup during staging. If a type does not fit, we skip it. Bad markup hurts trust.
What we avoid
- Keyword stuffing. It reads badly and can backfire.
- Thin city pages. One useful location page beats twenty weak ones.
- Chasing search volume over intent and fit. Traffic without relevance wastes time.
- Ignoring search features like FAQs or how-tos when they match the page.
- Duplicating the same topic across multiple URLs.
Simple workflow
- List services, audiences, locations, platforms, and outcomes – your core entities.
- Build topic clusters around buyer intent.
- Map one primary topic to each URL by template.
- Draft titles, meta, headings, and internal link targets.
- Plan schema types per template. Add only what the page truly supports.
- Review for overlap. Merge or redirect duplicates.
- Publish, measure, and refine quarterly. Update winners, cut dead weight.
This makes search part of the site plan, not an afterthought. It is calmer to run and easier to grow.
6. Performance budget and media plan We set speed targets before design starts. That keeps choices grounded and avoids surprises late on. Core Web Vitals targets and how we test Core Web Vitals are Google’s way of measuring how fast and stable a page feels. In plain terms – how quickly the main content appears, how steady the layout is, and how fast the page reacts when you tap or click. Largest Contentful Paint (main content visible) – target under 2.5 seconds for real users. We aim faster where possible. Interaction to Next Paint (response to a tap or click) – target under 200 ms. Cumulative Layout Shift (visual jumps) – target under 0.1. How we test it: During build – Lighthouse and WebPageTest on staging. We test key templates, not just the homepage. We emulate a mid-range phone on a normal 4G connection. It is closer to real life than a fast Mac on fibre. After launch – Google Search Console and the Chrome User Experience Report to see real user data. Quarterly checks – fix regressions before they stack up. Images – formats, sizes, and responsive rules Use modern formats first – WebP and AVIF where supported. Keep JPEG or PNG as a safe fallback when needed. Right-size every asset. We export to the largest size it will actually display, then let WordPress generate smaller versions for different screens. Responsive by default. We output srcset so browsers pick the best size automatically. No single giant image for all devices. Lazy load all below-the-fold images. Do not lazy load the main hero image. We mark it as high priority so it appears fast. Keep transparent graphics as SVG when possible. They are crisp at any size and usually lighter. Video – hosting and delivery Host marketing videos on a specialist platform like YouTube or Vimeo. We use privacy-enhanced, lightweight embeds so the page does not load their full player until needed. Self-host only short, muted loops and only when they add real value. We provide a poster image so the first frame is instant. No autoplay with sound. It annoys users and burns bandwidth. Controls visible, captions available. Defer loading videos below the fold. They should not block the main content. Fonts – strategy and fallbacks Prefer system fonts when brand allows. They are fastest and look clean. If brand fonts are required – we host them locally, use modern WOFF2 files, and limit to the few weights actually used. Preload the primary text font only, then use font-display: swap so text is readable immediately with a safe fallback. Define a clear fallback stack. If the custom font fails, the page still looks good. Avoid icon fonts. Use inline SVG icons – they are lighter and sharper. Third-party scripts – policy and review Every external script has a cost. We keep a simple policy so they do not slow the site or create risk. Purpose and owner required. No script goes live without a named reason and a person responsible. Load by need. Only on the pages that require it. Marketing tags behind consent where applicable. Defer or async so they do not block the main page from loading. Nothing in the critical path unless essential for content. Quarterly review. Remove unused pixels, A/B tools after tests end, and old chat widgets. One controller. A tag manager is fine if kept tidy. We test impact before and after adding any script. What we avoid by default Heavy page builders and unused libraries. We build with a lean WordPress stack so the site stays fast. Autoplay background videos with sound. Blocking scripts in the critical path. Icon fonts when SVGs will do. Set the budget, stick to it, and the design follows. It keeps pages quick, clean, and easier to maintain long term.
7. Technical choices for WordPress We choose a lean, maintainable stack that suits the project and the team. It keeps the site fast, secure, and easy to run without surprises. Theme approach – set early We decide the theme approach before design starts. That avoids rework later. A block theme uses the WordPress site editor and blocks for most of the layout. It is flexible and future facing if your team is happy editing with blocks. A hybrid theme mixes classic templates with blocks where it makes sense. It suits complex sites, legacy needs, or stricter layouts that should not be edited by mistake. We recommend a block theme when day to day updates will be done in house and you want visual control. We choose hybrid when stability and guardrails matter more. There is a clear path to add more blocks over time, not all at once. Plugins – few, supported, purposeful Plugins add features. Each one also adds risk and weight. We keep the list short. One plugin per job. No overlaps. For example, one SEO plugin, one forms plugin. Pick active, well supported plugins with a track record of updates. Favour native WordPress features before adding a plugin. Remove what is not used. Fewer moving parts means fewer issues. When we need something custom, we build it as a small, documented plugin and keep it in version control. Version control is a safe history of code changes so we can track edits and roll back if needed. Editor experience – patterns and permissions Your team should be able to update content without breaking layouts. We shape the editor around that goal. Block patterns for repeatable sections. Think ready made service blocks, FAQs, pricing rows. Lock the parts that should not move. Keep freedom where it helps. Roles and permissions set by task. Editors edit. Admins administer. No shared admin accounts. Clear names for media, patterns, and templates so people find the right thing fast. Short guides inside the dashboard. A few notes save a lot of support later. Hosting, CDN, and caching Good hosting is the foundation. A Content Delivery Network, or CDN, serves images and files from servers closer to your visitors. Caching stores ready made pages so they load quickly. Managed WordPress hosting with solid performance, staging, SSL, and backups. Use a CDN for static assets and large media. Faster worldwide and lighter on the server. Server level page caching first. Add a caching plugin only when needed. Do not stack multiple caches. Object caching where the host supports it. It helps logged in areas and searches. Set clear purge rules so updates appear quickly without wiping all caches. Monitoring and alerts. Fix small hiccups before they become outages. If you already have a host, we assess it honestly. Weak hosting costs more in lost time than the price difference suggests. Versions and updates We run on a currently supported PHP version and the current stable WordPress release. Old software is a security and speed risk. Minor security updates auto apply. Major updates are tested on staging, then scheduled for live. Plugins and themes reviewed and updated on a regular cycle. Backups and a simple rollback plan before any change. Documented change log so everyone knows what changed and why. What we avoid Plugin bloat and overlapping features. Custom code without version control. Shared admin accounts. Each person gets their own login with suitable access. Outdated PHP or weak hosting. Set these choices early and keep them tidy. The site stays quick, secure, and calm to run.
8. Accessibility and inclusive design
Bake it in from day one. Fixing access at the end costs more and leaves gaps. It is about real people using your site without friction.
We follow WCAG – the Web Content Accessibility Guidelines. Our baseline is Level AA. That standard keeps things usable for most people, most of the time.
How we approach it
Design, content, and build all carry their part. We plan for accessibility in wireframes, set rules for content, and code with care. No bolt-ons later.
- Clear structure – headings in order, logical reading flow, and consistent layouts.
- Readable content – plain language, meaningful link text, and no tiny text.
- Strong contrast – colours that remain readable on any screen, in any light.
- Visible focus – a clear outline when you tab through links and buttons.
- Keyboard first – everything works without a mouse, with skip links to jump ahead.
- Honest forms – proper labels, helpful hints, and errors that say what to fix.
- Responsible media – useful alt text on images, and captions or transcripts for video and audio.
Colour contrast and focus states
We choose colours that meet WCAG contrast for text and interface elements. We test light and dark backgrounds. We avoid colour-only cues. Add an icon or text as well so meaning is not lost.
Focus states matter. When you tab, you should see where you are. We keep outlines visible and distinct. We do not remove them for style. If the design is busy, we increase the outline size or add a clear highlight.
Keyboard navigation and skip links
Every interactive part works with a keyboard. Tab order follows the page, not the code’s whims. No popups or menus that trap focus. You can open them, move through them, and close them without a mouse.
We add skip links. A small link appears when you press Tab. It jumps straight to the main content. It saves time for keyboard and screen reader users.
Accessible forms, labels, and error handling
Every field has a clear label tied to the input. Placeholder text is not the label. Required fields are marked with text, not just colour.
Errors show near the field and in a short summary at the top on submit. The message says what went wrong and how to fix it. We keep the user’s input so they do not have to start again.
Buttons read like actions – Submit, Send enquiry, Pay now. Help text sits with the field it explains.
Alt text and media transcripts or captions
Images that add meaning get concise alt text that describes the purpose. Decorative images are flagged as decorative so they are skipped. Charts and complex images link to a short explanation.
Videos have captions. Audio and video have transcripts when content matters for understanding or SEO. If a third party video lacks captions, we add our own or provide a summary beneath.
WCAG-focused checklist and acceptance criteria
- Structure – Pages have one H1, headings in order, and landmarks for header, main, and footer. Acceptance – Screen reader outline is logical and matches the visual layout.
- Contrast – Text and interactive elements meet WCAG Level AA contrast. Acceptance – Tested and passes on light and dark backgrounds.
- Focus – All interactive elements show a visible focus state. Acceptance – No outlines removed. Focus is clearly visible on brand colours and images.
- Keyboard – Full site is usable with keyboard only. Acceptance – No focus traps. Menus, dialogs, sliders, and tabs open, move, and close via keyboard.
- Skip links – Present on all pages. Acceptance – First Tab reveals a Skip to content link that works.
- Links and buttons – Text is descriptive. Acceptance – No repeated Click here. Button roles match behaviour.
- Forms – Labels, instructions, and errors are clear. Acceptance – Each error is announced in text next to the field and summarised at the top. Required fields are marked with text.
- Media – Alt text where meaningful, decorative images ignored, captions or transcripts provided. Acceptance – Each page with media meets that rule or explains why not applicable.
- Motion – Non-essential animation can be paused or is subtle. Acceptance – No auto playing audio. Respect the user’s reduced motion setting.
- Testing – Automated checks plus a short manual review. Acceptance – Pages pass baseline automated tests and a human keyboard and screen reader smoke test.
What we avoid
- Colour-only cues for meaning.
- Components that trap focus.
- Overlays or widgets that claim to fix accessibility. They do not fix the source issues.
- Removing focus outlines for aesthetic reasons.
Small note – getting this right helps everyone. Clearer content, better forms, fewer support emails. It is worth the effort.
9. Design system and components
A good site feels consistent because it is built from a clear system. Not one-off pages. That system speeds design, build, and content editing. It also reduces bugs. Editors know what to use. Developers know what to extend. Visitors see the same patterns in the same places and move faster.
Typography scale and spacing system
We set a type scale – a small set of text sizes with matching line height and letter spacing. Headings step up in clear grades. Body text stays comfortable to read on all screens. No random sizes added later.
We also use a spacing system – a short list of spacing steps for margins and padding. Think small, medium, large, not 23 different gaps. This keeps rhythm steady and pages tidy. It also makes changes easier. If spacing feels tight, we adjust one value and the whole site benefits.
- Headings use defined levels only – H1 to H6 with set sizes.
- Body copy has one default size, with a larger option when long reading is expected.
- Line length is kept readable. We avoid very wide paragraphs.
- Spacing uses the shared steps. No one-off pixel tweaks.
Grid and layout rules across breakpoints
Pages sit on a grid. The grid is the invisible set of columns that keeps content aligned. Breakpoints are the screen widths where the layout changes to fit the device. We write these rules once and apply them everywhere.
- Content width has a sensible maximum so lines stay readable on large screens.
- On mobiles we prefer a single column. On tablets and desktops we add columns when it helps understanding.
- Gutters – the space between columns – come from the spacing system.
- Images and embeds scale within the grid. No overflow or clipped content.
- Hero areas and banners have set height limits so they do not bury the message.
Result – layouts feel stable. Editors can predict how a block will flow at each size. There are fewer surprises on launch day.
Core components with documented states
Components are reusable parts like buttons, forms, cards, navigation, tables, and message banners. Each one is defined once, then reused. We document how each behaves in different states so it stays clear and accessible.
- Buttons – default, hover, active, focus, disabled, loading. Focus is always visible for keyboard users.
- Form fields – default, focus, filled, error, success. Errors include clear text and helpful hints.
- Cards – image, title, summary, link. Consistent spacing, image ratios, and hover behaviour.
- Navigation – desktop and mobile patterns with clear open and close behaviour. No focus traps.
- Tables – header style, zebra option, responsive rule for small screens.
- Messages – info, success, warning, error. Each with distinct colour and icon, plus text that explains what to do next.
If a new need appears, we extend the component library rather than styling a one-off. This keeps the code lean and the experience predictable.
Iconography rules and usage
Icons support meaning. They are not decoration. We pick one icon set and stick to it so stroke, size, and style match. Icons always sit with text unless the meaning is completely obvious, like a play button.
- Size and spacing follow the type and spacing systems. No freehand sizing.
- Colour meets contrast needs. Icons that signal state – like error – use the same colours as messages.
- Do not use icons on their own for key actions. Pair with a clear label.
- Inline SVG or a single icon font – chosen for performance and clarity. We avoid loading multiple packs.
Content patterns for common messages and CTAs
We define short content patterns for repeat situations. This saves time and keeps tone steady. It also avoids vague links and mixed calls to action.
- Calls to action – one primary action per screen. Clear verbs like Book a call, Get a quote, or Download guide. Secondary actions are subtle and do not compete.
- Links – descriptive text, not Click here. If it leaves the site or downloads a file, say so.
- Forms – concise headlines, one purpose per form, helpful microcopy near the field it explains.
- System messages – use the message component with a short heading and one line of guidance. Avoid blame in error messages.
- Empty states – explain what is missing and how to start. Add a sensible next step.
We save these as WordPress patterns so editors can insert them in a click. Consistency without extra effort.
What we avoid
- One-off styles that multiply CSS – the styling code – and slow pages down.
- Inconsistent buttons and links that confuse users and hurt conversions.
- Decorative animations that add weight and distract from the goal.
- Designing components that are not backed by real content needs.
How this speeds build and editing
The system sets the rules once. Designers work faster with fewer variations to test. Developers ship cleaner code. Editors drop in proven blocks and patterns, not fresh layouts every time. Changes are safer too – update a rule and the benefit rolls across the site.
It is a calm way to build. Less noise. More focus on the message and the task your visitor came to complete.
10. Analytics, events, and consent
Measure what matters and respect privacy. You do not need to track everything. You do need a clear plan, tidy naming, and consent handled properly.
Start with a measurement plan
Tie measurement to your goals and the real journeys people take on the site.
- Business goals – examples: qualified enquiries, booked calls, online sales, brochure downloads.
- Key journeys – how people reach those goals. Example: Home → Service → Case study → Contact form.
- Questions to answer – what channels bring good leads, which pages help or block progress.
- KPIs – simple numbers that show progress. Example: enquiry conversion rate, call bookings per week.
- Events to track for each step – only where they add insight. Do not collect data you cannot use.
Event and conversion definitions
Events are actions people take on the site. Conversions are the few actions that matter most to the business.
- Primary conversions – form submitted, call clicked (with a tel link), checkout completed, demo booked.
- Secondary conversions – brochure downloaded, newsletter signup, quote tool started.
- Support events – page_view is automatic. Add focused events like contact_form_submit, phone_click, file_download, quote_request_start, quote_request_finish, video_play, menu_open.
- Naming standard – lowercase, snake_case, action first. Keep it human. Example: form_submit_contact, file_download_brochure, button_click_book_call.
- Parameters – short extra details. Example: form_name: contact, file_name: pricing_guide.pdf, page_section: footer.
- Keep a log – a simple shared sheet with event name, when it fires, and why it exists. Unlabelled events confuse reports.
Set only a small set as conversions. Too many conversions makes reporting noisy.
Analytics platform setup
Pick a platform that fits your needs and privacy stance. Google Analytics 4 (GA4) is common and integrates widely. Privacy-focused tools like Matomo or Plausible are good alternatives if you prefer simpler reports or to self host.
- Create the account and property, then add the tracking tag to the site. A tag is a small script that records events.
- Set your reporting time zone and currency.
- Define your conversions in the platform to match your plan.
- Exclude internal traffic from your office and agency IPs. You want real visitor data.
- Limit data collection features you do not need. Keep it lean.
- Test events in a staging site, then verify in production. No guesswork.
UTM and campaign tagging standards
UTMs are short tags you add to a link so analytics can attribute visits to a campaign. They sit after a question mark in a URL. Example: ?utm_source=newsletter&utm_medium=email&utm_campaign=summer_launch
- Required fields – utm_source (where), utm_medium (type like email, cpc), utm_campaign (the specific push).
- Optional fields – utm_content (to tell versions apart), utm_term (paid keywords).
- Naming rules – lowercase, no spaces, use hyphens or underscores, be specific. Example: utm_source=linkedin, utm_medium=cpc, utm_campaign=consulting_launch_2026.
- One shared list – keep a simple sheet of approved values so the team stays consistent.
- Never tag internal links on your own site. UTMs are for external campaigns only.
Consent, cookies, and retention
Follow UK privacy rules. If a tracker is not essential for the site to work, ask before you set it. No tricks.
- Consent banner – clear choices, accept and reject are equal in weight. No pre-checked boxes. No dark patterns.
- Categories – Necessary, Analytics, Marketing. Load Analytics and Marketing only after consent.
- Policy pages – explain what you collect, why, and for how long. Keep it plain.
- Respect consent in tags – only fire analytics events once the user has opted in, where consent is required.
- Data retention – set the shortest period that still lets you see trends. Many businesses choose a period that covers seasonal cycles, then review yearly.
- Access control – limit who can see raw analytics. Fewer hands, fewer mistakes.
What we avoid
- Tracking without consent where consent is required.
- Collecting data we cannot use to make a decision.
- Dark patterns in consent banners.
- Unlabelled or vague events that bloat reports.
- Recording every scroll and click. It creates noise and slows pages.
The aim is simple. Trustworthy data that answers clear questions, gathered with respect for your visitors. If a report will never change a decision, we do not build it.
11. Legal and compliance basics
Sort the basics early. It keeps launch on track and avoids rework later. None of this is exciting, but it matters.
Core documents
You will need three clear, accurate documents. Link them in the footer and from your consent banner.
- Privacy policy – explains what you collect, why, the legal basis, how long you keep it, and who you share it with. Include contact details for privacy requests.
- Cookie policy – lists the cookies and similar tools you use, their purpose, provider, and how long they last. Explain how users can change their choices.
- Terms of use or terms of service – the rules for using the site. Keep it plain. Cover acceptable use, IP ownership, and limits of liability.
Use templates as a starting point if you like, but get a legal review. Copy-paste text that does not match your setup creates risk.
Cookies – map categories to scripts
Decide which tools sit in which category. Then configure your consent banner and tag manager to match. Only load non-essential tools after consent.
- Necessary – core functions only. Examples: security tools, payment gateway scripts during checkout, login sessions.
- Analytics – measurement tools. Example: Google Analytics 4 configured to load only after consent.
- Marketing – profiling, ads, retargeting, and most extras. Examples: Meta Pixel, LinkedIn Insight Tag, A/B testing tools, live chat that sets tracking cookies.
If you also use a Functional category, put live chat and video embeds there. If you use only Necessary, Analytics, and Marketing, place them under Marketing unless they are required for a core task.
Tip – keep a simple table in your cookie policy that lists tool name, purpose, category, provider, and expiry. Update it when you add or remove scripts.
Accessibility statement
Publish a short accessibility statement. Say what standard you aim for, any known issues, and how people can contact you if they need content in another format.
Then act on reports. Fixes are almost always cheaper before launch than after.
DPIA – when you need one
DPIA stands for Data Protection Impact Assessment. It is a short, structured review you complete when processing sensitive data or doing higher risk tracking. The aim is to spot risks early and reduce them.
- Do one if you handle special category data such as health details, children’s data, or large-scale profiling.
- Do one if your site connects forms to CRMs or ad platforms in a way that profiles users.
- Document decisions. If you decide not to run a DPIA, note why.
Keep the DPIA with your project docs. Review it when your data flows change.
Company and contact details
UK sites must make it easy to identify and contact the business. Do not hide the basics behind a form.
- Legal business name and trading name if different.
- Company number and registered office if you are a limited company or LLP.
- Geographic contact address. A PO box alone is not enough.
- Email address and a phone number.
- VAT number if registered.
- Regulator or professional body details if you are regulated.
Place this on the contact page and in the footer. If you have ever scrambled for a company number on launch day, you know why we do this early.
Cookie banner basics
- Show clear choices. Accept and reject should be equal in weight.
- Do not set non-essential cookies until consent is given.
- Offer a preferences link in the footer so users can change their choice later.
- Match the categories and scripts exactly. No catch-all buckets.
Avoid delays and risks
- Avoid copy-paste policies without legal review.
- Avoid non-compliant cookie banners that nudge acceptance.
- Avoid missing company details on contact and footer pages.
Good practice – date your policies, name an owner, and review them at each major site change.
Quick launch checklist
- Privacy policy, cookie policy, and terms are final, reviewed, and linked in the footer.
- Cookie categories map to specific tools. Tested in staging and live.
- Consent banner blocks non-essential scripts until accepted.
- Accessibility statement published with a contact route for issues.
- DPIA completed if your data warrants it.
- Contact and company information is present on contact and footer pages.
Handle this now and launch runs smoother. It also builds trust, which is hard to win back if you lose it.
12. Environments and workflow We plan the build so work is calm, reversible, and easy to review. No last minute scrambles. No risky shortcuts. Changes move through clear steps and can be undone if needed. Environments We use three environments. Each has a job. Local is the developer’s machine. Fast and safe for early work. Staging is a private test site that mirrors live. It is used for reviews, content entry, and checks. We protect it so search engines do not index it. Production is the live site. It only receives tested, approved changes. This split stops surprises. It also makes issues easier to trace. Version control and review We use Git. Git is a simple change history for code and config. It records who changed what and why. If something breaks, we can step back. Every meaningful change goes into Git. No loose files. No edits only on a server. We use code review. A second pair of eyes checks changes before they move on. This reduces bugs and keeps standards consistent. Reviews look for clarity, security, performance, and the effect on SEO basics like titles, headings, and internal links. Deployments and rollback Deployment means moving approved changes to staging or live. We automate this so the same steps run every time. Fewer mistakes. Faster feedback. Rollback means undoing a release quickly if something goes wrong. We keep a clear rollback plan for each launch and major update. We take a backup before we deploy, and we keep the previous release ready to restore. For live releases we schedule a short window. We test key user paths right after – forms, cart, search, and any custom flows. Issue tracking and cadence We track work in a simple issue tracker. It is a shared list of tasks with owners, notes, and status. Everyone can see progress and what is blocked. On larger projects we use short sprints. A sprint is a one or two week block of focused tasks with a review at the end. Small sites may use a straightforward to-do and weekly check-in instead. The aim is the same – steady, visible progress. Content freeze near launch Close to launch we freeze content and templates. This avoids last minute changes that create bugs or mismatches between staging and live. Typical rules: 3 to 5 working days before launch – no new features or plugin changes. 2 days before launch – content freeze on structure and key pages. Only critical fixes and typos. On launch day – changes wait until post-launch checks are done. If something urgent comes up, we log it, assess risk, and either schedule it or include it with a clear rollback plan. What we avoid Editing on live. FTP-only workflows. No rollback plan. Untracked changes or hotfixes without documentation. Simple flow we follow Plan the change. Write a short note on the why and the impact. Build on local. Commit changes to Git with clear messages. Open a review. Another person checks the work. Deploy to staging automatically. Test function, speed, and SEO basics. Gather feedback. Agree scope for release. Start the content freeze window. Back up live. Deploy to production. Run post-release checks. Monitor and document. If needed, roll back fast and fix on staging. The result is steady work and predictable launches. Fewer surprises. If something breaks at 4 pm, we fix it at 4.15. No one needs a 10 pm rescue.
13. Content production and migration
Content carries your message, wins searches, and converts visitors. We plan how it is created, improved, and moved so you keep equity and do not confuse users or search engines.
Content plan and briefs
We start with a simple plan. Which pages matter most. What they need to achieve. Who they are for.
For priority pages we write a clear brief. A brief is a one page guide for the writer and reviewer. It keeps the page focused and measurable.
- Purpose – what the page must do and how we will judge success
- Audience – who it is for and what they care about
- Questions to answer – real questions from customers and sales calls
- Search topics – target terms and intent in plain language
- Page outline – headings, sections, and key messages
- Proof – case studies, data points, quotes, or references to include
- Internal links – which pages this page should link to and from
- Call to action – the next step, kept simple
- Media – images, diagrams, or downloads needed
AI assisted drafting, with human review
AI can speed up first drafts. We use it where it helps, but we do not publish raw AI copy.
- We feed the brief and trusted sources to the tool
- We check facts, add real examples, and cut fluff
- We write claims we can stand behind and cite the source when needed
- We edit for tone and clarity so it sounds like your business, not a machine
- We run a final human proofread before anything goes live
The result reads clean, matches your voice, and stays accurate. AI helps, humans are accountable.
Media optimisation and naming rules
Images and files affect speed and search. We follow simple rules so the library stays tidy and the site loads fast.
- Use the right size – resize to the largest place it will appear
- Compress sensibly – keep quality high, file size low
- Use modern formats where possible – WebP for images is a good default
- Descriptive names – lower case, hyphens, no spaces, no IMG_1234
- Naming pattern – topic-context-size, for example service-london-hero-1600×900.webp
- Alt text – short, factual description for accessibility and context
- Video – host via a streaming service or CDN if heavy, then embed
These small habits pay off. Pages feel faster and are easier to manage a year from now.
Inventory, pruning, and improvements
Before moving content we make an inventory. Think of it as a list of everything you have. Pages, posts, PDFs, and media.
- Record URLs, titles, and rough performance where available
- Keep winners – high value pages that still match your goals
- Merge overlaps – combine thin or duplicate pages into one stronger page
- Retire what is dead – outdated, zero value pages do not need a new home
- Refresh keepers – update facts, examples, and calls to action
We protect what works and fix what does not. Copying everything across is easy, but it carries old problems with it.
Redirect map and URL changes
If a page moves, we set a 301 redirect. A 301 is a permanent move that sends people and search engines from the old address to the new one.
- Build a redirect map – a simple sheet with old URL, new URL, and reason
- Document all URL changes – do not rely on memory
- Implement on staging first – test clicks, forms, and key journeys
- Check for loops and typos – one bad rule can hide a page
- Ship redirects before launch – never leave them to launch day
This keeps equity and bookmarks intact. It also avoids 404 errors that frustrate users.
Migration workflow and QA
We move content in small batches. Each batch is checked before the next one starts. Calm work beats a big push that hides mistakes.
- Prepare – create pages with correct templates and slugs
- Move – copy improved content, not legacy bloat
- Wire up – set internal links, menus, and featured images
- Check – headings, spelling, mobile layout, and basic accessibility
- Review – a second person signs off the batch
We also carry across page titles and meta descriptions. These are the title and short summary often shown in search results.
Editorial calendar and approvals
Publishing needs rhythm. We keep a light editorial calendar so work stays visible and on time.
- Schedule – draft, edit, and publish dates for each item
- Owners – who writes, who reviews, who approves
- Status – briefed, drafting, in review, approved, scheduled
- Sign off – legal or compliance review if needed
- Review cycle – set a reminder to revisit key pages every 6 to 12 months
A simple shared sheet is often enough. The key is that everyone knows what is next and who is on the hook.
What we avoid
- Unreviewed AI copy published as-is
- Copying legacy bloat and dead pages
- Large batches without QA
- Leaving redirects until launch day
Do the basics well. Briefs, tidy media, tested redirects, and small batches. You keep your hard won equity and launch without drama.
14. QA, accessibility, and SEO checks
We test calmly and thoroughly before launch. Across devices, browsers, and real user states. The aim is simple – no surprises on go-live.
Pre-launch checklist with owners
- Content freeze confirmed – Owner: project lead
- Redirects prepared and reviewed on staging – Owner: developer and SEO
- Forms tested end to end – success, errors, emails received, spam controls – Owner: QA and client
- 404 and error pages checked – clear copy, helpful links, correct status code – Owner: developer
- Accessibility basics passed – keyboard use, focus states, contrast, alt text, form labels – Owner: designer and QA
- Cross-browser and device tests passed – Owner: QA
- Lighthouse and Web Vitals within agreed targets – Owner: developer and SEO
- Structured data validated – Owner: SEO
- XML sitemap present, robots.txt correct, staging blocked and live site indexable – Owner: SEO
- Analytics and tracking firing once, not twice – Owner: developer
- Backup taken and rollback plan ready – Owner: developer
- Launch window booked with the team – avoid Friday afternoon – Owner: project lead
Cross-browser and device testing matrix
No desktop-only testing. Real users are on phones, tablets, and different browsers.
- Mobile phones: iOS Safari, Android Chrome – small screens, touch, slow networks
- Tablets: iPad Safari and Chrome – orientation changes, larger touch targets
- Desktop: Windows Chrome, Edge, Firefox – macOS Safari and Chrome
- States: logged out, logged in (if relevant), empty states, long content, error states
- Inputs: keyboard only, screen magnification, high contrast mode
- Network: fast and poor connections – check loading, image quality, and timeouts
Lighthouse and Web Vitals checks
Lighthouse is a built-in audit in Chrome that scores performance, accessibility, and basic SEO. Web Vitals are simple measures of speed and stability. They cover how fast the page shows, how stable it feels, and how quickly it reacts.
- Run Lighthouse on key templates – home, service, blog post, contact
- Watch Core Web Vitals – Largest Contentful Paint for load speed, Cumulative Layout Shift for visual stability, Interaction to Next Paint for responsiveness
- Check mobile first – then desktop
- Fix heavy images, unused scripts, and layout shifts from late-loading assets
- Retest after fixes to confirm gains
Accessibility essentials
Accessibility means everyone can use the site. It also improves general quality.
- Headings in a clear order – no skips
- Links make sense out of context – avoid vague labels
- Images have useful alt text where needed
- Buttons and form fields have labels
- Colour contrast meets sensible levels
- Everything works with a keyboard – visible focus, no traps
- Do a quick screen reader spot check on a key page
Structured data validation
Structured data is extra markup that helps search engines understand your content. Think of it as clear labels for things like your business, breadcrumbs, articles, or FAQs.
- Use only types that match your content – for example Organisation, LocalBusiness, BreadcrumbList, Article, or FAQPage
- Validate with a testing tool – fix errors and remove guesswork
- Avoid spammy markup – do not fake reviews or add data that is not on the page
XML sitemap, robots.txt, and indexing checks
The XML sitemap is a list of your pages for search engines. robots.txt is a simple file that tells crawlers what to fetch. Indexing means your pages are allowed to appear in search.
- Confirm the sitemap URL loads and includes key pages
- robots.txt should allow crawling on the live site and link to the sitemap
- Staging stays blocked from indexing
- Remove any noindex settings on the live site before launch
- After launch, request indexing of key pages and check for errors
Forms, errors, and 404s
People need clear feedback when things go wrong. We test both happy and unhappy paths.
- Submit each form with valid and invalid inputs – see clear messages
- Confirm emails arrive at the right inbox and look tidy
- Spam protection works without blocking real users
- 404 page is helpful, branded, and returns a true 404 status
- Server error screen is readable and not a blank wall
Launch timing and sign-off
Avoid Friday afternoon launches. Pick a calm window when the team is available, backups exist, and rollback is clear. We run the checklist together, make a coffee, and only then push live.
15. Launch and early monitoring
We release with a plan. Then we watch the right signals and fix fast. No surprises, no silent launches.
DNS cutover and cache strategy
DNS is the address book that points your domain to the new server. We prepare it so the switch is smooth.
- Lower DNS TTL ahead of time so changes travel faster.
- Record old and new IPs. Keep the old host reachable during the switch.
- Update DNS in a quiet window. Confirm the SSL certificate works on the new host.
- Clear caches after cutover – CDN, server cache, and any plugin cache.
- Set sensible browser cache times. Avoid caching logged-in pages or forms.
- Check the site from different networks to confirm the change has propagated.
Monitoring and alerts
We do not launch and walk away. We keep eyes on uptime, errors, and 404s. Alerts go to people who can act.
- Uptime pings – alerts if the site goes down or slows sharply.
- Error logs – watch for repeated 5xx errors and PHP or application errors.
- 404 monitoring – spot broken links or missing assets early.
- Security alerts from the host or firewall, if in place.
- Contact form delivery – confirm messages arrive and keep a fallback email visible.
Search Console and analytics verification
Search Console is Google’s dashboard for site health in search. We verify ownership, submit the XML sitemap, and check coverage. Analytics confirms real user activity.
- Verify the domain in Search Console. Submit the live XML sitemap.
- Confirm robots.txt allows crawling on the live site.
- Check Coverage for blocked or excluded pages and fix obvious causes.
- Verify analytics is running on all key templates. Annotate the launch date.
- Check core conversion events – form submissions, calls, or sales – are tracked.
First week – performance and crawl checks
The first week is about stability. Small fixes only. No big content or template changes unless something is broken.
- Speed spot checks on mobile first. Confirm pages load quickly for real users, not just in tests.
- Watch Core Web Vitals trends. Look for layout shifts or slow first loads.
- Review crawl stats in Search Console. Make sure Google can fetch without errors.
- Scan for image or script requests returning 404.
- Check server resources and error logs daily. Fix the root cause, not just the symptom.
Rollback criteria and process
Sometimes the fastest fix is to roll back. We agree the triggers before launch, so no debate when time is tight.
- Sustained downtime or repeated 5xx errors that cannot be resolved quickly.
- Critical journeys fail – checkout, bookings, logins, or contact forms do not work.
- Severe DNS or SSL problems that block access.
- Major search coverage faults caused by the release – live site unintentionally noindexed or blocked.
- Security concerns introduced by the change.
Process is simple. Restore the last known good backup or switch DNS back to the previous host. Keep cache clears in mind after any switch. Communicate the rollback, log the cause, and schedule a fix before attempting a second launch.
What we avoid
- Silent launches with no monitoring or alerts.
- Big redesign tweaks or content restructures in week one.
- Ignoring error logs, 404 spikes, or search coverage warnings.
Stay calm, watch the signals, and act quickly. That is how launches stay uneventful, which is exactly what we want.
16. Training, documentation, and maintenance
The goal is simple. Make the site easy to run day to day, without calling a developer for every small change. That takes training, clear notes, and a routine that sticks.
Editor training and short video guides
We train the people who will use the site. Editors get hands-on time with their own content, not dummy posts. We record short videos for the common tasks. Two to five minutes each. No fluff. Just the steps and the why.
Typical topics:
- Adding and editing pages and posts
- Using blocks, patterns, and reusable parts
- Image handling – sizes, cropping, alt text
- Menus and simple redirects
- Forms – edit fields, check deliveries
- Publishing checks – titles, meta descriptions, internal links
We keep the videos in a shared folder and link them inside the dashboard. If someone forgets a step, the answer is one click away. It saves time and avoids guesswork.
Access and roles
Not everyone needs Admin. In WordPress, roles control what a person can do. Admin can change settings and plugins. Editor can publish content. Author can write their own posts.
- Give Admin to the site owner and the technical contact only
- Give Editor to people responsible for publishing
- Give Author to occasional writers
- Use a shared inbox email for emergency access, stored safely
This keeps the site safe and reduces accidents. It also makes training simpler, because each person sees only what they need.
Runbooks for updates, backups, and incidents
A runbook is a short checklist anyone can follow. One page, clear steps, links to the right screens. We write three core runbooks.
Updates runbook:
- Take a fresh backup
- Update plugins and themes in a safe window
- Test key pages and forms
- Clear caches if used
- Log what changed and any issues
Backups runbook:
- Where backups live and how long they are kept
- How to make a manual backup before changes
- How to restore a single file or the whole site
- How to confirm the restore worked
Incidents runbook:
- Who to contact first and how
- Immediate steps – disable a problem plugin, switch to a safe theme, or enable maintenance mode
- What evidence to capture – error messages, time, last change
- When to roll back and how to communicate it
These live in a shared document and inside the dashboard. They get updated when the stack changes.
Design and content style guides
Consistency makes a site feel professional and helps with long term SEO. We keep the rules short and practical.
- Brand basics – colours, fonts, logo spacing
- Components – how to use buttons, cards, forms, alerts
- Layout patterns – hero, service page, case study, blog post
- Content tone – clear, direct, UK spelling, no jargon unless needed
- Headings and lengths – one H1 per page, short intros, scannable subheads
- Media – image sizes, naming files, alt text guidance, caption use
- Links – internal linking habits and anchor text that makes sense
We add examples. One good page is better than a long PDF no one reads.
Maintenance schedule and responsibilities
Agree the rhythm and the owner. Put it on a calendar. Missed maintenance costs more later.
- Weekly – check form submissions, review recent edits, approve or remove new users
- Monthly – apply updates with the Updates runbook, test key journeys, review backups and storage space
- Quarterly – audit plugins and themes, remove what is not used, review page speed and image weights, tidy redirects
- After any major change – run a quick smoke test across templates and forms
Responsibilities:
- Content owner – keeps pages accurate and up to date
- Technical owner – handles updates, backups, and incidents
- Search owner – checks basic visibility and fixes obvious issues
On small teams one person may wear two hats. That is fine. Write it down so there is no drift.
Backlog for improvements post-launch
Keep a simple backlog of ideas. A shared spreadsheet is enough. Each item has the page, the change, the reason, and the expected impact.
- Capture ideas from users, editors, and support tickets
- Tag by impact and effort to aid prioritisation
- Review monthly, pick a small batch, and ship
- Measure the result where possible, then tidy or revert
This keeps momentum without turning the site into a permanent build project.
What we avoid
- Handing over without documentation
- Admin-only editing for all users
- Set-and-forget maintenance
Train people, write the essentials, and keep a steady maintenance habit. That is how the site stays healthy and useful for years.
17. International and local SEO considerations Plan for geography early. Or keep it simple if you do not need it. If you only serve the UK, focus on local signals. If you serve multiple countries or languages, set the structure before you write a word. If you only serve the UK Keep the setup tight and consistent. This builds trust with search and users. Add your full business details on the site – name, address, phone, hours. Put them on the contact page and in the footer. Use Local Business schema. That is a small block of code that labels your business details for search engines. We add it once and keep it updated. Keep NAP consistency. Your Name, Address, and Phone must match everywhere – site, Google Business Profile, and key directories. Same format, same spelling. Set up Google Business Profile properly. Choose the right primary category, add relevant secondary categories, service area, hours, photos, and a short, clear description. Ask for reviews over time. Create location pages only for real places you serve from – offices, studios, clinics. Do not spin up pages for towns where you have no presence. If you serve multiple countries or languages Decide the structure first. It saves rework later. Then plan content per market, not just translations. Pick a URL approach per market: Subfolders – example.com/uk/, example.com/fr/. Usually simplest to run and share authority across markets.Subdomains – uk.example.com. Works, but splits some signals and adds overhead.Country domains – example.fr, example.de. Strong local signal, but more cost and management. Better if you have real operations and teams in those countries. Use hreflang. This tells search engines which page is for which language or country. For example en-GB for UK English and en-US for US English. We configure it in the head or sitemap so the right version shows in the right market. Localise content, do not just translate. Adjust examples, currency, spelling, measurements, contact options, delivery or service terms, and legal notices. Keep calls to action and forms relevant to the market. Avoid duplicate English variants. If UK and US both use English, make sure each page has clear differences that matter to users. Otherwise they compete in search and both lose. Plan operations details per market. Who answers enquiries, what phone number is shown, and what hours apply. Content should match reality. Hreflang in plain English Hreflang is a tag that pairs equivalent pages across languages or countries. It helps Google send a French user to the French page, and a UK user to the UK page. We set it up once per template and keep the pairs consistent. It reduces duplicate issues and wrong‑market clicks. Local Business schema and NAP Schema is a small data layer that sits behind the page. It confirms your business name, address, phone, hours, and more. NAP is that same set of details. Keep it identical across your site and profiles. Even small differences – Ltd vs Limited, or 0207 vs 020 – can weaken trust signals. Google Business Profile setup Pick the most accurate primary category. Add a few precise secondary ones. Avoid stuffing. Set service areas or a storefront address as it truly is. Do not list cities you do not cover. Add hours, photos, and products or services. Keep them updated. Use the same phone and address format as on your site. Link to the right landing page for that market. Ask for reviews slowly and steadily. Reply to them. It signals care. What to avoid Auto-translation without human review. It creates mistakes and odd phrasing. People notice. Duplicate English variants that cannibalise each other. Different market pages must be meaningfully different. Doorway pages for places you do not serve. If you do not have a presence or offer there, do not build a page for it. If your business is UK only, keep the site lean and local. If you are multi-market, set structure, hreflang, and localisation at the start. It costs less than fixing it later.
18. Budget, trade-offs, and timeline
We plan to ship useful work early, keep costs predictable, and avoid surprises. That means making choices in a clear, shared way. No hidden extras. No drifting scope.
Prioritisation matrix – impact vs effort
We sort tasks by two things: impact and effort. Impact is the real-world benefit – leads, sales, trust, or reduced workload. Effort is the time and complexity to design, build, write, review, and test. We give each a simple score, then decide:
- High impact – low effort: do first. This is where early wins live.
- High impact – high effort: plan, split into chunks, schedule.
- Low impact – low effort: batch or park. Do only if it supports a bigger goal.
- Low impact – high effort: cut. If needed later, we revisit with fresh eyes.
This stops gold plating and keeps us focused on outcomes that matter.
Phased roadmap with acceptance criteria
We work in phases. Each phase has acceptance criteria – a short checklist that defines done. If a test fails the checklist, the phase is not complete.
Phase 0 – decisions and setup
- Goals, audience, and success measures agreed in writing.
- Sitemap and page list approved.
- Brand assets provided or confirmed.
- Content plan, owners, and dates set.
- Key tech choices agreed – hosting, forms, tracking, required integrations.
- Risk log created and owners named.
- Change control rules agreed.
Phase 1 – foundation
- Clean WordPress setup on staging – a safe private copy for review.
- Core templates in place – homepage, service, article, contact.
- Performance baseline measured – page weight and load time captured.
- Accessibility basics checked – colour contrast, keyboard access, clear headings.
- Analytics and consent banner configured.
Phase 2 – core journeys
- Primary pages built with final copy and media.
- Key forms working end to end – submit, notifications, thank you, spam protection.
- Essential schema added – organisation, local business if relevant.
- Technical SEO checks passed – titles, meta, headings, canonical, sitemap.
- Redirects planned for any moved pages.
Phase 3 – enhancements
- Blog, resources, or case studies live if in scope.
- Search and filters tested if used.
- Structured internal links added to support key pages.
- Performance tuned – images, caching, critical CSS where helpful.
Phase 4 – launch and handover
- Launch checklist completed – backups, redirects live, forms re-tested on production.
- Monitoring on – uptime, analytics, search console.
- Editor training delivered with short how-to notes.
- Go-live sign-off recorded by the budget holder.
We can adjust phase names and contents to fit your project. The checklist stays.
Cost-benefit for features
Before adding a feature, we ask simple questions:
- Does it help the main goal – leads, sales, or trust?
- How much design, build, content, and testing does it take?
- Any ongoing costs – licences, support time, data fees?
- Any performance hit – slower pages or larger images?
- Any operational load – who will run it day to day?
- Any dependencies – third parties, approvals, legal checks?
Examples to ground it:
- Live chat can improve enquiries, but it adds support load and can slow pages. Worth it if someone can reply quickly.
- Heavy animation looks nice, but often harms speed. If used, keep it light and purposeful.
- Multiple languages are powerful if you serve those markets. If not, keep focus and avoid duplicate work.
Rule of thumb: if a feature does not move a key metric, it waits.
Risk log – owners and mitigations
We keep a simple risk log. Each risk has a description, likelihood, impact, owner, mitigation, and a trigger for action. The owner is the person who will deal with it if it happens.
- Content delays – Owner: client lead. Mitigation: content calendar, early drafts, plain templates.
- Slow approvals – Owner: client sponsor. Mitigation: single approver, fixed review windows.
- Integration uncertainty – Owner: developer. Mitigation: small technical test with sample data.
- SEO dip on launch – Owner: SEO lead. Mitigation: redirects, pre-launch crawl, post-launch checks.
- Performance regressions – Owner: developer. Mitigation: set a simple performance budget – limits for page size and load time – and test against it.
- Compliance changes – Owner: client. Mitigation: confirm legal text and consent rules before build, review at launch.
- Scope creep – Owner: project manager. Mitigation: use change control before starting extra work.
We review the log at each phase gate so nothing sneaks up on us.
Change control for scope shifts
Change control is a light process so changes are clear, priced, and scheduled without chaos.
- Request – write the change in plain English. What and why.
- Log – add it to the change log with the date and requester.
- Assess – confirm impact on time, budget, quality, and risks.
- Options – present choices, including do nothing, smaller version, or full version.
- Decision – budget holder approves or declines in writing.
- Plan – update timeline, cost, and acceptance criteria. Then start.
Minor tweaks that fit the current phase can be batched. Anything larger follows the steps above. No quiet add-ons.
What we avoid
- Fixed scope with moving goals. If goals change, scope must change too.
- Gold plating low-impact features. Nice to have is not enough.
- Hiding risks or assumptions. We write them down.
- Starting build without decisions documented. We keep a decisions log and sign-off before work begins.
Clear choices save time and money. A simple plan, agreed early, beats a clever plan changed late.
FAQ
How long should planning take before design starts?
It depends on scope, content readiness, and stakeholder availability. Small sites with a single approver move faster. Complex sites or multiple teams take longer. Good planning speeds up design and build because decisions are clear and rework drops.
Do we need final copy and brand assets before planning?
No. Working drafts and core brand elements are enough to start. We need the basics – logo, colours, typography if set, and tone notes. Content and design inform each other, so we shape both in parallel and refine as we go.
Can we use a premium theme and still keep performance?
Yes, if the theme is lean, well supported, and lets you disable extras. Avoid multipurpose bundles that load everything. If you need tight control, high speed, or a strict design system, a custom or block theme is often better. Keep plugins minimal either way.
How much SEO work happens before vs after launch?
Pre-build covers intent research, keyword mapping, site structure, internal linking plan, on-page rules, and redirects. We also set technical basics and tracking. Post-launch focuses on content expansion, optimisation, schema where relevant, and ongoing monitoring in Search Console and analytics.
Where does AI fit in this process?
AI helps with research, briefs, outlines, and first drafts. It can speed audits and produce options to review. Human review is required for facts, brand voice, compliance, and final editing. Treat AI as an assistant, not an author of record.
What if we are redesigning an existing site with rankings?
Start with an audit of URLs, queries, backlinks, and content value. Map redirects before any launch. Keep proven URLs and intent where possible. Test on a staging site, then monitor crawl errors, rankings, and key pages closely after go live.
Do we need special hosting or a CDN?
Choose hosting based on reliability, support, and performance targets. A CDN helps when traffic is national or global, media is heavy, or you need stable speed under load. For local, low-traffic sites it can be optional. Aim for modern PHP, HTTP/2 or HTTP/3, caching, and backups.
Can we phase features to control budget?
Yes. Prioritise by impact on leads, sales, or trust. Ship a stable core first with clean structure and tracking. Add enhancements later on the same foundation, not as rewrites. Keep a backlog and review it at each milestone.
You might like these too
These sit in the same category as the one you are reading. They follow the same thread and offer a bit more depth. Have a look if you want to go further.