Notes on building for the web
Notes on what we've learned building for the web, written down as we learned it, from responsive design's early days to the tools we reach for now. New entries are added as we keep building and learning.
2024
Our 2024 Front-End Toolkit: What We Reach for Now
Ten years of tool changes later, here's the actual stack we open on a new project today, and why.
Sustainable Web Design: Building Lighter Sites
A lighter page loads faster, costs less to host, and - increasingly measurably - uses less electricity to deliver.
A Practical Guide to Web Accessibility Testing Tools
Automated scanners catch roughly a third of real accessibility issues. The rest still need a human, and ideally a keyboard.
Building with Server Components in React
A component that runs only on the server, never ships its code to the browser, and can talk to a database directly.
CSS :has() - The Parent Selector We Finally Got
A decade of 'CSS can't select a parent based on its children' folk wisdom just became outdated in one release cycle.
The Baseline Initiative: Knowing What You Can Actually Use
"Can I use this yet" used to mean checking a compatibility table by hand for every feature. Baseline turns that into a single, clear label.
2023
Headless E-commerce: Shopify and Beyond
Keep the inventory, checkout and payments a platform already handles well - and build the actual storefront exactly how a client needs it.
A Practical Guide to Web Performance Budgets
A performance budget turns 'let's keep it fast' from a vague intention into a number the build can actually enforce.
View Transitions API: Smooth Page Changes Without a Framework
Animated page transitions used to mean a JavaScript framework and a lot of careful state management. Now it's a few lines of CSS.
AI-Assisted Coding Tools: What Changed for Our Workflow
An autocomplete that suggests a whole function isn't a replacement for understanding the code - but it has changed how we write the first draft of it.
An Introduction to Astro and the Islands Architecture
Ship HTML by default, and JavaScript only for the handful of components that actually need to be interactive.
CSS Has A Native Nesting Syntax Now
The single most-used Sass feature just landed natively in the browser, no build step required.
The Return of Server-Side Rendering: Why It Never Really Left
The industry spent years moving everything to the client, then spent the next few years quietly moving a lot of it back.
2022
Understanding CORS Once and For All
The error every developer hits eventually, and almost nobody understands the first time they see it.
Passwordless Authentication: Magic Links and WebAuthn
Users reuse passwords across every site they've ever signed up for. The safest password is the one that was never created in the first place.
An Introduction to Edge Computing for Web Apps
Running code close to the user, not just serving cached files close to them - that's the shift edge functions represent.
Building a Design System with Figma and Storybook
Designers work in Figma. Developers work in code. A design system needs both to actually stay in sync.
Core Web Vitals in 2022: What Actually Moved the Needle
Two years of Core Web Vitals audits later, the same handful of fixes account for most of the improvement.
Introduction to Svelte and Compiled Frameworks
No virtual DOM, no runtime framework code shipped to the browser - Svelte does its work at build time instead.
CSS Cascade Layers: Taming Specificity with @layer
Specificity wars have plagued CSS since the beginning. @layer doesn't remove specificity - it gives you a way to control it on purpose.
2021
The CSS :is() and :where() Selectors Explained
Two new selectors that turn a long, repetitive selector list into something genuinely readable.
API Security Basics: Authentication and Rate Limiting
An API with no rate limit isn't a convenience for developers - it's an open invitation to abuse.
An Introduction to Web Components
A reusable component with real encapsulation, no framework runtime required, that any framework can also drop straight into.
Web3 and Websites: Separating Hype from Utility
A wallet-connect button doesn't make a site decentralised. It's worth being precise about what actually changes and what's just marketing.
Next.js and the Rise of React Frameworks
Server-side rendering, routing, and API endpoints, all decided for you - the appeal of a framework instead of a library plus a dozen choices.
Container Queries: The Layout Problem Flexbox Couldn't Solve
A media query asks about the viewport. A container query asks about the component's own parent - a genuinely different, and often more useful, question.
2020
SEO Fundamentals Every Developer Should Know
Most technical SEO isn't a separate discipline - it's semantic HTML, a fast page, and a sitemap that isn't lying.
The Rise of JAMstack: Rethinking How We Build Websites
JavaScript, APIs, and pre-built Markup - no server rendering each page on every request, and a much smaller surface to secure.
Testing JavaScript: An Introduction to Jest
A test that runs in seconds catches a regression a client would otherwise have found for us, live, after launch.
Web Performance Optimization: The Fundamentals
Core Web Vitals turned page speed into something Google actually measures. Here's where the biggest, cheapest wins usually are.
An Introduction to Serverless Functions
No server to patch, no idle capacity to pay for - just a function that runs when it's called and nothing when it isn't.
Dark Mode: Implementing prefers-color-scheme
Respecting the operating system's own dark mode setting is one media query, not a whole redesign.
2019
Introduction to React.js for Beginners
Components, props and state - the three ideas that make React click once they finally click.
Designing a Design System: Tokens, Components, Docs
A design system isn't a component library. It's the smallest layer underneath one - the tokens everything else is built from.
A Guide to CSS Animations and Transitions
Two different tools for two different jobs: transitions react to a state change, animations run on their own timeline.
Static Site Generators Compared: Gatsby vs Jekyll vs Hugo
Three different philosophies for turning content into a folder of pre-built HTML - and three different projects each one fits best.
A Practical Guide to Web Accessibility (WCAG 2.1)
Accessibility isn't a separate checklist bolted on at the end. Most of it is just correct HTML, used correctly.
TypeScript for JavaScript Developers: Getting Started
A type error caught while typing is a lot cheaper than the same error caught by a user in production.
2018
Progressive Web Apps, Explained
Offline support, an installable icon, and push notifications - without asking a client to publish anything to an app store.
Headless CMS: A New Way to Manage Content
Decoupling the editor's writing tool from the front end that renders it opens the same content up to a website, an app, and anything else at once.
CSS Custom Properties (Variables): A Practical Guide
Sass variables get compiled away. CSS custom properties stay in the browser - and can be changed live with JavaScript.
An Introduction to GraphQL
One request, exactly the fields you asked for - no more, no less. That's the whole pitch, and it turns out to matter a lot.
CSS Grid vs Flexbox: When to Use Which
Now that Grid has solid browser support, the question isn't which one is better - it's which problem each one was actually built to solve.
Service Workers and the Cache API in Depth
The mechanism behind every 'works offline' claim a modern website can make, one caching strategy at a time.
2017
Writing Maintainable CSS with BEM
Block, Element, Modifier: a naming convention that makes a class name tell you exactly where it lives in the page.
Building a RESTful API with Node.js and Express
A walkthrough of the small set of decisions - routes, status codes, error handling - that make an API pleasant for someone else to consume.
A Beginner's Guide to Docker for Web Developers
"It works on my machine" stops being an excuse once the machine itself is defined in a file everyone shares.
Getting Started with Vue.js
A framework you can drop into one page with a single script tag, or scale into a full application - that flexibility is the whole pitch.
HTTP/2: What Changes for Front-End Developers
Multiplexed requests over one connection quietly undo a decade of front-end performance folk wisdom.
ES6 Features Every Developer Should Know
ECMAScript 2015 is now well supported enough to use directly. Here are the changes that actually alter how we write JavaScript day to day.
2016
An Introduction to Webpack and Module Bundling
One JavaScript file, built from many small ones, with dependencies resolved automatically instead of ordered by hand in a script tag.
Git for Web Developers: A Workflow That Actually Works
Version control isn't about remembering commands. It's about a small, boring set of habits that stop projects from becoming a folder of zip files.
Building Accessible Forms: The Basics
A form with no labels is unusable for a screen reader, no matter how good the placeholder text looks.
Getting Started with npm and the Node Ecosystem
package.json, node_modules, and the handful of commands that make up most of a front-end build process today.
Flexbox in Practice: Building Layouts Without the Hacks
Floats, clearfixes and negative margins built the web for a decade. Flexbox finally gives layout its own proper toolset.
CSS Preprocessors Compared: Sass vs LESS
Both add variables and nesting to CSS. The real difference between Sass and LESS shows up in tooling and how each compiles.
2015
Why We Switched to a Living Style Guide
A static PDF of brand colours goes stale the moment a developer picks a slightly different blue. A style guide built from real code can't drift.
Getting Started with Sass: A Practical Introduction
Plain CSS doesn't have variables, nesting, or math. Sass adds all three without asking the browser to change a thing.
An Introduction to Bootstrap 3 for Rapid Prototyping
A 12-column grid, a component library, and a way to get a client-reviewable prototype up in an afternoon instead of a week.
Understanding the CSS Box Model (Again)
Content, padding, border, margin - four concepts that explain most of the layout bugs a beginner will ever hit.
Why Responsive Web Design Isn't Optional Anymore
Smartphones passed desktops in web traffic this year. Here's what that means for how we plan a layout from the very first sketch.
Mobile-First Design: A Workflow, Not Just a Buzzword
Designing for the smallest screen first isn't a slogan - it forces every content decision to happen earlier, when it's still cheap to change.