Master the craft of
frontend engineering
A curated knowledge base of 80+ deep technical concepts every senior developer should know. From hydration to fiber architecture, from CORS to CRDTs.
All Topics
Browse our collection of 80 frontend engineering topics
Accessibility Tree
Understanding the browser's accessibility tree and how screen readers navigate your content
ARIA
Enhance accessibility with ARIA attributes when HTML semantics are insufficient
Async/Await
Modern syntax for handling asynchronous operations in JavaScript with cleaner, more readable code
Cache Strategies (SWR)
Stale-While-Revalidate and other caching patterns for fast, fresh data
Closures
Understanding closures - one of JavaScript's most powerful and often misunderstood features
Code Splitting
Split your bundle into smaller chunks and load them on demand for faster initial page loads
Color Contrast
Meet WCAG contrast requirements for text visibility and accessibility
Component Composition
Master component composition patterns to build flexible, reusable, and maintainable UI components
Concurrent React
Understanding concurrent react and its applications in modern web development
Content Security Policy
Implement Content Security Policy headers to mitigate XSS attacks and control resource loading
Context API
Pass data through the component tree without prop drilling using React's Context API
Core Web Vitals
Understand and optimize the three Core Web Vitals metrics: LCP, FID, and CLS for better user experience
CORS
Understanding and configuring CORS for secure cross-origin requests
CQRS Pattern
Command Query Responsibility Segregation separates read and write models for optimized performance and scalability
CRDTs
Build collaborative applications with CRDTs for conflict-free data synchronization
Critical Rendering Path
Understanding the sequence of steps browsers take to render web pages and how to optimize them
CSRF Protection
Protect against CSRF attacks using tokens, SameSite cookies, and other security measures
Design Systems
Create reusable component libraries, design tokens, and documentation for consistent user interfaces
Domain-Driven Design
Use Domain-Driven Design principles to model complex business logic and create maintainable software
Edge Rendering
Use edge computing to render pages closer to users for faster response times
esbuild
Lightning-fast bundler and minifier written in Go for rapid development builds
Event Loop
Deep dive into the JavaScript event loop, call stack, task queues, and the concurrency model
Event Sourcing
Persist application state as a sequence of events rather than current state snapshots
Fiber Architecture
Deep dive into React Fiber, the data structure and algorithm that powers React's concurrent features
Focus Management
Manage focus for modals, dynamic content, and keyboard navigation to ensure accessible user experiences
Generators
Master JavaScript generators for lazy evaluation, async iteration, and creating custom iterables
GraphQL
Learn GraphQL for efficient data fetching, type safety, and flexible queries that reduce over-fetching
HTTP/2
Learn how HTTP/2 multiplexing, header compression, and server push improve page load performance
HTTP/3
HTTP/3 uses QUIC to solve head-of-line blocking and improve connection establishment
HTTPS/TLS
Understand HTTPS, TLS certificates, and secure connection establishment
Hydration
Understanding the process of attaching event listeners and state to server-rendered HTML
Import Maps
Native browser module resolution without bundlers using import maps
IndexedDB
Build offline-capable applications with IndexedDB, the browser's structured data storage solution
Intersection Observer
Efficiently detect when elements become visible or hidden in the viewport for lazy loading and animations
Islands Architecture
Architecture pattern that renders pages as static HTML with interactive components hydrated independently
JWT Security
Understand JWT structure, signing, verification, and secure implementation practices
Keyboard Navigation
Ensure all interactive elements are accessible via keyboard for users who cannot use a mouse
Layout Thrashing
Prevent expensive forced reflows by batching DOM reads and writes
Lazy Loading
Improve initial page load by deferring non-critical resources until they're needed
Long Polling
Implement real-time updates by holding HTTP requests open until data is available
Memory Leaks
Common causes of memory leaks and techniques to prevent them in JavaScript applications
Micro-frontends
Breaking monolithic frontends into independently deployable pieces
Module Federation
Webpack Module Federation enables dynamic runtime sharing of code between independent applications
Monorepos
Organize and scale frontend projects using monorepo architecture with tools like Nx, Turborepo, and Rush
Motion Preferences
Implement prefers-reduced-motion to respect user preferences and prevent vestibular disorders
Mutation Observer
Monitor DOM changes with the Mutation Observer API for building reactive components and debugging
OAuth 2.0
Understand OAuth 2.0 flows for secure third-party authorization without sharing passwords
Partial Hydration
Reduce JavaScript overhead by selectively hydrating only interactive components while keeping static parts server-rendered
Preloading Resources
Use resource hints to prefetch, preload, and prerender resources for faster page loads
Promises
Understanding JavaScript Promises from the ground up - creation, chaining, error handling, and modern patterns
Prototypes
Understanding prototype-based inheritance, the prototype chain, and modern class syntax in JavaScript
React Compiler
Understanding react compiler and its applications in modern web development
React Hooks
Master React Hooks including useState, useEffect, useContext, and custom hooks for building modern React applications
Reconciliation
Understanding React's diffing algorithm and how it efficiently updates the UI
Resize Observer
Monitor element resizes with the Resize Observer API for responsive components without polling
REST API Design
Master RESTful API design principles, HTTP methods, status codes, and best practices
Resumability
Qwik's resumability paradigm eliminates hydration overhead by serializing application state and resuming execution
Rollup
Build JavaScript libraries with efficient tree-shaking and ES module output
Screen Readers
Understand how screen readers work and test your applications for users with visual impairments
Semantic HTML
Learn semantic HTML elements that provide meaning and structure to web content for improved accessibility and SEO
Server Actions
Next.js Server Actions allow components to call server-side functions seamlessly without API routes
Server Components
React Server Components enable zero-bundle-size components that render exclusively on the server
Server-Sent Events
Use SSE for unidirectional server-to-browser real-time updates over HTTP
Service Workers
Build Progressive Web Apps with Service Workers for offline functionality, push notifications, and background sync
Stale Closure Problem
Why your useEffect callbacks sometimes use outdated values and how to fix them
Static Site Generation
Generate static HTML at build time for fast, secure, and scalable websites
Streaming SSR
Stream HTML progressively from server to browser for faster time-to-first-byte and improved perceived performance
Subresource Integrity
Use cryptographic hashes to ensure external resources loaded from CDNs haven't been modified
Suspense
Manage async operations and loading states with React Suspense for better UX
Tree Shaking
How modern bundlers remove unused code and optimize your JavaScript bundles
Turbopack
Next-generation bundler built in Rust for instant HMR and fast production builds
Type Coercion
Understanding implicit and explicit type conversion in JavaScript, equality operators, and common pitfalls
Virtual Scrolling
Implement virtual scrolling to efficiently display large datasets by only rendering visible items
Vite
Lightning fast build tool leveraging native ES modules for instant HMR and optimized production builds
Web Workers
Use Web Workers to run JavaScript in background threads without blocking the UI
WebAssembly
Leverage WebAssembly to run C, C++, Rust, and other languages at near-native speed in the browser
Webpack
Master Webpack configuration for bundling JavaScript applications with loaders and plugins
WebRTC
Understanding webrtc and its applications in modern web development
WebSockets
Build real-time applications with WebSockets for bidirectional, low-latency communication between client and server
XSS Prevention
Learn to identify and prevent XSS vulnerabilities including reflected, stored, and DOM-based attacks