Skills for Frontend Developers

Semantic HTML is not a soft requirement — it determines whether your product works for assistive technology users, passes automated accessibility audits, and ranks in search. Hiring managers at companies with real accessibility commitments will screen for this; candidates who treat HTML as a layout primitive fail these screens.

CSS is the skill most frontend developers underestimate and most interviewers probe. The gap between "can write CSS that looks right" and "understands why the cascade resolves the way it does" is where mid-level candidates fail at senior screens. Grid and flexbox are the foundation; understanding specificity, inheritance, and custom properties (CSS variables) is what separates depth from dabbling.

Framework knowledge is hired — JavaScript internals are what separate senior frontend engineers from people who can copy components. The specific things that get tested: the event loop (why setTimeout(fn, 0) doesn't mean "immediately"), closure behavior in loops, how async/await differs from Promise chains, and prototype-based inheritance. Getting these wrong in a technical screen is a fast-fail at senior levels.

React is the dominant framework in 2026 and being the default expectation at most companies. The hiring bar has moved past "can write a component" to "understands when components re-render and why, can design component APIs that do not cause prop-drilling nightmares, and knows when NOT to reach for useEffect."

Google's Core Web Vitals (LCP, CLS, INP as of 2024) are ranking signals and user experience metrics that senior frontend engineers are expected to understand, measure, and improve. The ability to run a Lighthouse audit, interpret the results, and make targeted optimizations is now a near-universal expectation at product companies.

TypeScript adoption has crossed 60%+ in frontend codebases as of 2026 and is now the default at most companies using React. The hiring bar is not "can add type annotations" — it is understanding generics, discriminated unions for type-safe state, and how to write types that help rather than hinder the developer experience.

The frontend testing bar has consolidated around: unit/component tests with React Testing Library (test behavior, not implementation), end-to-end tests for critical user flows with Playwright or Cypress. Engineers who write tests only in React Testing Library without ever touching a page-level test miss bugs in navigation, auth flows, and multi-step forms.

Next.js App Router is the current production standard for React-based web applications and is explicitly required at an increasing share of frontend roles. The shift to server components changes where data fetching belongs and how you think about bundle size — candidates who have only used the Pages Router are working with outdated mental models.

Tailwind CSS has become the dominant CSS strategy at product companies, particularly those building design-system-driven UIs. Hiring managers increasingly list it explicitly. The hiring bar: not just using the classes, but understanding when to extract a component, how to configure the theme, and when utility-first creates maintenance problems.

Redux has been largely replaced in new codebases by Zustand and Jotai for client state, and by TanStack Query (React Query) for server state. Understanding the distinction between client state (UI state, user preferences) and server state (fetched data) is the architectural insight that informs this choice.

Frontend developers who can take a Figma file and implement it pixel-accurately — including hover states, spacing tokens, and responsive breakpoints — reduce design-engineering friction and build trust with design teams. This is increasingly screened in take-home exercises.

Understanding why your bundle is large and how to make it smaller — code splitting, dynamic imports, tree-shaking configuration — separates frontend engineers who can diagnose performance problems from ones who add flags hoping for improvement.

The mental model shift from "everything renders on the client" to "some components run only on the server" is where the Next.js 13+ and React 18+ ecosystem has moved. Engineers who understand which components should be server-only (data fetching, secure access) versus client-only (interactivity, browser APIs) will design faster, more secure UIs.

Tools like v0.dev (Vercel), GitHub Copilot, and Cursor are changing how frontend code is written. Engineers who know how to prompt effectively for UI components — and then critically review and refine the output — ship faster. The skill is in the review and refinement, not the prompting.

Relevant for companies building compute-intensive browser experiences: video editing, image processing, collaborative real-time documents, or game-adjacent products. Not a general frontend requirement but increasingly relevant at specific product categories.

The most thorough treatment of JavaScript internals available for free. Covers the event loop, closures, prototypes, and async patterns at the depth that senior technical interviews probe. Not a tutorial — a deep reference.

Best for: JavaScript core skills; must-have tier.

The React team completely rewrote the documentation in 2023. It now covers hooks, the mental model for state, and common mistakes with useEffect at a depth that most blog posts do not reach. Read the "Thinking in React" and "Escape Hatches" sections thoroughly.

Best for: React hooks and component patterns; must-have tier.

The best resource on intrinsic CSS layout — flexbox and grid beyond the basics, with explanations of why the layout algorithms work the way they do. More durable than framework-specific tutorials because it teaches the underlying model.

Best for: CSS layout fundamentals; must-have tier.

The most practical TypeScript training for working React developers. Covers generic types, conditional types, discriminated unions, and template literal types through hands-on exercises. The free workshops alone cover 70% of what interview screens test.

Best for: TypeScript depth; must-have tier.

Google's authoritative reference for Core Web Vitals, performance patterns, and modern browser APIs. The performance section is the best free resource for LCP, CLS, and INP optimization with real measurement guidance.

Best for: Browser performance optimization; must-have tier.

Covers the philosophy and implementation of behavior-driven component testing. The "common mistakes" article by Kent C. Dodds covers the anti-patterns that most candidates reproduce from outdated tutorials.

Best for: Frontend testing; must-have tier.

The App Router section was rewritten and is significantly better than the Pages Router docs. The "Data Fetching" and "Rendering" sections explain the server/client component mental model with code examples and interactive diagrams.

Best for: Next.js App Router; nice-to-have tier.

The ARIA authoring practices guide and the WCAG understanding documents are essential reading for anyone serious about accessibility. MDN accessibility documentation is more practical than the W3C spec itself.

Best for: Web accessibility; must-have tier.

A free, visual reference for design patterns relevant to frontend development: rendering patterns (SSR, SSG, ISR, CSR), JavaScript patterns (module, singleton, observer), and React-specific patterns. Good reference before senior interviews.

Best for: Architectural patterns; nice-to-have tier.