Frontend Mastery

Lazy Loading & Code Splitting: Shrinking your bundle size

1 Views Updated 5/4/2026

Code Splitting & Lazy Loading

Modern web apps can be massive (5MB+). If a user has to download your whole admin panel just to see the login page, they will leave. Code Splitting allows you to break your app into small "Chunks" that are loaded only when needed.

1. React.lazy & Suspense

Instead of importing a component at the top of the file, use lazy(). This tells React: "Wait until this component is actually about to be rendered, then download its code from the server."

const AdminPanel = React.lazy(() => import('./AdminPanel'));

// Usage
}>
    

2. Route-Based Splitting

The best place to split code is at the **Route** level. Each page (Home, Profile, Settings) should be its own chunk. This ensures the "Initial Load" is extremely fast, as the browser only downloads what is on the current screen.

4. Interview Mastery

Q: "What is the difference between Lazy Loading a component and using 'Dynamic Imports' for a library?"

Architect Answer: "They use the same underlying mechanism (`import()`), but for different purposes. Lazy Loading components optimizes the **UI Render Path**. Dynamic Imports (e.g., `const moment = await import('moment')`) optimize **Utility Logic**. If you only need a heavy PDF library when the user clicks 'Download,' you should dynamically import it inside the click handler to avoid bloating the main bundle."

Frontend Mastery
1. Core Foundation & Modern JS
ES6+ for Architects: Closures, Generators, and Symbols Asynchronous JS: Event Loop, Microtasks, and Promises TypeScript Mastery: Advanced Types, Generics, and Utility Types
2. React Internals & Core Hooks
Virtual DOM vs Reconciliation: The Fiber Architecture Effective useState & useEffect: Avoiding infinite loops useMemo vs useCallback: When optimization becomes a bottleneck useContext + useReducer: Building a built-in state manager Custom Hooks: Extracting business logic for reusability
3. Professional State Management
Redux Toolkit (RTK): Slices, Selectors, and Thunks RTK Query: Automating API caching and synchronization Zustand: The lightweight alternative to Redux Signal-based State: The future of fine-grained reactivity
4. Performance & Rendering
Component Re-rendering: How to profile and fix slow UIs Lazy Loading & Code Splitting: Shrinking your bundle size Virtualization: Rendering million-row lists efficiently Web Workers: Offloading heavy calculations to background threads
5. Design Systems & CSS
Modern CSS: Grid, Flexbox, and Container Queries CSS-in-JS vs TailWindCSS: Choosing the right styling strategy Storybook: Building a shared component library Accessibility (a11y): Building inclusive web interfaces
6. Next.js & Modern Frameworks
Next.js App Router: SSR vs SSG vs ISR React Server Components (RSC): The end of the Waterfall Data Fetching Patterns: Streaming and Suspense SEO for Frontend: Meta Tags, JSON-LD, and Core Web Vitals
7. Testing & Security
Unit Testing: Vitest and React Testing Library E2E Testing: Playwright for mission-critical flows Frontend Security: XSS, CSRF, and Content Security Policy State Synchronization: Optimistic UI & WebSockets
8. Final Polish & Interview
Micro-Frontends: Scalable architecture for enterprise teams Frontend Architect Interview: System Design & Performance