Frontend Architecture
How a frontend stays workable across many people and many years.
17 topics
Choosing a Rendering Architecture
SPA, SSR, SSG, ISR and RSC — what each optimises for, and the questions that pick one.
core25 minComponent API Design
Designing props and composition so a component is reusable without becoming a configuration language.
core25 minDesign Systems
What a design system actually consists of beyond a component library, and why adoption is the hard part.
core25 minVersioning Shared UI
Shipping changes to a component library many teams depend on, without breaking them or freezing yourself.
deep20 minDocumenting UI with Storybook
A workshop for building components in isolation, and what it buys beyond documentation — testing, review, and accessibility checks.
core20 minTheming & Multi-Tenant UI
One codebase rendering as many brands — token layering, per-tenant configuration, and the isolation that keeps them apart.
deep20 minModule Boundaries & Folder Structure
Organising by feature rather than file type, and enforcing the boundaries so the structure survives contact with a deadline.
core20 minMonorepos for Frontend
Several packages in one repository — what it buys, what it costs, and the tooling that makes it viable.
deep25 minMicro-Frontends
Splitting a frontend across independently deployable teams — when the organisational problem justifies the technical cost.
deep25 minBFF & API Layering
A backend shaped for one frontend — what it solves, what it costs, and where it sits next to server components.
deep20 minResilient UI & Error Handling
Designing for partial failure so one broken widget does not take the page, and errors reach someone who can act.
core25 minFrontend Observability
Knowing what users actually experience — error tracking, real-user monitoring, logs and traces that cross into the backend.
core25 minAnalytics & Event Taxonomy
Designing a tracking plan that answers product questions, rather than accumulating events nobody can interpret.
deep20 minFeature Flags & Progressive Delivery
Separating deploy from release — flag types, evaluation on the server versus the client, and paying down flag debt.
core25 minLarge-Scale Migrations
Moving a live codebase from one framework, library or pattern to another without a rewrite and without stopping feature work.
deep25 minError Handling
Deciding which failures are expected and handled, which are bugs that should crash loudly, and who finds out either way.
core25 minsharedObservability Fundamentals
Instrumenting a system so you can answer questions about it you didn't think to ask before it broke.
core25 minshared