Sitemap
Explore all pages and content available on Frontend Interview
Blog Posts
100 articles available
react-core(1)
start-here(1)
interview-prep(1)
React(17)
- Server vs Client Components (Next.js App Router): Boundaries, Hydration Cost, and Performance
- React 18 Concurrency: Transitions, Interruptible Rendering, and Why INP Improves
- React.memo, useMemo, useCallback: When They Help (and When They Don’t)
- Keys, Reconciliation, and Remounting: The Real Rules
- React Rendering Deep Dive: Render vs Commit (and How to Prove Rerenders)
- Polymorphic React Components (the 'as' Prop) with Type Safety
- Typing React Components in TypeScript (Practical Patterns)
- React Performance: An Interview Checklist
- Custom Hooks: Extracting Reusable Logic
- React Context: When to Use It (and When Not To)
- Controlled vs Uncontrolled Components (Forms)
- State Updates and Batching in React
- useMemo vs useCallback: When (Not) to Use Them
- useEffect: Dependencies, Cleanup, and Common Traps
- Keys in React Lists: Why They Matter
- Components, Props, and State (Interview Essentials)
- React Rendering: The Mental Model
Next.js(2)
Performance(31)
- Server vs Client Components (Next.js App Router): Boundaries, Hydration Cost, and Performance
- React 18 Concurrency: Transitions, Interruptible Rendering, and Why INP Improves
- React.memo, useMemo, useCallback: When They Help (and When They Don’t)
- Keys, Reconciliation, and Remounting: The Real Rules
- React Rendering Deep Dive: Render vs Commit (and How to Prove Rerenders)
- Web Performance Roadmap: Start Here (2 hours / 1 day / 1 week)
- Offline & Service Workers: Caching Without Breaking Users
- Performance APIs: Web Vitals, Long Tasks, and Real Metrics
- CSS Performance: contain, content-visibility, and Rendering Cost Control
- Web Performance Interview Pack: 25 Questions + Best Answers
- Performance Recipes: High-ROI Fixes (Before/After Patterns)
- Measuring Performance: Lighthouse vs RUM (and Setting Budgets)
- Next.js Performance: RSC, Streaming, and Caching Patterns
- Third-Party Scripts: Containment Strategies That Keep Pages Fast
- Rendering Pipeline: Layout, Paint, Composite (and How to Avoid Jank)
- Caching & CDNs: HTTP Caching That Actually Works
- JavaScript Cost: Hydration, Long Tasks, and Shipping Less JS
- Fonts Without Regret: Fast Loads, No CLS
- Images for Performance: Sizes, Formats, Priority, and Preload
- Performance Debugging Playbook (Chrome DevTools + Real Signals)
- Core Web Vitals: The Mental Model (LCP, INP, CLS)
- Core Web Vitals (LCP, CLS, INP): Frontend Performance That Actually Matters
- Service Workers + Offline Caching (Interview-Ready Guide)
- HTTP Caching for Frontend: Cache-Control, ETag, and Practical Strategies
- Browser Rendering Pipeline: Layout (Reflow) vs Paint vs Composite (Performance)
- Event Delegation in JavaScript: How It Works + Performance Patterns
- Debounce vs Throttle: Differences, Use Cases, and Implementations
- Map vs Set vs WeakMap vs WeakSet: When to Use Which (Interview-Ready)
- Memory Leaks in Frontend Apps: Causes, Detection, and Fixes (Interview-Ready)
- React Performance: An Interview Checklist
- useMemo vs useCallback: When (Not) to Use Them
Interviews(75)
- Server vs Client Components (Next.js App Router): Boundaries, Hydration Cost, and Performance
- React 18 Concurrency: Transitions, Interruptible Rendering, and Why INP Improves
- React.memo, useMemo, useCallback: When They Help (and When They Don’t)
- Keys, Reconciliation, and Remounting: The Real Rules
- React Rendering Deep Dive: Render vs Commit (and How to Prove Rerenders)
- Web Performance Roadmap: Start Here (2 hours / 1 day / 1 week)
- Offline & Service Workers: Caching Without Breaking Users
- Performance APIs: Web Vitals, Long Tasks, and Real Metrics
- CSS Performance: contain, content-visibility, and Rendering Cost Control
- Web Performance Interview Pack: 25 Questions + Best Answers
- Measuring Performance: Lighthouse vs RUM (and Setting Budgets)
- Next.js Performance: RSC, Streaming, and Caching Patterns
- Third-Party Scripts: Containment Strategies That Keep Pages Fast
- Rendering Pipeline: Layout, Paint, Composite (and How to Avoid Jank)
- Caching & CDNs: HTTP Caching That Actually Works
- JavaScript Cost: Hydration, Long Tasks, and Shipping Less JS
- Fonts Without Regret: Fast Loads, No CLS
- Images for Performance: Sizes, Formats, Priority, and Preload
- Performance Debugging Playbook (Chrome DevTools + Real Signals)
- Core Web Vitals: The Mental Model (LCP, INP, CLS)
- Scaling TypeScript: Project References, Composite Builds, and Fast CI
- Type-Level Testing + Public API Design (Library Author Mindset)
- Polymorphic React Components (the 'as' Prop) with Type Safety
- Typed Forms Without Pain (Mapped Types + Generic Helpers)
- Bug-Catching TS Flags: noUncheckedIndexedAccess & exactOptionalPropertyTypes
- satisfies: Enforce Shape Without Losing Literal Types
- unknown → Safe Types: Runtime Validation Patterns
- Branded Types: Safer IDs, Money, and Domain Values
- Template Literal Types for Safe Routes, Events, and Keys
- Strongly Typed pipe()/compose() (Variadic Tuples vs Overloads)
- Conditional Exports (node/browser) + Correct Types
- Path Aliases That Don’t Break Production (@/ Without Regret)
- moduleResolution: NodeNext vs Bundler (and Why It Breaks Builds)
- package.json exports + Types: Designing a Clean Public API
- ESM vs CJS in TypeScript (Interop Without Tears)
- Type-Level Testing & API Design Patterns
- Advanced Generics: Overloads, Inference Tricks, and Variance
- Mapped Types, keyof, and Template Literal Types (Interview-Ready)
- Typing React Components in TypeScript (Practical Patterns)
- Enums vs Union Types (and const enums)
- tsconfig.json: The Settings That Matter
- Declaration Merging & Module Augmentation
- Conditional Types + infer (Interview Essentials)
- The `satisfies` Operator (Why It’s a Big Deal)
- Type Guards & Narrowing Patterns
- any vs unknown vs never (Interview-Ready)
- TypeScript Utility Types: Pick, Omit, Partial, Record (Practical Guide)
- TypeScript Narrowing & Discriminated Unions (Interview-Ready)
- TypeScript Generics: Basics, Constraints, and Real Patterns
- TypeScript: types vs interfaces (When to Use Which)
- Frontend Testing: Unit vs Integration vs E2E (What Interviewers Want)
- Accessibility Basics: Semantic HTML, ARIA, and Keyboard Navigation
- Core Web Vitals (LCP, CLS, INP): Frontend Performance That Actually Matters
- Service Workers + Offline Caching (Interview-Ready Guide)
- HTTP Caching for Frontend: Cache-Control, ETag, and Practical Strategies
- Browser Rendering Pipeline: Layout (Reflow) vs Paint vs Composite (Performance)
- CORS + Cookies + SameSite: Frontend Basics (Why Requests Fail)
- Event Delegation in JavaScript: How It Works + Performance Patterns
- Browser Storage: localStorage vs sessionStorage vs IndexedDB (When to Use Which)
- JSON in JavaScript: Serialization Pitfalls + Safe Parsing Patterns
- JavaScript Objects: References, Cloning, and Immutability (Deep vs Shallow)
- JavaScript Arrays for Interviews: map/filter/reduce + Time Complexity
- JavaScript Error Handling: try/catch, Custom Errors, and Patterns
- JavaScript Equality & Type Coercion: == vs === (With Interview Traps)
- JavaScript Modules: ESM vs CommonJS (import/export vs require)
- JavaScript Prototypes & the Prototype Chain (Interview-Ready)
- Debounce vs Throttle: Differences, Use Cases, and Implementations
- Map vs Set vs WeakMap vs WeakSet: When to Use Which (Interview-Ready)
- Memory Leaks in Frontend Apps: Causes, Detection, and Fixes (Interview-Ready)
- Async/Await Pitfalls: Parallel vs Sequential (With Examples)
- Promises Deep Dive: Chaining, Errors, all vs allSettled (Interview-Ready)
- JavaScript Hoisting + Temporal Dead Zone (var vs let/const)
- JavaScript 'this' Explained: call/apply/bind + Arrow Functions
- JavaScript Closures Explained (With Interview Questions)
- JavaScript Event Loop: Microtasks vs Macrotasks (Interview-Ready)
Core Web Vitals(9)
- React 18 Concurrency: Transitions, Interruptible Rendering, and Why INP Improves
- Web Performance Roadmap: Start Here (2 hours / 1 day / 1 week)
- Web Performance Interview Pack: 25 Questions + Best Answers
- Performance Recipes: High-ROI Fixes (Before/After Patterns)
- JavaScript Cost: Hydration, Long Tasks, and Shipping Less JS
- Fonts Without Regret: Fast Loads, No CLS
- Images for Performance: Sizes, Formats, Priority, and Preload
- Core Web Vitals: The Mental Model (LCP, INP, CLS)
- Core Web Vitals (LCP, CLS, INP): Frontend Performance That Actually Matters
Offline(2)
Caching(2)
Monitoring(2)
Web Platform(9)
- Performance APIs: Web Vitals, Long Tasks, and Real Metrics
- Core Web Vitals: The Mental Model (LCP, INP, CLS)
- Accessibility Basics: Semantic HTML, ARIA, and Keyboard Navigation
- Core Web Vitals (LCP, CLS, INP): Frontend Performance That Actually Matters
- Service Workers + Offline Caching (Interview-Ready Guide)
- HTTP Caching for Frontend: Cache-Control, ETag, and Practical Strategies
- Browser Rendering Pipeline: Layout (Reflow) vs Paint vs Composite (Performance)
- CORS + Cookies + SameSite: Frontend Basics (Why Requests Fail)
- Browser Storage: localStorage vs sessionStorage vs IndexedDB (When to Use Which)
CSS(11)
- CSS Performance: contain, content-visibility, and Rendering Cost Control
- Modern CSS Features You Should Know
- CSS Positioning: static/relative/absolute/fixed/sticky
- How to Center a Div (All Common Ways)
- Accessibility Basics for Frontend Interviews
- Responsive Design: Media Queries, Fluid Layouts, and Breakpoints
- CSS Grid: Two-Dimensional Layout
- Flexbox: Aligning Layouts the Right Way
- The CSS Box Model (Deep but Practical)
- CSS Specificity: How Styles Actually Win
- CSS Grid vs Flexbox: When to Use Each
Browser(3)
Debugging(2)
JavaScript(23)
- Third-Party Scripts: Containment Strategies That Keep Pages Fast
- JavaScript Cost: Hydration, Long Tasks, and Shipping Less JS
- ESM vs CJS in TypeScript (Interop Without Tears)
- Event Delegation in JavaScript: How It Works + Performance Patterns
- Browser Storage: localStorage vs sessionStorage vs IndexedDB (When to Use Which)
- JSON in JavaScript: Serialization Pitfalls + Safe Parsing Patterns
- JavaScript Objects: References, Cloning, and Immutability (Deep vs Shallow)
- JavaScript Arrays for Interviews: map/filter/reduce + Time Complexity
- JavaScript Error Handling: try/catch, Custom Errors, and Patterns
- JavaScript Equality & Type Coercion: == vs === (With Interview Traps)
- JavaScript Modules: ESM vs CommonJS (import/export vs require)
- JavaScript Prototypes & the Prototype Chain (Interview-Ready)
- Debounce vs Throttle: Differences, Use Cases, and Implementations
- Map vs Set vs WeakMap vs WeakSet: When to Use Which (Interview-Ready)
- Memory Leaks in Frontend Apps: Causes, Detection, and Fixes (Interview-Ready)
- Async/Await Pitfalls: Parallel vs Sequential (With Examples)
- Promises Deep Dive: Chaining, Errors, all vs allSettled (Interview-Ready)
- JavaScript Hoisting + Temporal Dead Zone (var vs let/const)
- JavaScript 'this' Explained: call/apply/bind + Arrow Functions
- JavaScript Closures Explained (With Interview Questions)
- JavaScript Event Loop: Microtasks vs Macrotasks (Interview-Ready)
- Mastering JavaScript Async/Await
- TypeScript Best Practices for 2024
Networking(2)
TypeScript(31)
- Scaling TypeScript: Project References, Composite Builds, and Fast CI
- Type-Level Testing + Public API Design (Library Author Mindset)
- Polymorphic React Components (the 'as' Prop) with Type Safety
- Typed Forms Without Pain (Mapped Types + Generic Helpers)
- Bug-Catching TS Flags: noUncheckedIndexedAccess & exactOptionalPropertyTypes
- satisfies: Enforce Shape Without Losing Literal Types
- unknown → Safe Types: Runtime Validation Patterns
- Branded Types: Safer IDs, Money, and Domain Values
- Template Literal Types for Safe Routes, Events, and Keys
- Strongly Typed pipe()/compose() (Variadic Tuples vs Overloads)
- Conditional Exports (node/browser) + Correct Types
- Path Aliases That Don’t Break Production (@/ Without Regret)
- moduleResolution: NodeNext vs Bundler (and Why It Breaks Builds)
- package.json exports + Types: Designing a Clean Public API
- ESM vs CJS in TypeScript (Interop Without Tears)
- Type-Level Testing & API Design Patterns
- Advanced Generics: Overloads, Inference Tricks, and Variance
- Mapped Types, keyof, and Template Literal Types (Interview-Ready)
- Typing React Components in TypeScript (Practical Patterns)
- Enums vs Union Types (and const enums)
- tsconfig.json: The Settings That Matter
- Declaration Merging & Module Augmentation
- Conditional Types + infer (Interview Essentials)
- The `satisfies` Operator (Why It’s a Big Deal)
- Type Guards & Narrowing Patterns
- any vs unknown vs never (Interview-Ready)
- TypeScript Utility Types: Pick, Omit, Partial, Record (Practical Guide)
- TypeScript Narrowing & Discriminated Unions (Interview-Ready)
- TypeScript Generics: Basics, Constraints, and Real Patterns
- TypeScript: types vs interfaces (When to Use Which)
- TypeScript Best Practices for 2024
Tooling(6)
- Scaling TypeScript: Project References, Composite Builds, and Fast CI
- Bug-Catching TS Flags: noUncheckedIndexedAccess & exactOptionalPropertyTypes
- Conditional Exports (node/browser) + Correct Types
- Path Aliases That Don’t Break Production (@/ Without Regret)
- moduleResolution: NodeNext vs Bundler (and Why It Breaks Builds)
- package.json exports + Types: Designing a Clean Public API
API Design(2)
Advanced Types(6)
- Polymorphic React Components (the 'as' Prop) with Type Safety
- Typed Forms Without Pain (Mapped Types + Generic Helpers)
- satisfies: Enforce Shape Without Losing Literal Types
- Branded Types: Safer IDs, Money, and Domain Values
- Template Literal Types for Safe Routes, Events, and Keys
- Strongly Typed pipe()/compose() (Variadic Tuples vs Overloads)
Modules(6)
- Conditional Exports (node/browser) + Correct Types
- Path Aliases That Don’t Break Production (@/ Without Regret)
- moduleResolution: NodeNext vs Bundler (and Why It Breaks Builds)
- package.json exports + Types: Designing a Clean Public API
- ESM vs CJS in TypeScript (Interop Without Tears)
- JavaScript Modules: ESM vs CommonJS (import/export vs require)
Generics(4)
Web Development(1)
HTML(3)
Accessibility(3)
Security(2)
Data Validation(1)
Data Structures(2)
Error Handling(1)
Async(4)
Promises(3)
Scope(2)
Interview(20)
- Modern CSS Features You Should Know
- CSS Positioning: static/relative/absolute/fixed/sticky
- How to Center a Div (All Common Ways)
- Accessibility Basics for Frontend Interviews
- Responsive Design: Media Queries, Fluid Layouts, and Breakpoints
- CSS Grid: Two-Dimensional Layout
- Flexbox: Aligning Layouts the Right Way
- The CSS Box Model (Deep but Practical)
- CSS Specificity: How Styles Actually Win
- HTML Semantics: The Interview Answer
- React Performance: An Interview Checklist
- Custom Hooks: Extracting Reusable Logic
- React Context: When to Use It (and When Not To)
- Controlled vs Uncontrolled Components (Forms)
- State Updates and Batching in React
- useMemo vs useCallback: When (Not) to Use Them
- useEffect: Dependencies, Cleanup, and Common Traps
- Keys in React Lists: Why They Matter
- Components, Props, and State (Interview Essentials)
- React Rendering: The Mental Model