Long-form, code-first write-ups on the problems I keep running into: module federation, micro-frontends, Vite, containers and shipping SPAs that search engines and humans both like.
Handoff was never "here is a tool that can read Figma and write code." It was a transfer of intent, constraints and edge cases from one head to another, and most of that transfer still happens nowhere. Seating an agent between design and engineering does not close the gap, it moves where the gap gets discovered, usually into production. What handoff was actually for, where it breaks now, and what a contract that a human and an agent can both build from looks like.
The "can AI build the front end" argument keeps using the consumer product as its test case β the one place models are weakest. Back-office is the inverse: templated screens, a design system that constrains the output, a spec that already exists in the API contract, users who file tickets instead of leaving, and enough volume to pay back the scaffolding. Where agent-built UI is already net-positive, what still needs a human, and how to set it up.
Consumer UX advice optimises for first impressions. E-commerce operations optimise for product readiness, speed and consistency: suppliers, NGPs, categories, gender, stock, campaigns and the long pipeline before a product goes live.
Years ago I got interview feedback that I lacked a "fix broken windows" mindset. Here is why that framing breaks down for software that moves other people's money, where real ownership means routing a fix through the framework (code owners, review, staged rollout, audit trail) rather than around it.
AI is making the handoff between UX, product design and front-end implementation increasingly cheap. For a large class of products, that changes the shape of the work: one person can increasingly move from understanding a problem to designing, building and shipping the solution without the traditional boundaries between roles. This piece looks at what that means for interaction design, research, hiring and internal tools and what still requires distinctly human judgement. It also makes the case that the traditional CRUD back office may be one of the first major categories of interface to change: from navigating workflows through screens to expressing intent and approving a proposed plan.
Caching removes work instead of speeding it up, but a front end has half a dozen independent caches: memoization, the request cache (TanStack Query), normalized stores, a persisted cache, the service worker, hashed assets, and prefetching. What each removes, which metric it moves, and how to choose.
If the front end is "just CSS", the API should be good enough to prove a feature works with no front end at all: a curl, an assertion, a green check in CI, before a single component exists. Shape responses around screens, keep business logic where a request can test it, and stop making the browser your second backend.
How Server-Sent Events, WebSockets and plain polling differ from the client side, the auth and reconnection gotchas each one has, and a project-by-project guide for which to reach for.
The front end is not dumb, it is not authoritative. Rules that money, security or correctness depend on live on the server and are enforced there. The server sends decisions, the client renders them, and any client-side copy of a rule is optional decoration.
Data cleaning belongs on the backend. The front end shapes for presentation, not repair. Both sides validate the same contract from one schema, and the backend never omits keys or lies with optionality, because every gap becomes defensive code in every client.
A light-hearted look at what goes wrong when the person grading your React interview thinks in for loops, distrusts arrow functions, and wants the time complexity of rendering a list. Plus the serious point: interview for the domain, by people who work in it.
Front-end architecture is not folder structure. It is the load-bearing choices: rendering strategy, app topology, the backend contract, where state lives, and the module boundaries. How to make those choices, enforce them, and evolve them.
A staged approach to moving an Angular app to React with an agent: audit the current UX, redesign, write the migration plan before any code, keep the Angular app read-only, execute one route at a time against a checklist, and keep a changelog.
How the two Web Storage APIs really differ (tab scope, lifetime, the storage event), a scenario table for picking one, why theme preference belongs in localStorage, and how to keep a consistent theme and shared variables across a module-federated app without prop drilling.
How to turn ad-hoc agent prompting into repeatable practice: writing a workflow as a markdown document, composing it from skills, adding evals that check the workflow was actually followed, and running an orchestrator that dispatches steps and tracks the checklist.
The rubric behind a React interview, how to answer the standard questions (state colocation vs context vs a store like Zustand, re-renders, data fetching, component API design), where to draw the line as a candidate and an interviewer, and why the trivia layer no longer tells you much.
A practical guide to component and unit testing in 2026: the Vitest and React Testing Library stack, testing behaviour instead of implementation, MSW for the network, mocking sparingly, handling async, and treating coverage as a signal rather than a target.
Core Web Vitals explained (LCP, INP, CLS), lab vs field measurement, the tools that give real answers, how to read a performance trace, and the fix toolbox: code splitting, breaking up long tasks, debounce and throttle, fewer re-renders, images and fonts.
The European Accessibility Act became applicable in June 2025. What is in scope, the WCAG bar it sets through EN 301 549, how member states enforce it, the transition deadlines still ahead, and a practical compliance checklist for front-end teams.
What actually changes when the same person frames the problem, designs the screens, writes the prompts, ships the code and watches the analytics: the leverage, the failure modes, and the product-management work that does not disappear.
A layer-by-layer guide to caching a modern front end: immutable hashed assets, HTML revalidation, stale-while-revalidate at the CDN edge, tag-based purging, and where an in-memory client cache like TanStack Query fits on top.
A client-rendered Vite/React SPA can rank and share well without adopting Next.js. What Googlebot actually does with JavaScript, why social crawlers do not, and a pragmatic stack: per-route meta, canonical tags, structured data and pre-rendering.
A practical comparison of the ways to compose a front-end from independently owned pieces (npm packages, server-side composition, Module Federation, native import maps, web components), and how to pick one.
Vite bakes import.meta.env into the bundle at build time, so one Docker image cannot be promoted across environments. This covers why that happens and a pattern where the container writes an env.js file at start-up from real process env.
A ground-up look at Webpack Module Federation: the runtime container, remoteEntry, the shared scope and semver negotiation. Plus how the Vite implementation differs, and the failure modes that decide whether it is worth adopting.