Inline elements: Do not start on a new line and only take as much width as necessary. Examples: <span>, <a>, <img>.

Block elements: Start on a new line and take the full width available. Examples: <div>, <p>, <h1>.

Inline-block elements: Flow like inline elements but allow setting width and height. Examples: <button>, <input>.

== (Loose equality): Compares values after type coercion. It converts both values to the same type before comparison.

=== (Strict equality): Compares both value and type. No type coercion is performed.

Example: 5 == '5' returns true (type coercion), while 5 === '5' returns false (different types).

Best practice: Always use === to avoid unexpected behavior from type coercion.

The Virtual DOM is a lightweight JavaScript representation of the actual DOM. React uses it to improve performance.

How it works:

• When state changes, React creates a new virtual DOM tree.
• React compares the new virtual DOM with the previous one (diffing).
• React updates only the changed parts in the actual DOM (reconciliation).

Benefit: Minimizes expensive DOM manipulations, making React apps faster and more efficient.

var: Function-scoped, can be re-declared and updated. Hoisted to the top of its scope.

let: Block-scoped, can be updated but not re-declared. Not hoisted in the same way as var.

const: Block-scoped, cannot be re-declared or updated. Must be initialized at declaration.

Best practice: Use const by default, use let when you need to reassign, avoid var.

Node.js is a JavaScript runtime built on Chrome's V8 engine. It allows JavaScript to run on the server side.

Key features:

• Non-blocking I/O: Handles multiple requests efficiently without blocking the main thread.
• Event-driven: Uses an event loop to handle asynchronous operations.
• Single-threaded: Uses a single thread but handles concurrency through the event loop.

Example: Node.js is ideal for building scalable APIs and real-time applications.

SQL (Relational):

• Structured, table-based
• ACID compliant (Atomicity, Consistency, Isolation, Durability)
• Predefined schema
• Examples: MySQL, PostgreSQL

NoSQL (Non-relational):

• Unstructured, document-based
• BASE compliant (Basically Available, Soft state, Eventual consistency)
• Dynamic schema
• Examples: MongoDB, Cassandra

When to use: SQL for complex queries and transactions, NoSQL for scalability and unstructured data.

REST API (Representational State Transfer) is an architectural style for building web services. It uses HTTP methods to perform CRUD operations.

Core principles:

• Stateless: Each request contains all information needed to process it.
• Client-Server: Separation of concerns between client and server.
• Uniform Interface: Consistent API design (GET, POST, PUT, DELETE).
• Resource-based: Resources are identified by URLs.
• Representation: Resources are returned in formats like JSON or XML.

Example: GET /api/users returns all users.

Methods to connect React to Node.js:

• Fetch API: Use fetch() to make HTTP requests to the backend.
• Axios: A popular library for making HTTP requests.
• WebSocket: For real-time bidirectional communication.

Example:

// React component fetching data from Node.js API
fetch('http://localhost:5000/api/users')
  .then(response => response.json())
  .then(data => setUsers(data));

Authentication is the process of verifying a user's identity. Common methods include:

• JWT (JSON Web Tokens): Stateless authentication using tokens.
• Session-based: Using cookies and server-side sessions.
• OAuth: Third-party authentication (Google, Facebook).

JWT flow:

• User logs in with credentials
• Server validates and creates a JWT
• Client stores the JWT and includes it in future requests
• Server validates the JWT on each protected route

MVC (Model-View-Controller) is an architectural pattern:

• Model: Data and business logic (database)
• View: User interface (frontend)
• Controller: Handles user input and updates the model

MERN is a specific technology stack:

• MongoDB: Database
• Express.js: Backend framework
• React: Frontend library
• Node.js: Runtime environment

Key difference: MVC is an architectural pattern, while MERN is a specific tech stack that implements MVC principles.

JavaScript is the most important skill. It's used in both frontend (React, Angular) and backend (Node.js). Strong JavaScript fundamentals are essential.

Practice coding problems, build portfolio projects, review HTML/CSS/JavaScript fundamentals, and practice behavioral questions. Mock interviews are also very helpful.

Be honest and say "I don't know, but here's how I would approach it." Show your problem-solving process — interviewers value this more than a perfect answer.

Yes — bring your laptop and be ready to show 1-2 projects. Walk through your process, challenges, and results. This is often more impressive than a perfect answer to a question.