Full Stack Interview Questions for Freshers

1. Explain how promises work in JavaScript.

A promise in JavaScript represents the eventual result of an asynchronous operation. It can be in one of three states: pending, fulfilled, or rejected. Promises allow for chaining .then() and .catch() methods to handle asynchronous code more cleanly than callbacks.

2. What is Docker, and how is it used in full stack development?

Docker is a platform that uses containers to package an application with all its dependencies, ensuring consistency across different environments. Developers use Docker to create isolated environments for applications, making it easier to develop, test, and deploy code.

3. What is the difference between localStorage and sessionStorage in JavaScript?

Both are part of the Web Storage API:

localStorage stores data with no expiration date, meaning it persists even after the browser is closed.
sessionStorage stores data for a single session (until the browser or tab is closed).

4. Explain the difference between SQL JOINs (INNER, LEFT, RIGHT, FULL)

INNER JOIN: Returns records that have matching values in both tables.
LEFT JOIN: Returns all records from the left table and matched records from the right table.
RIGHT JOIN: Returns all records from the right table and matched records from the left table.
FULL JOIN: Returns all records when there is a match in either the left or right table.

5. Explain CSRF and how to prevent it.

CSRF (Cross-Site Request Forgery) is an attack where unauthorized commands are sent from a user that the website trusts. It can be prevented by:

Using anti-CSRF tokens.
Setting SameSite attribute for cookies.
Requiring re-authentication for sensitive actions.

6. How do you ensure security in a full stack application?

Key security practices include:

Implementing authentication and authorization.
Protecting against SQL injection and XSS.
Using SSL/TLS for HTTPS.
Applying CORS policies.
Sanitizing inputs and encoding outputs.

7. How would you optimize a slow SQL query?

Use indexes to speed up search queries.
Avoid SELECT *, only select necessary columns.
Use EXPLAIN to understand how the query is being executed.
Minimize the use of subqueries, prefer JOINs when applicable.
Optimize database schema (e.g., normalize or denormalize as needed).

8. How would you approach integrating third-party services (like payment gateways) into your application?

Start by understanding the API documentation of the third-party service, ensuring that you have the required authentication mechanisms (e.g., API keys, OAuth tokens) in place.
Use webhooks provided by the service to handle real-time events like payment confirmations or failed transactions.
Ensure that the integration is secure by using HTTPS, validating responses from the third-party service, and avoiding sensitive data exposure (e.g., encrypt credit card information).

9. Implement bubble sort in JavaScript.

10. Write a Python function to check if a linked list has a cycle.

def hasCycle(head): slow, fast = head, head while fast and fast.next: slow = slow.next fast = fast.next.next if slow == fast: return True return False

11. Create a basic authentication middleware in Express (Node.js).

12. Write a function to remove duplicates from an array in JavaScript.

function removeDuplicates(arr) { return […new Set(arr)]; } console.log(removeDuplicates([1, 2, 2, 3, 4, 4]));

13. Find the longest word in a string using JavaScript.

function longestWord(str) { let words = str.split(‘ ‘); return words.reduce((longest, word) => word.length > longest.length ? word : longest, “”); } console.log(longestWord(“Full stack developer interview questions”)); /

14. How to create a basic form validation in React??

15. How to find the depth of a binary tree in Python?

class Node: def __init__(self, value): self.left = None self.right = None self.value = value def maxDepth(node): if node is None: return 0 else: left_depth = maxDepth(node.left) right_depth = maxDepth(node.right) return max(left_depth, right_depth) + 1

16. Merge two sorted arrays in JavaScript.

function mergeSortedArrays(arr1, arr2) { return […arr1, …arr2].sort((a, b) => a – b); } console.log(mergeSortedArrays([1, 3, 5], [2, 4, 6]));

17. How to make an HTTP GET request in React using fetch?

useEffect(() => { fetch(‘https://api.example.com/data’) .then(response => response.json()) .then(data => console.log(data)) .catch(error => console.error(‘Error fetching data:’, error)); }, []);

18. Write a Python function to check if a linked list has a cycle.

def hasCycle(head): slow, fast = head, head while fast and fast.next: slow = slow.next fast = fast.next.next if slow == fast: return True return False

19. Create a basic authentication middleware in Express (Node.js).

20. Create a simple Todo App in React.

21. Create a function that returns the Fibonacci sequence up to n in Python.

def fibonacci(n): sequence = [0, 1] while len(sequence) < n: sequence.append(sequence[-1] + sequence[-2]) return sequence[:n] print(fibonacci(5))

22. Write a program to implement a stack in JavaScript.

class Stack { constructor() { this.items = []; } push(element) { this.items.push(element); } pop() { return this.items.pop(); } peek() { return this.items[this.items.length – 1]; } isEmpty() { return this.items.length === 0; } }

23. Write a function to check if two strings are anagrams in JavaScript.

function areAnagrams(str1, str2) { const format = str => str.replace(/[^\w]/g, ”).toLowerCase().split(”).sort().join(”); return format(str1) === format(str2); } console.log(areAnagrams(“listen”, “silent”));

24. Write a SQL query to fetch the second-highest salary from an “employees” table.

SELECT MAX(salary) FROM employees WHERE salary < (SELECT MAX(salary) FROM employees);

25. Implement a basic REST API with Express (Node.js).

26. Specify some performance optimization techniques for web applications?

Minify and compress assets like CSS, JavaScript, and images.
Lazy load images and resources.
Use caching (browser caching, server-side caching).
Implement Content Delivery Networks (CDNs).
Optimize database queries (using indexes, avoiding N+1 queries).
Reduce HTTP requests by bundling assets with tools like Webpack.

27. How does GraphQL differ from REST?

GraphQL is a query language for APIs that allows clients to request only the data they need. Unlike REST, which exposes multiple endpoints for different resources, GraphQL uses a single endpoint where clients specify the structure of the response. This reduces over-fetching and under-fetching of data.

28. How do you handle file uploads in a full stack application?

File uploads are typically handled by:

Setting up an HTML form with the enctype=”multipart/form-data” attribute.
Using middleware like multer in Node.js to process file uploads.
Storing the files either in the file system or in cloud storage (e.g., AWS S3).

29. How can Cross-Site Scripting (XSS), be prevented?

XSS is a security vulnerability that allows attackers to inject malicious scripts into web pages viewed by others. It can be prevented by:

Escaping user input to prevent the execution of malicious code.
Using Content Security Policy (CSP).
Validating and sanitizing inputs.

30. What are the main benefits of using TypeScript in full stack development?

TypeScript provides static type checking, allowing developers to catch errors at compile-time rather than runtime. It enhances code quality, improves readability, and helps with better tooling (autocomplete, refactoring) and large-scale application maintainability.

31. Why Node.js is popular for full stack development?

Node.js is a JavaScript runtime that allows developers to write server-side code using JavaScript. Its event-driven, non-blocking I/O model makes it efficient and scalable, which is ideal for building fast and scalable network applications like APIs and real-time services.

32. What are some common HTTP status codes and their meanings?

200 OK: The request was successful.
201 Created: The request was successful and a resource was created.
400 Bad Request: The request was malformed or invalid.
401 Unauthorized: Authentication is required or has failed.
404 Not Found: The requested resource was not found.
500 Internal Server Error: The server encountered an error.

33. How would you optimize a REST API for performance?

Enable caching using HTTP headers (like Cache-Control) and external caching layers (e.g., Redis) to reduce the number of requests hitting the server.
Use pagination, filtering, and sorting to limit the amount of data returned in each request, especially for large datasets.
Implement compression (e.g., Gzip) to reduce the size of the responses sent over the network. Optimize database queries with indexing, query optimization, and avoiding N+1 query problems.

34. Build a web application that allows users to upload images, and you want to store the images efficiently and make them available across different regions. How would you design this?

Use a cloud storage service like AWS S3, Google Cloud Storage, or Azure Blob Storage to store the images.
Store metadata (e.g., file name, upload date) in a database (SQL or NoSQL) for easy querying.
To improve performance and availability in different regions, use a Content Delivery Network (CDN) to cache and deliver images to users based on their location.
Ensure image validation (size, type) and security by scanning uploads for malicious content.
Implement lazy loading to improve the performance of pages with many images.

35. How does AJAX work?

AJAX (Asynchronous JavaScript and XML) is a technique that allows web pages to update asynchronously by exchanging data with a web server in the background, without reloading the entire page. It is often used with JavaScript to dynamically update parts of a web page.

36. Optimize the performance of a web application that’s getting slower as more users are added. What steps would you take?

Analyze server performance using monitoring tools (like New Relic or Google Lighthouse) to identify bottlenecks.
Use caching (e.g., Redis or Memcached) for frequently accessed data to reduce database load.
Implement lazy loading for images, scripts, or other large resources.
Use pagination for displaying large datasets rather than loading all records at once.
Ensure that the frontend is efficient, using techniques like code splitting and tree shaking.

37. How JSON is used?

JSON (JavaScript Object Notation) is a lightweight data format used for storing and transporting data. It is easy for both humans and machines to read and write. It is commonly used in APIs to send and receive data between a client and server.

38. What is the difference between SQL and NoSQL databases?

SQL databases are relational, structured with predefined schemas, and use SQL (Structured Query Language) for defining and manipulating data.

NoSQL databases are non-relational, schema-less, and handle unstructured or semi-structured data. They are scalable and flexible, often used for big data or real-time web apps.

39. Implementation of a new feature causes an unexpected bug in a different part of the application. How do you handle this?

Reproduce the bug to understand the scope and root cause.
Check the version control history (e.g., git log) to identify the commit that introduced the issue.
Write unit tests for the affected feature and the area where the bug appeared to avoid future regressions.
Fix the bug and test the entire feature again using integration tests and manual testing.
Deploy the fix, ensuring that it passes staging and pre-production testing.

40. How would you approach integrating third-party services (like payment gateways) into your application?

Start by understanding the API documentation of the third-party service, ensuring that you have the required authentication mechanisms (e.g., API keys, OAuth tokens) in place.
Use webhooks provided by the service to handle real-time events like payment confirmations or failed transactions.
Ensure that the integration is secure by using HTTPS, validating responses from the third-party service, and avoiding sensitive data exposure (e.g., encrypt credit card information).

41. How would you handle error logging and monitoring in a full stack application?

For frontend errors, use tools like Sentry or LogRocket to capture and log JavaScript errors, including user interactions that led to the error.
On the backend, set up logging with a framework like Winston for Node.js or Log4j for Java, and use centralized logging tools like ELK Stack (Elasticsearch, Logstash, Kibana) or Graylog for aggregated logs.
Set up real-time monitoring with tools like Prometheus and Grafana to track server performance and alert for issues like high CPU usage or memory leaks.

42. What are the pros and cons of using a monolithic architecture?

Monolithic Architecture:

Pros:

Easier to develop and deploy initially, as everything is in one codebase. Simple to test, debug, and deploy in smaller projects.

Cons:

Harder to scale individual components.
As the application grows, it can become difficult to maintain and update.
A single failure in one component could bring down the entire application.

43. When your team is experiencing frequent merge conflicts during development. What strategies can you employ to reduce merge conflicts?

Use feature branches to isolate new features and prevent multiple developers from working on the same code.
Encourage smaller, more frequent commits with pull requests to keep code changes manageable and easier to review.
Communicate effectively with the team to avoid working on the same files or modules simultaneously.
Implement code linters and formatting tools like ESLint or Prettier to standardize the code style across the team.
Conduct regular merges from the main or develop branch into feature branches to keep them up to date with the latest changes.

44. The product owner requests a new feature that could significantly affect system performance if not implemented correctly. How do you approach this?

Begin by understanding the requirements fully and breaking them down into smaller tasks.
Identify potential performance bottlenecks early (e.g., high data loads, complex queries, etc.).
Use a proof of concept to test the feasibility of different approaches.
Apply best practices for performance, such as using efficient algorithms, caching, and load balancing.
Perform load testing using tools like JMeter to ensure the feature scales well under high traffic.
Continually profile and monitor the feature in production for any performance issues.

45. A security vulnerability (e.g., SQL injection, XSS) is reported in your application. How do you address it?

Investigate the vulnerability by replicating the issue to understand its impact.

Apply fixes based on the type of vulnerability:

For SQL Injection, use parameterized queries or ORMs that handle query building safely.
For XSS, sanitize and validate user input and use frameworks that automatically escape output.
Implement additional security measures like Content Security Policy (CSP) and input validation.
Add automated security testing to your CI/CD pipeline, using tools like OWASP ZAP or SonarQube.
Educate the team on secure coding practices to prevent future vulnerabilities.

46. When your application’s backend experiences a sudden increase in traffic, causing high CPU usage and slower response times. How do you handle this?

First, implement auto-scaling for your infrastructure (e.g., AWS EC2 Auto Scaling, Kubernetes) to handle sudden traffic spikes.
Review logs and monitoring tools (e.g., Grafana, Datadog) to pinpoint the bottleneck (e.g., CPU, memory, database).
Use load balancers (e.g., NGINX, AWS Elastic Load Balancing) to distribute traffic across multiple servers.
Consider using caching strategies (e.g., Redis) for frequently accessed data to reduce database load.
If needed, refactor code to improve efficiency, e.g., optimizing long-running operations or improving database queries.

47. Design a web application that provides a real-time chat feature. How would you implement it?

Use WebSockets to enable two-way real-time communication between clients and the server.
For the server, use Node.js with Socket.IO to handle real-time events.
Store chat history in a NoSQL database like MongoDB, which is well-suited for handling large amounts of unstructured data.
Implement user authentication using JWT tokens to secure the chat system.
Scale the system using a pub/sub model (e.g., Redis) to handle real-time messaging across distributed nodes.

48. To refactor a legacy codebase to improve maintainability and scalability, What steps would you take?

Analyze the existing code to understand its architecture, dependencies, and problem areas.
Break the monolithic application into microservices, separating concerns (e.g., user management, billing, etc.).
Apply code reviews and introduce unit tests to ensure that changes do not break functionality.
Improve the modularization of code, ensuring that each module has clear responsibilities and minimal dependencies.
Document the code as you refactor, providing clear guidance for future developers.
Gradually migrate to newer technologies or frameworks if needed, to improve scalability and maintainability.

49. The frontend of your application is experiencing performance issues, particularly with rendering large datasets. How would you improve the performance?

Implement pagination or infinite scrolling to only load a subset of data at a time.
Use virtualization libraries like React Virtualized to efficiently render large lists by only rendering visible items.
Optimize the application with lazy loading and code splitting to load only the necessary components.
Reduce the number of DOM elements and use efficient state management (e.g., React’s useReducer or Redux).
Use memoization (e.g., React’s useMemo, React.memo) to prevent unnecessary re-renders of components.

50. How do you manage authentication and authorization in a full stack application?

For authentication, use standards like OAuth2 or JWT (JSON Web Tokens) to verify user identity. JWTs are often used in stateless applications, where tokens are passed in HTTP headers.
For authorization, control user permissions based on roles (e.g., admin, user) or specific permissions for resources (e.g., file ownership). This can be managed in your backend with access control lists (ACLs) or using frameworks like Passport.js or Spring Security.

Request more information

Full Stack Interview Questions for Freshers