Web standards and operational practices, written for the people who ship them.
Practical guides on how the web is built, how it works, and how to ship it properly.
What you'll find here
Three kinds of material, each written for a different moment in your work.
How standards work in practice
Implementation guides for the standards that govern professional web work. Each one covers what the standard requires, how to test whether you have met it, and the failure modes that turn up most often.
Why things break and how to fix them
Investigations into real problems: what a dependency costs in load time, why a Lighthouse score moved, how one WCAG criterion plays out across five components.
Things to look up
Material to look up rather than read. Core Web Vitals thresholds, WCAG level breakdowns, HTTP caching headers, image format decision trees.
Browse by subject
Every document in the library belongs to one of these areas.
Foundations
Document setup and platform features. Doctype, charset, viewport, lang, Open Graph, canonical URL, favicons, container queries, and what every page needs before anything else loads.
Performance
Loading, rendering, and the measurements that describe them. Core Web Vitals, resource priority, caching behaviour, and what actually moves each of them.
Accessibility
WCAG 2.2 criteria applied to real components, and how to test them with assistive technology rather than with a scanner alone.
Security
Headers, transport, and browser-enforced boundaries. CSP, CORS, cookie attributes, and the defaults that keep a page safe without extra tooling.
Answer Engine Optimization
Structuring content so search and retrieval systems can extract, attribute and cite it without reconstructing it from surrounding context.
DevOps & Operations
Infrastructure, deployment pipelines, containers, networking protocols, and the reliability patterns required to run web applications in production.
Read these first
The documents the rest of the library assumes you have read. They are not the newest things published here. They are the ones worth reading first.
- performance
Core Web Vitals (LCP, INP, CLS)
Core Web Vitals measure loading, responsiveness, and visual stability. Hit LCP ≤ 2.5s, INP ≤ 200ms, and CLS ≤ 0.1 at the 75th percentile of real users.
- accessibility
Semantic HTML and landmarks
Use the right HTML element for the job. Landmarks like <header>, <nav>, <main>, and <footer> let assistive technologies announce structure and skip between regions.
- accessibility
ARIA - first rule of ARIA
ARIA can make custom widgets accessible, but the first rule of ARIA is don't use ARIA. Reach for a native HTML element first; add ARIA only when nothing native fits.
- performance
Cache-Control headers
Cache-Control tells browsers and CDNs how long to keep a response. Use immutable + max-age=31536000 for fingerprinted assets and short or no-cache for HTML.
- performance
Script loading - defer, async, module
Choose the right script-loading attribute for every <script>: defer for app code, async for independent third-party, type=module for modern code. Bare <script> in <head> is always wrong.
- accessibility
Image alt text
Every <img> element must have an alt attribute. The value describes the image's purpose to screen readers, search engines, and anyone whose image fails to load.
Why we publish
We publish what building the web teaches us.
Web standards are public documents.
The W3C specifications, the WCAG success criteria, and the HTML living standard are available to anyone. They are written for the people implementing browsers, though, not for the people building sites on top of them, so the distance between what a specification says and what to do on Tuesday morning stays wide.
We close that distance through the work we build and maintain: products, tools, internal systems and client projects. Publishing them raises the baseline of the field we work in, and we would rather compete on execution than on keeping information scarce.
The publication exists because the work exists, not the other way around.
More about our teamHow these documents are maintained
Written from implementation
Documents come out of work we have built and shipped.
Claims carry their method
Where a document states a performance or accessibility result, it also states how that result was measured.
Dated, and corrected in public
Every document carries a publication date. Corrections are logged rather than quietly edited away.
View corrections logStandards we hold ourselves to
What we will and will not publish, how sources are cited, and how commercial relationships are disclosed.
View editorial standards
Studio Standards
Our own implementation practices, documented in the open. They are not web standards, and the distinction matters enough to state plainly.
Standards Principles
- Open web standards
- Specifications from W3C, WHATWG and IETF.
- Zero Jank
- Main-thread free interfaces.
- Published openly
- Notes from our own practice, shared in case they're useful.
Direct Answer Structuring
Strict formatting rules for definitions using Q&A structures so AI engines can extract them as absolute facts.
Entity-Based Interlinking
Connecting content based on named semantic entities rather than just keywords, building a robust Knowledge Graph.
Citation-Ready Anchors
Building persistent deep-links onto every paragraph to encourage direct AI source citations.
Data Table Serialization
Designing semantic HTML tables specifically so they can be perfectly parsed and reasoned over by LLMs.
Rich Media Transcript Markup
Enforcing time-stamped, machine-readable transcripts alongside all video/audio content.
Zero-Layout-Shift Rendering
Strict engineering rules for reserving exact DOM space for images to guarantee a 0.0 CLS.
DevOps & Operations
Infrastructure, deployment, and monitoring practices. This content lives separate from web standards, focusing on how we build and ship reliably.
Operations Principles
- Infrastructure
- CI/CD, automated testing, and performance budgets.
- Reliability
- Making releases boring and routine.
Blue-Green Deployment vs Canary Release: What's the difference?
Blue-Green deployments switch traffic instantly between two identical environments. Canary releases shift traffic gradually to a subset of users to limit the blast radius of a bad deployment.
Disaster recovery and RPO/RTO
The strategies and metrics used to restore business operations after a catastrophic event, focusing on acceptable data loss (RPO) and acceptable downtime (RTO).
Load balancer health checks
Automated probes used by load balancers to determine if a backend server is capable of handling traffic, preventing requests from being routed to failed instances.
Exponential Backoff and Jitter: How Retry Logic Should Work
How to implement exponential backoff and jitter in retry logic — the technique that prevents cascading failures when a downstream service is struggling under load.
Runbooks and playbooks
Explicit, step-by-step technical manuals designed to guide developers through mitigating specific alerts and routine operational tasks.
TCP Keepalive: Preventing Silent Connection Drops
How TCP keepalive probes work at the OS level, why cloud firewalls silently drop idle connections before the default 2-hour timeout, and how to configure tcp_keepalive_time to prevent application deadlocks.
New in the library
View all (253) →The newest implementation guides added to the library. Each one explains what the standard requires, how to implement it, and how to verify it in practice.
- foundations
_for-sale DNS records
If a domain is genuinely for sale, say so in DNS. A TXT record at _for-sale.example.com advertises it to brokers and availability services without taking the site down or parking it.
- security
X-XSS-Protection
A dead header that roughly a third of major sites still send. No shipping browser reads it, it was never standardised, and the values people copy-paste were the dangerous ones. Stop sending it and rely on CSP.
- foundations
WebSub - push notification for feeds
If you publish a feed, advertise a WebSub hub with rel="hub" and rel="self" so subscribers are pushed each update instead of polling for it. Cuts latency to seconds and removes most of the crawl traffic your feed attracts.
Latest articles
All articles →Research, implementation notes, and technical essays exploring the web beyond specifications and reference documentation.
- AccessibilityWCAG 2.2 AA Testing: How to Test the 6 Criteria Automated Scanners Miss
- SecurityWhy Port 80 Is Required for ACME HTTP-01 Renewals: Troubleshooting AWS Ingress and Port 443 Failures
- SEOHow Googlebot Renders JavaScript and How to Diagnose When It Fails
- AEOWhat Is llms.txt? How It Works, What It Does, and Whether You Need It
- ArchitectureWhy Is the Web Still Built on Text?
- AccessibilityAccessible Name Computation: Why axe and Screen Readers Can Appear to Disagree
Want to implement these standards?
We build to the same criteria published here, with Core Web Vitals judged against field data, WCAG 2.2 AA verified with assistive technology, and architecture documented as it's built.
{
"webSpecification": {
"coreWebVitals": "field data",
"accessibility": "WCAG 2.2 AA",
"architecture": "documented as built"
}
}