Wipro Infrastructure Engineering Full Stack Developer Interview Questions and Answers

The virtual DOM in React optimizes rendering by minimizing direct manipulation of the actual DOM, enhancing performance.

• The virtual DOM is a lightweight copy of the actual DOM, allowing React to manage changes efficiently.

• When a component's state changes, React creates a new virtual DOM tree and compares it with the previous one using a process called 'reconciliation'.

• Only the differences (or 'diffs') between the old a...read more

Routing in Express and Flask involves defining URL patterns and associating them with specific functions to handle requests.

• In Express, use 'app.get()', 'app.post()', etc., to define routes. Example: app.get('/users', (req, res) => { ... });

• Flask uses the '@app.route()' decorator to define routes. Example: @app.route('/users', methods=['GET']) def get_users(): ...

• Both frameworks support route parameters. Example in ...read more

I utilize various techniques like code splitting, caching, and optimizing assets to enhance application performance.

• Code Splitting: Load only necessary JavaScript for the current view, improving initial load time. Example: Using React's lazy loading.

• Caching: Implement browser caching and server-side caching to reduce load times. Example: Using Redis for caching API responses.

• Image Optimization: Compress images and use ...read more

Faced a challenge with team communication during a project, leading to delays and misalignment on tasks.

• Team members were using different tools for communication, causing confusion.

• I initiated a daily stand-up meeting to align everyone's tasks and progress.

• Implemented a shared project management tool (like Trello) to track tasks.

• Encouraged open feedback sessions to address any issues promptly.

Implementing security measures in full stack applications is crucial to protect data and maintain user trust.

• Use HTTPS to encrypt data in transit, preventing eavesdropping.

• Implement authentication and authorization using JWT or OAuth.

• Sanitize user inputs to prevent SQL injection and XSS attacks.

• Regularly update dependencies to patch known vulnerabilities.

• Use environment variables to manage sensitive information like AP...read more

Routing in Express and Flask involves defining endpoints to handle requests and responses effectively.

• In Express, use 'app.get()', 'app.post()', etc., to define routes. Example: app.get('/users', (req, res) => { ... });

• Flask uses decorators to define routes. Example: @app.route('/users', methods=['GET']) def get_users(): ...

• Organize routes in separate files for maintainability. In Express, use 'express.Router()' to ...read more

Frontend and backend communicate via APIs, protocols, and data formats to exchange information and perform actions.

• 1. RESTful APIs: Frontend makes HTTP requests to backend endpoints (e.g., GET, POST) to retrieve or send data.

• 2. GraphQL: A query language for APIs that allows clients to request specific data, reducing over-fetching.

• 3. WebSockets: Enables real-time communication between frontend and backend, useful for ch...read more

CRUD operations in MongoDB involve creating, reading, updating, and deleting documents in a collection.

• 1. Create: Use `db.collection.insertOne()` or `db.collection.insertMany()` to add documents. Example: `db.users.insertOne({ name: 'John', age: 30 })`.

• 2. Read: Use `db.collection.find()` to retrieve documents. Example: `db.users.find({ age: { $gt: 25 } })`.

• 3. Update: Use `db.collection.updateOne()` or `db.collection.up...read more

MongoDB uses a flexible document model and a binary format for efficient data storage and retrieval.

• Data is stored in BSON format, which is a binary representation of JSON-like documents.

• Documents are organized into collections, allowing for dynamic schemas.

• MongoDB uses a storage engine (like WiredTiger) that supports compression and efficient data access.

• Indexes can be created on fields to improve query performance, e...read more

Form validation in HTML and React ensures user input is correct and enhances user experience.

• HTML5 provides built-in validation attributes like 'required', 'minlength', and 'pattern'. Example: <input type='text' required />.

• In React, manage form state using 'useState' for controlled components. Example: const [name, setName] = useState('');

• Use 'onChange' event to validate input in real-time. Example: <input va...read more

Indexes in MongoDB enhance query performance by allowing faster data retrieval.

• Indexes are data structures that improve the speed of data retrieval operations.

• They work similarly to an index in a book, allowing quick access to specific data.

• MongoDB supports various types of indexes, including single field, compound, and geospatial indexes.

• For example, a single field index on 'username' allows quick searches for users b...read more

The MERN stack is a JavaScript-based framework for building web applications using MongoDB, Express.js, React, and Node.js.

• MongoDB: A NoSQL database that stores data in flexible, JSON-like documents. Example: Storing user profiles.

• Express.js: A web application framework for Node.js that simplifies server-side development. Example: Creating RESTful APIs.

• React: A front-end library for building user interfaces, allowing f...read more

I use Git for version control and CI/CD tools like Jenkins and Docker for deployment, ensuring efficient collaboration and automation.

• Git: A distributed version control system that allows multiple developers to work on a project simultaneously.

• GitHub: A platform for hosting Git repositories, enabling collaboration and code review.

• Jenkins: An open-source automation server that helps automate the deployment process throu...read more

Mongoose is an ODM library for MongoDB and Node.js, simplifying data modeling and validation.

• Mongoose provides a schema-based solution to model application data.

• It allows for easy validation of data before saving it to the database.

• Mongoose supports middleware, enabling pre and post hooks for operations like save and remove.

• Example: Defining a schema for a user model with fields like name and email.

• Mongoose enables que...read more

Indexes in MongoDB enhance query performance by allowing faster data retrieval.

• Indexes are data structures that improve the speed of data retrieval operations.

• They work similarly to an index in a book, allowing quick access to specific data.

• MongoDB supports various types of indexes, including single field, compound, and geospatial indexes.

• For example, creating an index on a 'username' field allows faster searches for u...read more

SQL databases are structured and relational, while NoSQL databases are flexible and non-relational.

• SQL databases use structured query language (e.g., MySQL, PostgreSQL).

• NoSQL databases are schema-less and can store unstructured data (e.g., MongoDB, Cassandra).

• SQL databases are ideal for complex queries and transactions.

• NoSQL databases excel in scalability and handling large volumes of data.

• SQL databases enforce ACID pr...read more

REST and GraphQL are two different approaches for building APIs, each with unique characteristics and use cases.

• REST uses fixed endpoints for resources, while GraphQL uses a single endpoint for all queries.

• In REST, the server defines the structure of responses, whereas in GraphQL, clients specify the structure of the response they need.

• REST typically returns a fixed data structure, which can lead to over-fetching or un...read more

I implement secure authentication and authorization using tokens, role-based access, and best practices for data protection.

• Use JWT (JSON Web Tokens) for stateless authentication, allowing users to log in and receive a token for subsequent requests.

• Implement OAuth 2.0 for third-party authentication, enabling users to log in using services like Google or Facebook.

• Utilize role-based access control (RBAC) to define user r...read more

Middleware in Express.js processes requests and responses, enabling functionalities like logging, authentication, and error handling.

• Middleware functions are functions that have access to the request, response, and next middleware function.

• They can modify the request and response objects, end the request-response cycle, or call the next middleware function.

• Common use cases include logging requests, parsing request bodi...read more

Synchronous programming executes tasks sequentially, while asynchronous programming allows tasks to run concurrently, improving efficiency.

• Synchronous programming blocks execution until a task completes, e.g., reading a file.

• Asynchronous programming allows other tasks to run while waiting, e.g., fetching data from an API.

• In synchronous code, functions return results immediately; in asynchronous code, they return promis...read more

The CSS box model describes the rectangular boxes generated for elements, including content, padding, border, and margin.

• Content: The innermost part where text and images appear. Example: width and height properties define the size.

• Padding: Space between the content and the border. Example: padding: 10px adds space around the content.

• Border: A line surrounding the padding (if any) and content. Example: border: 1px soli...read more

Promises and async/await are JavaScript features for handling asynchronous operations more effectively.

• A promise is an object representing the eventual completion or failure of an asynchronous operation.

• Promises have three states: pending, fulfilled, and rejected.

• Example of a promise: const myPromise = new Promise((resolve, reject) => { /* async code */ });

• Async/await is syntactic sugar built on top of promises, mak...read more

Media queries are CSS techniques that enable responsive design by applying styles based on device characteristics.

• Media queries allow you to apply different styles for different screen sizes.

• Example: `@media (max-width: 600px) { body { background-color: lightblue; } }`

• They can target various features like width, height, orientation, and resolution.

• Example: `@media (orientation: portrait) { /* styles for portrait mode *...read more

var, let, and const are used for variable declaration in JavaScript, differing in scope, hoisting, and mutability.

• var is function-scoped or globally scoped, while let and const are block-scoped.

• let allows variable reassignment, whereas const does not allow reassignment after declaration.

• Variables declared with var are hoisted, meaning they can be used before their declaration, while let and const are not hoisted in the...read more

I employ various testing methods including unit, integration, and end-to-end testing to ensure application reliability and performance.

• Unit Testing: Testing individual components, e.g., using Jest for React components.

• Integration Testing: Ensuring different modules work together, e.g., using Mocha to test API endpoints.

• End-to-End Testing: Simulating user interactions, e.g., using Cypress to test the entire user flow.

• Pe...read more

Web applications face various security vulnerabilities that can compromise data integrity and user privacy.

• SQL Injection: Attackers can manipulate SQL queries to access or modify database data. Example: 'OR 1=1' in a login form.

• Cross-Site Scripting (XSS): Malicious scripts are injected into web pages viewed by users. Example: A comment section allowing HTML input.

• Cross-Site Request Forgery (CSRF): Users are tricked int...read more

I optimize performance by analyzing bottlenecks, using efficient algorithms, and leveraging caching strategies in both frontend and backend.

• Use lazy loading for images and components to reduce initial load time.

• Implement code splitting in frontend frameworks like React to load only necessary code.

• Optimize database queries by using indexing and avoiding N+1 query problems.

• Utilize server-side caching (e.g., Redis) to red...read more

Managing state in a full-stack application involves techniques for both client-side and server-side data handling.

• Use React's useState and useEffect hooks for local component state management.

• Implement Redux or Context API for global state management in React applications.

• On the server side, use session management (e.g., Express sessions) to maintain user state.

• Utilize databases (e.g., MongoDB, PostgreSQL) to persist a...read more

Client-side rendering (CSR) loads content in the browser, while server-side rendering (SSR) generates HTML on the server.

• CSR fetches data via APIs after the initial page load, e.g., React apps.

• SSR sends fully rendered HTML to the client, improving SEO, e.g., Next.js.

• CSR can lead to faster interactions after the initial load but may have slower first-page load times.

• SSR can improve performance for users with slower devi...read more

I implement various security measures to protect applications from vulnerabilities and attacks.

• Use HTTPS to encrypt data in transit, preventing eavesdropping.

• Implement input validation to prevent SQL injection and XSS attacks.

• Utilize authentication and authorization mechanisms, such as OAuth2.

• Regularly update dependencies to patch known vulnerabilities.

• Conduct security audits and penetration testing to identify weaknes...read more

Securing sensitive data involves encryption, access controls, and regular audits to protect against unauthorized access.

• Use encryption for data at rest and in transit (e.g., AES for storage, TLS for communication).

• Implement strong access controls and authentication mechanisms (e.g., OAuth, JWT).

• Regularly update and patch software to mitigate vulnerabilities.

• Conduct security audits and penetration testing to identify we...read more

Utilizing .env files helps manage environment variables securely and efficiently in development and production environments.

• Store sensitive information like API keys and database credentials in .env files to avoid hardcoding them in the source code.

• Use a library like dotenv in Node.js to load environment variables from the .env file into process.env.

• Example: In a .env file, you might have 'DB_HOST=localhost' and in you...read more

CI/CD are practices that automate software development processes, enhancing code quality and deployment speed.

• Continuous Integration (CI) involves automatically testing and merging code changes into a shared repository.

• Continuous Deployment (CD) automates the release of code changes to production after passing tests.

• CI/CD helps catch bugs early, reducing integration issues and improving collaboration among developers.

• T...read more

Deploying a full stack application involves several key steps from development to production.

• 1. Development: Build the application using front-end and back-end technologies (e.g., React for front-end, Node.js for back-end).

• 2. Testing: Conduct unit tests, integration tests, and user acceptance tests to ensure functionality and performance.

• 3. Build: Compile the application code and assets into a production-ready format (...read more

Version control is a system that records changes to files, allowing collaboration and tracking of project history. Git is a popular tool for this.

• Git allows multiple developers to work on the same project simultaneously without conflicts.

• Using branches in Git, I can develop features independently, e.g., creating a 'feature/login' branch for a new login feature.

• I utilize Git commands like 'commit' to save changes, 'push...read more

ACID properties ensure reliable processing of database transactions, maintaining data integrity and consistency.

• Atomicity: Transactions are all-or-nothing. Example: If a bank transfer fails, no money is deducted or added.

• Consistency: Transactions bring the database from one valid state to another. Example: A transaction must not violate any database rules.

• Isolation: Transactions occur independently. Example: Two transa...read more

Aggregation in MongoDB processes data records and returns computed results, enabling complex data analysis.

• Aggregation framework allows for operations like filtering, grouping, and sorting data.

• Common stages include $match (filtering), $group (grouping), and $sort (sorting).

• Example: To find the total sales per product, use $group to sum sales by product ID.

• Aggregation pipelines can be nested, allowing for advanced data...read more

Schema validation in MongoDB ensures data integrity and consistency using various methods and tools.

• Use Mongoose for schema definition: Mongoose allows you to define schemas with validation rules. Example: const userSchema = new mongoose.Schema({ name: { type: String, required: true } });

• Implement JSON Schema validation: MongoDB supports JSON Schema for validation. Example: db.createCollection('users', { validator: { $...read more

Primary keys uniquely identify records in a table, while foreign keys establish relationships between tables.

• A primary key is a unique identifier for a record in a table, e.g., 'user_id' in a 'Users' table.

• A foreign key is a field that links to the primary key of another table, e.g., 'user_id' in an 'Orders' table referencing 'Users'.

• Primary keys cannot contain NULL values and must be unique across the table.

• Foreign ke...read more

Status codes indicate the result of an HTTP request, helping clients understand the response from the server.

• 200 OK: The request was successful, and the server returned the requested data.

• 404 Not Found: The server could not find the requested resource, indicating that the URL is incorrect or the resource is missing.

• 500 Internal Server Error: The server encountered an unexpected condition that prevented it from fulfilli...read more

JSON Web Tokens (JWT) are compact, URL-safe tokens used for secure information exchange between parties.

• JWTs consist of three parts: Header, Payload, and Signature.

• Header typically contains the type of token (JWT) and the signing algorithm (e.g., HMAC SHA256).

• Payload contains claims, which are statements about an entity (usually the user) and additional data.

• Signature is created by combining the encoded header, encoded...read more

Handle file uploads in Express.js using middleware like multer for easy processing and storage.

• Use multer middleware to handle multipart/form-data, which is used for file uploads.

• Install multer: `npm install multer`.

• Set up multer in your Express app: `const multer = require('multer'); const upload = multer({ dest: 'uploads/' });`.

• Create a route for file uploads: `app.post('/upload', upload.single('file'), (req, res) =&...read more

PUT replaces the entire resource, while PATCH updates only specific fields of a resource.

• PUT is idempotent, meaning multiple identical requests have the same effect as a single request.

• PATCH is used for partial updates, allowing changes to specific fields without affecting the entire resource.

• Example of PUT: Sending a complete user object to update a user profile.

• Example of PATCH: Sending only the email field to update...read more

RESTful APIs are web services that follow REST principles, enabling communication between client and server using standard HTTP methods.

• REST stands for Representational State Transfer, a software architectural style.

• Uses standard HTTP methods: GET (retrieve), POST (create), PUT (update), DELETE (remove).

• Resources are identified by URIs (Uniform Resource Identifiers), e.g., /users/123.

• Stateless interactions: each reques...read more