Web Development Interview Questions

1. Hoisting
● Understand how variable and function declarations are hoisted in JavaScript.
● Explain the difference between variable hoisting and function hoisting.
● Be prepared to answer questions related to hoisting behavior in different
scenarios.

2. Difference between Undefined, Not Defined, and Null

● Explain what each term means in JavaScript:
● Undefined: A variable has been declared but not assigned a value.
● Not Defined: A variable has not been declared at all.
● Null: An intentional assignment representing the absence of any object
value.
● Understand when and why each value is used.

3. Call Stack
● Describe what the call stack is in JavaScript.
● Explain how the call stack works during function calls.
● Understand the concept of stack frames and how they relate to function
execution.

4. Stop Propagation
● Define what event propagation is in the context of the DOM.
● Explain how stopPropagation works to prevent further event propagation.
● Understand scenarios where stopPropagation is useful (e.g., handling events on
specific elements without affecting parent or sibling elements).

5. Difference between stopPropagation and

stopImmediatePropagation
● Compare and contrast stopPropagation and stopImmediatePropagation.
● Explain when to use each method and their effects on event propagation.

6. Difference between import and require

● Describe the differences between ES6 import and CommonJS require.
● Understand the syntax and use cases for each module system.
7. Semantic Versioning
● Explain what semantic versioning (SemVer) is.
● Understand the format of version numbers (major.minor.patch).
● Describe how to interpret version changes (breaking changes, new features, bug
fixes).

8. Event Loop
● Explain how the event loop works in JavaScript.
● Understand the concepts of the call stack, callback queue, and event loop.
● Describe how asynchronous code execution is handled.

9. Arrow Operator Use Case

● Explain the purpose of arrow functions in JavaScript.
● Describe scenarios where arrow functions are useful (e.g., concise syntax, lexical
scoping).

10. Difference between Arrow Operator and Normal Function

- Compare and contrast arrow functions with regular functions.
- Understand the differences in behavior related to `this` binding and lexical scoping.

11. Spread Operator and Rest Operator

- Explain the use of the spread operator (`...`) and rest operator (`...args`) in JavaScript.
- Describe how they work with arrays and objects.
- Understand use cases for each operator.

12. Object Destructuring

- Describe what object destructuring is in JavaScript.
- Explain how to extract values from objects using destructuring syntax.
- Understand default values and renaming properties during destructuring.

13. Role of Bundler

- Explain the purpose of bundlers (e.g., Webpack, Parcel, Rollup) in web development.
- Describe how bundlers optimize and bundle JavaScript, CSS, and other assets.
- Understand the benefits of code splitting and lazy loading.
14. DOM Manipulation
- Explain what the Document Object Model (DOM) is.
- Describe how to manipulate the DOM using JavaScript (e.g., selecting elements,
modifying attributes, adding/removing elements).
- Understand best practices for efficient DOM manipulation.

15. Event Handler

- Describe what event handlers are and how they work.
- Explain how to attach event listeners to HTML elements.
- Understand common events (e.g., click, submit, keypress) and their use cases.

16. Conditional Optional Types in TypeScript

- Explain what conditional types are in TypeScript.
- Describe how to create optional types based on conditions (e.g., `T extends U ? X :
Y`).
- Understand use cases for conditional types.

17. Generics in TypeScript

- Define what generics are in TypeScript.
- Explain how to create reusable and type-safe functions/classes using generics.
- Understand common patterns for using generics (e.g., arrays, promises, utility
functions).

18. States and Props

- Describe the concepts of state and props in React.
- Explain how state and props are used to manage data and communication between
components.
- Understand the difference between local state and global state (e.g., Redux, Context
API).

19. Context in React

- Explain what React context is and how it works.
- Describe scenarios where context is useful (e.g., theme)
20. Lifting of the State
- Explain the concept of lifting state in React.
- Describe scenarios where state needs to be lifted to a common ancestor component.
- Understand how to manage shared state across multiple child components.

21. How useRef Works

- Describe what the `useRef` hook is in React.
- Explain how `useRef` works to create a mutable reference to a DOM element or a
value.
- Use cases for `useRef` (e.g., accessing DOM elements, persisting values across
renders).

22. About useEffect and When to Use Return Statement

- Understand the purpose of the `useEffect` hook in React.
- Describe the component lifecycle phases where `useEffect` runs.
- Explain when to use the return statement within `useEffect` (for cleanup).

23. useMemo and useCallback Differences

- Compare and contrast `useMemo` and `useCallback`.
- Understand their use cases and performance implications.
- Explain how they optimize function execution and memoization.

24. Why We Should Be Careful While Using useEffect for API Calling
- Describe potential issues with using `useEffect` for API calls.
- Explain how it can lead to unnecessary re-renders.
- Best practices for handling API calls in `useEffect`.

25. Difference between SASS, CSS, and SCSS

- Compare and contrast SASS, CSS, and SCSS.
- Understand their syntax, features, and use cases.
- Explain how they compile to standard CSS.

26. All About New Hooks in React (e.g., usePathName, etc.)

- Describe any new hooks introduced in React (if applicable).
- Understand their purpose and how they enhance component functionality.
- Provide examples of using these hooks.

27. DOM Manipulation (Continued)

- Dive deeper into DOM manipulation techniques.
- Explore more advanced scenarios (e.g., creating elements dynamically, handling
events).

28. Event Handler (Continued)

- Explore additional event handling patterns.
- Discuss event delegation, event bubbling, and capturing.
- Provide practical examples of event handling in React components.

29. How to Access Local Storage in Next.js

- Explain how to use the `localStorage` API in Next.js.
- Understand the limitations and considerations when working with local storage.
- Provide code examples for reading and writing data to local storage.

30. window and document in Next.js

- Describe the global objects `window` and `document`.
- Explain how they differ in client-side and server-side rendering.
- Discuss scenarios where direct access to these objects is necessary.

31. System Analysis and Design for Chat System

- Understand the requirements for building a chat system.
- Design the architecture, data flow, and components of a chat application.
- Consider scalability, real-time communication, and security aspects.

32. System Analysis and Design for Rate Limiter

- Explore rate limiting techniques (e.g., token bucket, sliding window).
- Design a rate limiter system to prevent abuse or excessive requests.
- Consider distributed systems and high traffic scenarios.
33. Stack and Queue
- Explain the concepts of stacks and queues in data structures.
- Describe their use cases and implementations.
- Provide examples of stack and queue operations.

34. Linked List

- Understand linked lists and their variations (singly linked list, doubly linked list).
- Explain how linked lists differ from arrays.
- Implement basic linked list operations (insertion, deletion, traversal).

35. Binary Search

- Describe the binary search algorithm.
- Explain how it works on sorted arrays.
- Discuss time complexity and scenarios where binary search is efficient.

36. PUT and PATCH Differences

- Compare and contrast the HTTP methods PUT and PATCH.
- Understand their use cases for updating resources.
- Explain idempotence and safety in the context of these methods.

37. About CORS

- Define Cross-Origin Resource Sharing (CORS).
- Explain how CORS prevents unauthorized requests from different origins.
- Describe how to configure CORS in server-side applications.

38. Options and Heads HTTP Methods

- Understand the OPTIONS and HEAD HTTP methods.
- Explain their purposes and use cases.
- Discuss scenarios where they are commonly used.

39. XSS and CSRF

- Describe Cross-Site Scripting (XSS) and Cross-Site Request Forgery (CSRF) attacks.
- Explain how they occur and their impact on web security.
- Discuss preventive measures to mitigate these vulnerabilities.

40. Middleware
- Explain the concept of middleware in web development.
- Describe how middleware functions work in Express.js.
- Provide examples of common middleware (e.g., logging, authentication).

41. How HTTP Works

- Understand the basics of the Hypertext Transfer Protocol (HTTP).
- Describe the request-response cycle.
- Explain HTTP methods, status codes, and headers.

42. Why Validation is Required in Backend

- Discuss the importance of input validation in backend development.
- Explain security risks related to user input.
- Describe techniques for validating and sanitizing user data.

43. Error Handling in Production

- Explain best practices for error handling in production environments.
- Discuss logging, monitoring, and graceful degradation.
- Describe how to handle unexpected errors.

44. SSH and SSL

- Understand Secure Shell (SSH) for secure remote access.
- Explain how SSL/TLS (Secure Sockets Layer/Transport Layer Security) provides
encryption for data transmission.
- Discuss their roles in securing communication.

45. Difference between Public and Private IP

- Compare public IP addresses (used on the internet) and private IP addresses (used
within local networks).
- Explain NAT (Network Address Translation) and IP address allocation.

46. Reverse Proxy

- Describe what a reverse proxy is and how it works.
- Explain load balancing, caching, and security benefits of using a reverse proxy.
- Provide examples of popular reverse proxy servers (e.g., Nginx, Apache).

47. About DNS

- Define the Domain Name System (DNS).
- Explain how DNS resolves domain names to IP addresses.
- Discuss DNS records (A, CNAME, MX, etc.).

48. Difference between Base64 and Blob

- Compare Base64 encoding and binary large objects (Blobs).
- Understand their use cases (e.g., image embedding, file uploads).
- Explain how to convert between Base64 and Blob formats.

49. How to Serve Static Files

- Describe how web servers serve static files (e.g., HTML, CSS, images).
- Explain caching mechanisms and content delivery networks (CDNs).
- Discuss best practices for efficient static file serving.

50. Index DB and Progressive Web Apps (PWAs)

- Understand IndexedDB as a client-side database.
- Explain how PWAs enhance web applications (offline access, push notifications).
- Describe service workers and caching strategies.

51. Index DB
- Understand IndexedDB as a client-side database.
- Describe how IndexedDB provides a structured way to store large amounts of data.
- Explain its use cases (e.g., offline applications, caching).
52. Progressive Web App (PWA)
- Define what a Progressive Web App (PWA) is.
- Explain the benefits of PWAs (e.g., offline access, fast loading, responsive design).
- Describe how to build and deploy a PWA.

53. Serialization and Deserialization

- Explain the concepts of serialization and deserialization.
- Describe how data is converted to a format suitable for storage or transmission (e.g.,
JSON, XML, binary).
- Discuss security considerations during deserialization.

54. ORM (Why Do We Need ORM)

- Define Object-Relational Mapping (ORM).
- Explain why ORM is useful in web development.
- Discuss how ORM simplifies database interactions and abstracts away SQL queries.

55. About N+1 Problem and Preventive Measures

- Describe the N+1 problem in database queries.
- Explain how it occurs when fetching related data (e.g., in an ORM).
- Discuss solutions (eager loading, batch loading) to prevent N+1 queries.

More Web Development Interview Questions Syllabus

1. SSH (Secure Shell)
● Explain what SSH is and how it differs from traditional virtualization.
● Describe the key components of SSH and how they interact with each other.
● Discuss the process of setting up an SSH server on a Linux machine.

2. Docker
● Understand what Docker is and its role in DevOps.
● Explain container orchestration and how Docker works.
● Describe the steps of the Docker workflow (write, plan, apply).

3. Kubernetes
 ● Define Kubernetes and its architecture.
● Explain the concept of container orchestration.
● Discuss Kubernetes components, such as pods, services, and deployments.

4. Terraform
● Understand Infrastructure as Code (IaC) and Terraform’s role.
● Describe Terraform providers and where to find documentation.
● Explain the declarative approach used in Terraform.

5. Public and Private Keys

● Explain the difference between public and private keys.
● Discuss their role in secure communication and authentication.

6. TCP and UDP

● Compare and contrast TCP (Transmission Control Protocol) and UDP (User
Datagram Protocol).
● Understand their use cases and differences in reliability.

7. Three-Way Handshake
● Describe the three-way handshake process in TCP.
● Explain how it establishes a connection between a client and a server.

8. Cron Jobs
● Define cron jobs and their purpose.
● Explain how to schedule recurring tasks using cron syntax.

9. Queue Systems
● Understand the concept of message queues.
● Describe popular queue systems (e.g., RabbitMQ, Kafka) and their use cases.

10. Pagination with and without Cursor

- Explain pagination techniques in web applications.
- Compare and contrast pagination with cursor-based pagination.

11. Authentication and Authorization

- Define authentication and authorization.
- Discuss common authentication methods (e.g., OAuth, JWT) and authorization
mechanisms (e.g., RBAC, ACL).

12. SOLID Principles

- Describe the SOLID principles (Single Responsibility, Open/Closed, Liskov
Substitution, Interface Segregation, Dependency Inversion).
- Explain how they enhance code quality and maintainability.