A reference guide for web design students. Good work on the modern web is shaped by twelve broad principles. Each of them contains several lower-level principles of its own, and together they determine the way we plan, design, build and maintain a website.
The short version
Build to standards, with clean code and meaningful structure. Start with people and their content, make sure it works on any screen, and make it clear, accessible, fast and light on the planet.
Think of these twelve principles as umbrella ideas. Each one contains several narrower principles, which are listed under its heading. For example, “Web standards” includes the Web Standards Model, progressive enhancement and the separation of concerns, while “Clear, consistent visual design” includes principles for colour, typography and layout.
Every principle follows the same pattern. There is a brief description, followed by how it influences the design process, the lower-level principles it includes, and some reference links for further reading. Where a principle connects to one or more of our cheat sheets, it says so.
Note that the principles overlap, and sometimes they pull in different directions. Good designers don’t follow them one at a time — they balance all twelve. See Balancing the principles.
The twelve principles at a glance
Design process mapping
Where each principle has the most influence in a typical project. Note that this is a guide, not a rule.
Principle
Research and plan
Design
Build
Test and launch
Maintain
1. Web standards
Yes●
Yes●
Yes●
2. Best practice coding
Yes●
Yes●
Yes●
3. Semantic code
Yes●
Yes●
Yes●
4. User-centred design
Yes●
Yes●
Yes●
Yes●
5. Content-first
Yes●
Yes●
6. Original and engaging content
Yes●
Yes●
7. Responsive web design
Yes●
Yes●
Yes●
8. Mobile-first / device-agnostic
Yes●
Yes●
Yes●
9. Clear, consistent visual design
Yes●
Yes●
10. Accessibility
Yes●
Yes●
Yes●
Yes●
Yes●
11. Sustainability
Yes●
Yes●
Yes●
Yes●
12. Performance
Yes●
Yes●
Yes●
Yes●
The principles
1Web standards
Web standards are shared technical specifications that define how HTML, CSS, JavaScript, HTTP and other web technologies work. They are developed by bodies such as the W3C, the WHATWG, the IETF and Ecma. Because every browser implements the same standards, a page written to them will work across browsers, devices and assistive technologies, both today and in the future.
How it influences the design process
Choosing technology: we prefer open, standard HTML, CSS and JavaScript to proprietary plug-ins and tools that lock us in.
Building: we write the HTML structure first, and then link to an external stylesheet and an external script. Presentational HTML and inline styles should be avoided.
Using new features: check browser support (MDN’s compatibility tables or caniuse.com) before relying on a new feature, and always provide a sensible fallback.
Testing: validate your code, and check it in several browsers and on several devices, not just your favourite.
Lower-level principles included
The Web Standards Model: HTML for structure and meaning, CSS for presentation, and JavaScript for behaviour. Each technology does one job.
Separation of concerns: keeping those three layers in separate files, so that we can restyle a site without touching its content.
Progressive enhancement: the content and core functions work with HTML alone. CSS and JavaScript then improve the experience where they are supported.
Valid, well-formed code that browsers can interpret predictably.
Interoperability: consistent behaviour across browsers and platforms.
Learn more
W3C: StandardsWhat web standards are, why they matter, and how the W3C develops them
MDN Curriculum: Web standardsThe HTML, CSS and JavaScript “triangle”, separation of layers and the web standards model
2Best practice coding: clean, readable and consistent
This principle is about writing code that is clean (free of clutter, duplication and anything unnecessary), readable (a person can follow its structure, names and comments) and consistent (the same conventions are used throughout, by everyone on the project). Why does this matter so much? Well, code is read far more often than it is written — by teammates, by clients, and by your future self.
How it influences the design process
Before the first file: agree on naming conventions, formatting rules and a folder structure.
While building: use your editor’s formatter and a linter to enforce the rules automatically. Write the structure first, and add comments that explain why, not what.
Throughout: keep your work in version control (such as Git), with clear commit messages.
Before and after launch: validate, review and refactor. Tidy code is far cheaper to change later.
Lower-level principles included
Naming conventions: lowercase, hyphenated, meaningful names for files, folders and classes.
Consistent formatting: indentation, quote style, and lowercase element and attribute names.
Don’t repeat yourself (DRY): define a value once and reuse it, for example with CSS custom properties.
Keep it simple (KISS): choose the simplest solution that works.
Low, flat specificity: structure-first selectors, with classes only where they are needed.
Organised structure and modularity: small files and components, each with a clear purpose.
Validation, linting and version control as routine habits.
Learn more
MDN: Code style guidePractical conventions for writing HTML, CSS and JavaScript examples
Semantic code uses markup to describe what content means, not just how it looks, so that the intent behind each part of a page is explicit. That meaning can then be understood by every kind of reader:
Humans: screen readers, reader modes and translation tools use headings, landmarks, lists and labels to present content clearly.
Search engines (SEO): crawlers use structure and descriptive text to work out what a page is about.
LLMs and AI systems: these extract headings, paragraphs, lists and tables from the text of a page, and a clear structure helps them quote it accurately. Note that Google’s guidance says no special markup is needed for its AI features, but clear, crawlable text does matter.
How it influences the design process
Plan: define the page’s structure and heading outline from the content, before choosing any visual styling.
Build: choose each HTML element for its meaning (nav, main, article, button, ul). Write the HTML first, and then style it.
Test: check that the page still makes sense with CSS turned off, that the heading outline is logical, and that a screen reader can navigate it.
Describe: give every page a unique, descriptive title and meta description, and give images useful alt text.
Lower-level principles included
The right element for the job: semantic HTML rather than generic div elements.
A logical heading hierarchy with one h1, as described in cheat sheet 4.
Landmarks and structure:header, nav, main and footer.
Descriptive link text, alt text and labels.
Meaningful file and URL names (cheat sheet 1) and the lang attribute.
Real text: important content shouldn’t be locked inside images or hidden behind scripts.
Structured data (such as schema.org) where it suits the content, matching what is visible on the page.
User-centred design is an approach in which the needs, goals, abilities and context of real users drive decisions at every stage, rather than assumptions or personal taste. It is an iterative process: we research, design and test, and then we refine. Above all, remember that you are not your user.
How it influences the design process
Discover: before any design starts, find out who the users are, what they are trying to do, and in what situations and on what devices they will be doing it.
Plan: organise navigation and content around users’ tasks and language, not around the structure of the organisation.
Design: sketch and prototype cheaply, and test with real people before building anything.
After launch: use analytics and feedback to keep improving the site.
Lower-level principles included
User research: interviews, surveys, observation and analytics.
User needs, personas and user stories: ways of expressing what people need to do, and why.
User journeys and task flows: mapping the steps people take to reach a goal.
Information architecture and navigation: labels and structures that match the way users think.
Usability heuristics: consistency, clear feedback, error prevention and recognisable controls.
Prototyping, usability testing and iteration: because evidence beats opinion.
Empathy and inclusive design: considering the full range of people who will use the site.
Connects to: principles 5 (content-out), 8 (mobile-first) and 10 (accessibility).
5Content-first
Content-first means designing from the content outwards, which is why it is also known as “content-out”. The real words, images, data and functions that users came for come first, and the layout, navigation and styling are shaped around them. The opposite approach is to build an empty template and pour the content into it later. As Jeffrey Zeldman put it in 2008:
“Design in the absence of content is not design, it’s decoration.”
How it influences the design process
Early: gather or write the content (or at least a realistic outline of it) before starting the visual design.
Structure: plan the heading outline and page structure from the content (see cheat sheet 4).
Design: build components for the real length and types of content, and avoid lorem ipsum. Test layouts against awkward real content, such as long names or a missing image.
Responsive layouts: let breakpoints appear where the content stops working, not at the widths of particular devices.
Teamwork: writers, designers and developers work together from the start.
Lower-level principles included
Content audit and inventory: knowing what you have, what is missing and what should be removed.
Content hierarchy: deciding what matters most, and what users should see first.
Information architecture and content modelling: the types of content, and how they relate to each other.
Plain language: writing so that the widest possible audience can understand.
Content first, navigation second: letting the content decide the structure of the menus.
Connects to:cheat sheet 4 (headings and outlines), and principles 6, 7 and 8.
6Original and engaging content
This principle is about content that is yours and that is worth people’s time. Original means it is created or curated with real insight, experience or imagery, rather than being copied, duplicated or generic. Engaging means it is relevant, clear and interesting, and easy to read and act on. After all, content is the reason people visit a website in the first place. Google’s guidance asks for “people-first” content, made to benefit readers rather than to manipulate search rankings.
How it influences the design process
Planning: list the questions and tasks your audience has, and write content that answers them.
Assets: plan original photography, illustration and graphics early, rather than relying on generic stock images.
Writing: use descriptive headings, short paragraphs, lists and meaningful link text, so that pages can be scanned easily. Edit ruthlessly.
Legal and ethical: only use text, images and media that you have the rights to, and credit your sources.
After launch: plan regular updates and remove out-of-date pages, because stale content loses trust.
Lower-level principles included
People-first writing: content created for readers, not for search engines.
Experience, expertise, authority and trust (E-E-A-T): showing who is behind the content, and why they can be trusted.
Uniqueness: no duplicated, thin or copied pages.
Plain language and scannability: clear words, structure and formatting.
Voice and tone: a consistent and appropriate personality.
Purposeful media: images, audio and video that add something, with captions, alt text and transcripts.
Accuracy, honesty and copyright: checking facts, citing sources and respecting creators’ rights.
Responsive web design is an approach in which one website adapts to the size and capabilities of whatever viewport it is shown in, rather than building separate sites for separate devices. The term was coined by Ethan Marcotte in 2010, and its three original ingredients are flexible grids, flexible images and media, and media queries.
How it influences the design process
Design: treat a layout as a flexible system, not a fixed page, and sketch it at several widths.
Build: avoid fixed pixel widths. Use relative units, flexible layout tools, and max-width: 100% for media.
Breakpoints: add a media query where the content or layout starts to break, not at the width of a particular phone.
Test: resize the browser, use device emulation, and try the site on real devices.
Lower-level principles included
The viewport meta tag, so that mobile browsers use the device width.
Fluid, flexible layouts: percentages, rem, Flexbox and Grid.
Flexible media: images that scale, plus responsive images (srcset and <picture>; see cheat sheet 8).
Media queries and content-driven breakpoints.
Fluid typography and relative units, so that text scales with the layout.
Mobile-first means designing and coding for the smallest screen and the most constrained situation first, and then enhancing the experience as more space and capability become available. The approach was popularised by Luke Wroblewski around 2009. Device-agnostic (also known as screen-agnostic) means never assuming a particular device. In other words, your site should work for any screen size, input method, connection speed or technology, including devices that don’t exist yet. Put simply, mobile-first is the order of work, responsive design is the technique, and being device-agnostic is the goal.
How it influences the design process
Plan: small screens force us to decide what is essential, so start there and put the most important content first.
Design: sketch the smallest layout first, and then add to it as space allows.
Build: write the base CSS for small screens without media queries, and then add min-width queries for larger ones.
Test: use real phones, and throttle the network to see how the site behaves on a slow connection.
Lower-level principles included
Content priority: constraints focus the design on what really matters.
Progressive enhancement: a solid base experience everywhere, with extras layered on top.
Input-agnostic design: works with touch, mouse, keyboard and voice, with generous touch targets.
Network and device resilience: assume slow connections and low-powered devices.
Capabilities, not devices: adapt to what the browser can do, not to a list of known devices.
Context beyond screen size: mobile users are often distracted, in a hurry, or outdoors.
This principle is about organising colour, typography, layout and imagery so that a site communicates clearly, guides the user’s attention and feels like one coherent whole. Clear means that information is easy to read and understand at a glance. Consistent means that the same things look and behave the same way everywhere, so that users learn a pattern once and can then trust it.
How it influences the design process
Early: define a style guide, covering the palette, typefaces, spacing scale and component styles, and turn it into design tokens (CSS custom properties).
Wireframes first: work out the hierarchy and layout in grey, before adding colour and decoration.
Components: build reusable, consistent parts, such as buttons, cards and forms, instead of one-off designs.
Review: audit the design for consistency and check contrast. Resist the temptation to add “just one more” colour or font.
Lower-level principles included
Colour: a limited, purposeful palette. Use brand colours consistently and with enough contrast, and never rely on colour alone to carry meaning (cheat sheet 5).
Typography: one or two typefaces, a readable size, a comfortable line height, a sensible line length (roughly 45 to 75 characters) and a clear type scale.
Layout: grids and alignment, white space, grouping by proximity, repetition and balance.
Visual hierarchy: size, weight, colour and position show what matters most.
Accessibility means designing and building so that everyone can perceive, understand, navigate and interact with our websites. That includes people with visual, hearing, motor and cognitive disabilities, as well as people with temporary or situational limitations, such as a broken arm or a screen in bright sunlight. (“a11y” is shorthand: a, then 11 letters, then y.) Accessibility is the right thing to do, it improves the experience for all users, and in many countries it is also a legal requirement. In the UK, the Equality Act 2010 applies, and public sector websites must meet specific accessibility regulations.
How it influences the design process
From the start: include disabled users in your research. Accessibility that is added at the end is slower, costlier and weaker.
Design: check colour contrast, text sizes, focus styles and the clarity of layouts as you design.
Build: use semantic HTML first, which gives you much of your accessibility for free, and add ARIA only where native HTML can’t do the job.
Test: use automated checkers (but note that they catch only some issues), keyboard-only testing, a screen reader, zoom and reflow, and real users.
Target: aim for WCAG 2.2 Level AA, which is the usual standard.
Lower-level principles included
POUR: content must be Perceivable, Operable, Understandable and Robust. These are the four principles behind WCAG.
WCAG conformance levels: A, AA and AAA.
Text alternatives for images, and captions and transcripts for audio and video.
Colour contrast (4.5:1 for normal text, 3:1 for large text), and not relying on colour alone.
Keyboard access and visible focus, with no keyboard traps.
Labelled forms and clear error messages.
Resizable, reflowing text and support for zoom.
Reduced motion, and no content that flashes dangerously.
Sustainable web design means designing and building websites that minimise harm to the planet and to people. Every page view uses electricity — in data centres, in networks and on the user’s device — so a heavier site means more energy and more carbon. Sustainable web design also considers social impact: privacy, fairness and inclusion. The W3C’s Web Sustainability Guidelines frame this as planet, people and prosperity. Note that estimates of a site’s footprint vary between tools, so treat the numbers as indicators rather than exact measures.
How it influences the design process
Plan: question every feature (“do we really need this video, carousel or tracker?”), and set a page-weight budget.
Design: prefer simple layouts, system fonts (or just a few web fonts), and SVG and well-compressed images over heavy media.
Build: ship less code and less JavaScript, load media only when it is needed, and avoid auto-playing video.
Host and deliver: choose green hosting, and use caching.
Maintain: remove old and unused content and files, and measure and monitor the site over time.
Lower-level principles included
Data minimisation: sending only the bytes that are needed.
Efficient assets: the right image format and size (cheat sheet 7 and cheat sheet 8), lazy loading, and optimised fonts.
Lean code and fewer third-party scripts.
Green hosting and efficient delivery.
Content pruning: deleting what nobody needs.
Longevity: designs that keep working on older devices, so that they don’t force people to upgrade.
Ethical design: respecting privacy and avoiding manipulative “dark patterns”.
Performance describes how quickly a page loads, becomes usable and responds to input. Slow pages frustrate users, particularly on mobile devices and slow connections, and they cost sales and trust. Google’s Core Web Vitals measure three things: loading (Largest Contentful Paint, which is good at 2.5 seconds or less), responsiveness (Interaction to Next Paint, 200 milliseconds or less) and visual stability (Cumulative Layout Shift, 0.1 or less).
How it influences the design process
Plan: set a performance budget (page weight and number of requests) at the start, and treat speed as a feature.
Design: favour lightweight layouts, and decide early which images, fonts and third-party tools are worth their cost.
Build: optimise images, set width and height attributes on images, load scripts so that they don’t block rendering, and avoid unused code.
Test: measure with Lighthouse, PageSpeed Insights and your browser’s dev tools, under throttled mobile conditions. Always measure before you optimise.
Maintain: monitor performance over time, because pages get heavier as content is added.
Lower-level principles included
Perceived performance: how fast a page feels, which is helped by showing the important content first.
Performance budgets and measuring against real-user data.
Image optimisation: format, size, compression and lazy loading (cheat sheet 8).
Minification and compression of CSS, JavaScript and HTML.
Fewer requests and fewer third-party scripts.
Caching and content delivery.
Efficient font loading.
Avoiding render-blocking resources and layout shifts.
The principles reinforce each other. For example, semantic HTML helps accessibility, search, AI systems and standards compliance, all at the same time. Mobile-first thinking tends to improve performance, sustainability and content focus. Lighter pages are faster, greener and more inclusive. In other words, work that serves one principle well will often serve several.
However, sometimes they conflict, and when that happens, the skill lies in making a deliberate trade-off.
Tension
A good way to resolve it
Rich visual design and video versus performance and sustainability (9 vs 11, 12)
Use heavy media only where it earns its place. Optimise it, load it lazily, and provide a light default.
Content-first design versus a consistent design system (5 vs 9)
Build a system of flexible components that adapts to real content, rather than forcing content into rigid boxes.
Engaging media versus accessibility (6 vs 10)
Pair every image, video and animation with alt text, captions, transcripts and a reduced-motion option.
The newest CSS and JavaScript features versus web standards and wide support (1 vs 8)
Use progressive enhancement: a solid baseline for everyone, with new features layered on where they are supported.
Fast delivery versus clean code (2)
Agree conventions, and automate formatting, linting and checks at the start, so that speed doesn’t build up technical debt.
Common misunderstandings
Misunderstanding
The reality
Web standards make every site look the same
Standards define the technologies, not the design. They leave you free to be as creative as you like.
Mobile-first means mobile-only
It describes the order in which you work. Larger screens are still fully supported.
Accessibility is only for blind users
It covers vision, hearing, movement and thinking, as well as temporary and situational needs. It helps everyone.
SEO means stuffing in keywords
Search engines reward clear, helpful, well-structured content that is made for people.
Content-first means writing every word before designing
It means understanding the real content early and designing with it, not waiting for a perfect final draft.
Performance is a final polish
Early decisions about images, fonts and scripts set a page’s weight. Late fixes can only reduce the damage.
Sustainability just means green hosting
Hosting is only one part. Page weight, features, content and device longevity all count.
AI can read messy pages, so structure doesn’t matter
Machines can cope with untidy HTML, but a clear structure helps them, and every other user too.
External sites change over time, so if a reference link has moved, search for the page title. The figures quoted for the Core Web Vitals and the current WCAG version were correct at the time of writing, but check the sources for any updates.