Advanced Full Stack Interview Questions

1. How would you ensure responsiveness in a web application?

Media Queries:

Use CSS media queries to apply styles based on device screen size.

@media (max-width: 768px) { .container { flex-direction: column; } }

Flexible Grids and Layouts:

Use percentage-based widths or CSS Grid and Flexbox to create responsive layouts.

2. How is Spring Boot different from Spring?

Spring Boot is a project built on top of the Spring Framework that simplifies the process of building Spring-based applications. Unlike traditional Spring applications, Spring Boot allows developers to create stand-alone applications with minimal configuration, thanks to its convention-over-configuration approach and embedded servers like Tomcat. It also provides opinionated defaults and the ability to package applications into executable JARs.

3. How do you deploy a full-stack application using Docker?

Create a Dockerfile for Each Service:

Each component of the application (front-end, back-end, database) should have its own Dockerfile.

Create a docker-compose.yml File:

Use Docker Compose to manage multi-container applications. Define services for the front-end, back-end, and database.

Build and Start the Containers:docker-compose up –build

Deployment:

Deploy the application to cloud platforms like AWS, Azure, or Google Cloud using Docker containers. Tools like Kubernetes can be used for container orchestration.

4. Explain the Error Handling for Async Functions

For async functions, you can use try-catch to handle errors:

app.get(‘/users’, async (req, res, next) => { try { const users = await User.find(); res.json(users); } catch (err) { next(err); } });

5. How do you handle error handling in Express.js?

Basic Error Handling:

In Express, you can define error-handling middleware by specifying four arguments (err, req, res, next).

app.use((err, req, res, next) => { console.error(err.stack); res.status(500).send(‘Something went wrong!’); });

6. How would you secure an API?

Authentication:

Use JWT or OAuth for securing endpoints. Each request to protected routes should carry an authentication token.

Example using JWT:

app.get(‘/secure-data’, authenticateToken, (req, res) => { res.json({ message: “Secure data” }); });

7. Explain about closures in JavaScript?

A closure is a function that remembers its lexical environment, even when the function is executed outside that environment. It allows inner functions to access variables defined in the outer function even after the outer function has returned.

Example:

function outer() { let counter = 0; return function increment() { counter++; return counter; }; } const incrementCounter = outer(); console.log(incrementCounter()); // 1 console.log(incrementCounter());

8. How would you optimize SQL queries in a full-stack application?

Use Indexes:

Create indexes on columns that are frequently used in WHERE clauses or join conditions to speed up data retrieval.

CREATE INDEX idx_user_email ON users(email);

*Avoid SELECT :

Only query the necessary columns instead of selecting all columns with SELECT *.

SELECT name, email FROM users WHERE id = 1;

9. Explain about Dependency Injection (DI) in Spring?

Dependency Injection (DI) is a design pattern in which an object (called the dependency) is passed to another object (called the dependent) instead of being created within the dependent object. In Spring, DI helps in decoupling objects and increasing the flexibility and testability of the code. Spring supports DI through constructor-based, setter-based, and field-based injections.

10. What are the challenges of implementing microservices, and how would you overcome them?

Service Discovery:

In microservices, services are distributed across multiple servers and may scale up or down dynamically. Finding the correct service instance can be a challenge.

Data Management:

Microservices often have their own databases, which can make managing transactions across services tricky.

Inter-service Communication:

Increased network communication can introduce latency and increase failure points.

Security:

Each microservice may expose an API, increasing the attack surface.

Monitoring and Debugging:

With multiple services running, it can be difficult to monitor and trace errors across the system.

11. How would you overcome the challenges of implementing microservices?

To keep track of service instances use a Service Discovery tool like Eureka (from Netflix), Consul, or Kubernetes DNS.

Manage distributed transactions and event-driven architectures using the Sagas pattern to ensure eventual consistency.

To handle service failures gracefully use circuit breakers, Implement retry logic and timeouts for resilience.

Implement OAuth2, JWT tokens, and API gateways for centralized security and access control.

Use distributed tracing tools like Jaeger or Zipkin and monitoring tools like Prometheus and Grafana.

12. How would you handle data consistency across microservices?

Maintaining data consistency in microservices can be challenging because each service typically has its own database. Some patterns to ensure consistency include:

Eventual Consistency:

In microservices, strong consistency (immediate consistency across all services) is difficult to achieve. Instead, services aim for eventual consistency. This means that changes are propagated across services over time, and the system will eventually become consistent.

Sagas Pattern:This pattern is used for managing distributed transactions. Each step in the transaction is handled by a separate service, and if one step fails, compensating transactions are executed to roll back the changes.

Two-Phase Commit (2PC):This is a protocol that ensures all services agree on a transaction before committing. It’s rarely used in microservices because it can become a bottleneck and doesn’t scale well.

13. State the difference between Microservices architecture, and Monolithic architecture?

Key Differences:

Monolithic Architecture:

Single, large codebase.
Tight coupling between components.
Hard to scale specific components individually.
Deployment involves updating the entire system, even for small changes.

Microservices Architecture:

The application is divided into independent services.
Services communicate via APIs or messaging.
Services can be developed, tested, and deployed independently.
Easier to scale specific parts of the application as needed.

14. How do Microservices communicate with each other, and what are some common patterns?

Microservices communicate primarily through API calls or message queues. Two common patterns for communication are:

Synchronous Communication (via REST APIs or gRPC)
Asynchronous Communication (via Messaging or Event Streaming)

15. State the advantages of API Gateway in Microservices architecture?

Advantages of an API Gateway:

Simplified Client Communication:

Instead of making multiple requests to different services, the client sends a single request to the API Gateway, which internally forwards the requests to the correct services.

Security: The API Gateway can handle authentication (e.g., OAuth2, JWT tokens) and enforce security policies, reducing the complexity of individual services.

Load Balancing: The API Gateway can distribute incoming requests across service instances, improving the scalability of the system.

Rate Limiting and Throttling: The API Gateway can apply rate-limiting rules to prevent overloading services and protect against DDoS attacks.

Centralized Logging and Monitoring: API Gateways provide a centralized point for logging all requests, which helps with monitoring, tracing, and debugging.

16. How do you resolve merge conflicts in Git?

Steps to resolve a merge conflict:

Identify the conflict:

When a conflict occurs, Git will pause the merge and mark the conflicted areas in the affected files. The conflicting sections will look like this:

<<<<<<< HEAD

Code from your current branch

=======

Code from the branch being merged in

>>>>>>> feature-branch

Edit the file(s):

Manually resolve the conflict by editing the file(s) to decide which changes to keep or how to combine them. After editing, remove the conflict markers (<<<<<<<, =======, and >>>>>>>).

Mark the conflict as resolved:

Once you’ve resolved the conflicts, stage the resolved file(s):

git add

Complete the merge:

After staging the files, complete the merge by committing the changes:

git commit

17. Specify the best practices to resolve merge conflicts in Git?

A merge conflict occurs when Git cannot automatically merge changes because two different commits modified the same part of a file in incompatible ways.

Best Practices:

Regularly pull and merge changes from the main branch to your feature branch to reduce the chances of large merge conflicts.

Use tools like git mergetool or IDEs with merge conflict resolution features (e.g., VS Code) to help visualize conflicts.

18. Mention the difference between git pull and git fetch?

git fetch:

Fetch downloads commits, files, and references from a remote repository into your local repository, but it does not automatically merge the changes into your working directory. It allows you to see the changes before deciding to integrate them.

Example:

git fetch origin

git pull:

Pull is essentially a combination of git fetch followed by git merge. It automatically downloads the changes from the remote repository and merges them into your current branch.

Example:

git pull origin main

19. Specify the difference and when to use git fetch and git pull

Key Differences:

git fetch: Fetches the data but does not merge it automatically, allowing you to review the changes.

git pull: Fetches the data and immediately merges it with your local branch.

When to use:

Use git fetch if you want to see the changes first or if you’re working on a long-lived feature branch to avoid unexpected merges.

Use git pull if you’re ready to integrate remote changes immediately.

20. Why is the Git branch important in version control?

Importance of branches:

Isolation of Work: Each branch works independently of the others, which means changes made in one branch do not interfere with the others until you decide to merge them.
Parallel Development: Multiple branches allow multiple developers or teams to work on different parts of the project at the same time without stepping on each other’s toes.
Safe Experimentation: Developers can experiment or implement a new feature on a separate branch and only merge it into the main branch once it’s tested and ready.

21. How does Git differ from other version control systems?

Differences from other version control systems:

Distributed Nature:

Unlike centralized systems like Subversion (SVN), Git is distributed, meaning every developer has a full copy of the repository, including its history. This allows working offline and makes collaboration easier.

Speed and Efficiency:

Git is faster than centralized systems since most operations (like commits, merges, and diffs) are done locally without needing to communicate with a remote server.

Branching and Merging:

Git makes branching and merging easier and more efficient. It encourages the use of branches for feature development, bug fixes, etc., and allows merging back into the main codebase without conflicts.

22. How to create a new Git branch?

A branch in Git is an independent line of development. It allows developers to diverge from the main codebase (usually the main or master branch) to work on new features, bug fixes, or experiments without affecting the stable code.

Example:

git branch feature-login

git checkout feature-login

This creates a new branch feature-login and switches to it, allowing you to work on the login feature without affecting the main branch.

23. What is the difference between git merge and git rebase? When would you use each?

git merge:

Merging takes the contents of a branch and integrates them into the target branch. It creates a new “merge commit” that combines the histories of both branches.

Example:

git checkout main

git merge feature-branch

git rebase:

Rebasing rewrites the commit history by moving your branch on top of another branch. Instead of creating a merge commit, git rebase reapplies your changes on top of the target branch latest commit.

Example:

git checkout feature-branch

git rebase main

24. When to use git merge and git rebase?

Use git merge when you want to preserve the complete history of both branches, including all commits made in the feature branch.

Use git rebase when you want a cleaner, linear commit history. It’s useful for keeping the commit history tidy, especially when working with long-lived feature branches.

25. What is database sharding, and when would you use it?

Answer: Database sharding is a technique of partitioning a large database into smaller, more manageable pieces called shards, each hosted on a different server. This allows for distributing the load and improves performance and scalability.

When to use:

When the database has grown too large to fit on a single server, or when query performance is suffering due to the size of the dataset.

High-traffic applications that need horizontal scaling (e.g., large social media platforms, e-commerce sites).

26. How do microservices benefit back-end architecture?

Benefits:

Independent Deployment: Services can be updated and deployed without affecting the entire system.

Scalability: Individual services can be scaled based on demand.

Resilience: Failure in one service doesn’t necessarily bring down the entire application.

Technology Diversity: Different services can be built with different technologies (e.g., Node.js for one, Java for another).

27. Explain the concept of caching in back-end systems and how it improves performance.

Caching is the process of storing frequently accessed data in a temporary storage layer (cache) so that future requests for that data can be served faster without querying the database or performing expensive computations.

Types of Caching:

In-memory caching: Using tools like Redis or Memcached to store data in memory.

Browser caching: Storing static resources (e.g., images, CSS) in the client’s browser.

28. How caching improves performance.

Reduced Latency: Cached data can be retrieved much faster compared to fetching it from the database or regenerating it.

Reduced Load on Back-end Systems: By serving cached data, the system avoids repeated processing and database hits, reducing server load and improving scalability.

29. Explain about load balancing?

Load balancing is the process of distributing incoming network traffic across multiple servers (or instances) to ensure no single server becomes overwhelmed. This increases the availability and reliability of the application.

Common Load Balancers:

Nginx, HAProxy, and cloud-based options like AWS Elastic Load Balancing.

30. Why load balancing is important in back-end systems?

Improved Scalability: As traffic increases, more servers can be added to handle the load.

Fault Tolerance: If one server goes down, the load balancer redirects traffic to other healthy servers, ensuring the application stays available.

Reduced Downtime: Load balancers help distribute the load, preventing any single server from overloading and crashing.

31. What are middleware functions in back-end development?

Middleware functions in back-end frameworks like Express.js are functions that have access to the request (req), response (res), and the next middleware function in the application’s request-response cycle.

Middleware can:

Process requests (e.g., authentication, logging, parsing data).

Terminate the request-response cycle or pass control to the next middleware function using next().

Example in Express.js:

app.use((req, res, next) => { console.log(‘Request Time:’, Date.now()); next(); // Pass control to the next handler });

32. How middleware functions are used in frameworks like Express.js?

Uses:

Authentication (checking tokens, credentials).
Logging requests.
Handling errors.
Parsing request bodies (e.g., body-parser middleware for JSON).

33. Specify the use cases for SQL and NoSQL databases.

SQL Databases:

Suitable for applications requiring complex queries, relationships between data (e.g., e-commerce systems with product, user, and order tables), and strict consistency.

NoSQL (Non-relational) Databases:

Used for applications requiring flexibility, high scalability, or dealing with large datasets (e.g., real-time analytics, social media platforms).

34. How does RESTful API work in a back-end system?

Stateless: Each API request from the client contains all the information needed to process it, meaning the server doesn’t store client state between requests.

Resource Identification via URLs: Resources (e.g., users, products) are identified by URLs. Example: /api/products/1 refers to the product with ID 1.

HTTP Methods:

GET: Retrieve data.
POST: Create new resources.
PUT/PATCH: Update resources.
DELETE: Delete resources.

35. What is the purpose of a web server in back-end development?

A web server serves client requests for web pages and resources, facilitating communication between the front-end and back-end of a web application. The server processes HTTP requests from clients (e.g., browsers) and returns appropriate responses, such as HTML, JSON, or other data formats.

Example web servers: Nginx, Apache, Express.js (Node.js).

36. What is the time complexity of searching, inserting, and deleting in a binary search tree (BST)?

Search, Insertion, Deletion (Average Case): O(log n)

In a balanced binary search tree (BST), each operation reduces the search space in half at each level, leading to logarithmic time complexity.

Search, Insertion, Deletion (Worst Case): O(n)

In the worst case, if the tree becomes unbalanced (e.g., all nodes are in a straight line), the operations may take linear time

37. How does hash table work?

A hash table is a data structure that maps keys to values using a hash function to compute an index into an array of buckets, where the value corresponding to a key is stored.

Working of hash table

A hash function converts a key into an integer (hash code), which is used as an index to place the key-value pair in an array (bucket).

If two keys hash to the same index, a collision occurs, which can be handled by methods like chaining (linked lists in buckets) or open addressing (finding another available index).

Time Complexity:

Insertion, deletion, and search can be O(1) on average, but O(n) in the worst case (when all elements hash to the same index).

38. What data structure would you use to find the top 10 most frequent user IDs in the log file with millions of entries.

Data Structures: Use a HashMap to store user IDs as keys and their counts as values, and a Min-Heap (priority queue) to track the top 10 frequent user IDs.

Approach:

Traverse the log file once, and for each user ID, update the count in the HashMap.

After processing the entire log, iterate over the HashMap. Use a Min-Heap to maintain the top 10 most frequent IDs.

If the heap size is less than 10, insert the user ID and its count.
If the heap size is 10, compare the current count with the smallest count in the heap (root). If the current count is larger, replace the root with the current user ID and its count.

Once you finish iterating, the Min-Heap will contain the top 10 most frequent user IDs.

39. Given an unsorted array of integers, find the longest consecutive sequence of integers. The solution should run in O(n) time.

Data Structure: Use a HashSet to store the elements of the array.

Insert all elements into a HashSet to enable O(1) lookups. Iterate through the array and for each number num, check if num – 1 exists in the HashSet.
If num – 1 exists, it means num is part of an existing sequence, so skip it.
If num – 1 does not exist, this number is the start of a new sequence.

From this starting point, count the length of the sequence by incrementing the number and checking if the next consecutive number exists in the set. Track the longest sequence found

Time Complexity:

O(n) because inserting and checking in a HashSet is O(1) on average, and each element is processed only once.

40. Design a web-based ticket booking system. One of the functionalities is to allow users to search for available seats in a theater. The theater is represented as a 2D grid of seats, where some seats are booked and others are available. You need to return the list of available seats in O(1) time. How would you approach this?

Data Structure:

Use a 2D array or matrix to represent the theater seats (rows and columns), with booked seats marked as false and available seats as true. Additionally, maintain a separate HashSet of available seats for O(1) lookups.

Approach:

Initialize a 2D matrix to represent the seats, marking each seat as available (true) or booked (false). As seats are booked, update the matrix and remove the seat from the HashSet.

To search for available seats, directly return the list of seats from the HashSet, which gives O(1) lookup time for checking availability.

41. Design a system that processes large amounts of sensor data in real-time. You need to find the median of the stream of data at any point in time. What data structures would you use?

Data Structures: Use two Heaps (Min-Heap and Max-Heap).

The Max-Heap stores the smaller half of the numbers.
The Min-Heap stores the larger half of the numbers.

For each new number in the data stream:

If the number is smaller than or equal to the maximum element of the Max-Heap, insert it into the Max-Heap. Otherwise, insert it into the Min-Heap.

Balance the heaps to ensure they have equal size or the Max-Heap has one extra element.

To find the median:

If the heaps have the same size, the median is the average of the two root elements.
If the Max-Heap has more elements, the median is the root of the Max-Heap.

42. Design a data-heavy dashboard that shows real-time analytics. Users should be able to interact with filters, which dynamically update the displayed data without refreshing the page. How would you achieve this?

Key Technologies:

AJAX/Fetch API for asynchronous calls.
WebSockets for real-time data.
React, Angular, or Vue for reactive UI updates.

43. Build a responsive web application, and you need to ensure that the UI is consistent across different screen sizes (mobile, tablet, desktop). What tools and techniques would you use to achieve this?

Approach:

CSS Media Queries:

Use media queries to apply different styles based on the device’s width, height, resolution, or orientation.

For example:

@media (max-width: 768px) { .container { flex-direction: column; } }

Flexbox and CSS Grid:

Use Flexbox and Grid for creating flexible and adaptive layouts that adjust seamlessly across screen sizes.

Responsive Design Frameworks:

Consider using responsive front-end frameworks like Bootstrap or Tailwind CSS, which provide pre-designed components and grid systems that work well across various screen sizes.

Viewport Meta Tag:

Ensure the page adapts to different screen widths by setting the viewport meta tag:

44. In a web form where users input personal details. After filling out the form, the data must be validated both on the client side and the server side to prevent errors and malicious data submissions. How would you handle this?

Approach:

Client-Side Validation:

Use JavaScript (or libraries like React with form validation packages such as Formik or Yup) to validate the form before submission.Ensure fields like email, phone number, and required fields are correctly validated using regular expressions and built-in HTML5 form validation attributes.

Example (HTML5):

Server-Side Validation:

Once the form is submitted, validate the data again on the server side using frameworks such as Express.js, Django, or Spring Boot to ensure the data meets required standards and sanitize inputs to prevent SQL injection or cross-site scripting (XSS) attacks

Error Handling:

Display error messages clearly under each form field or at the top of the form if validation fails.

45. What is the difference between Depth-First Search (DFS) and Breadth-First Search (BFS)?

DFS (Depth-First Search):

Explores as far as possible along a branch before backtracking.
Uses a stack (or recursion) for the implementation.
Suitable for problems like pathfinding in mazes or searching through tree structures where you want to explore deep before wide.
Time complexity: O(V + E) where V is vertices and E is edges.

BFS (Breadth-First Search):

Explores all neighbors at the current depth level before moving to nodes at the next depth level. Uses a queue for the implementation.
Suitable for finding the shortest path in unweighted graphs (e.g., in social networking sites). Time complexity: O(V + E).

46. Design a web-based ticket booking system. One of the functionalities is to allow users to search for available seats in a theater. The theater is represented as a 2D grid of seats, where some seats are booked and others are available. You need to return the list of available seats in O(1) time. How would you approach this?

Data Structure:

Approach:

Initialize a 2D matrix to represent the seats, marking each seat as available (true) or booked (false). As seats are booked, update the matrix and remove the seat from the HashSet.

To search for available seats, directly return the list of seats from the HashSet, which gives O(1) lookup time for checking availability.

47. Design a system that processes large amounts of sensor data in real-time. You need to find the median of the stream of data at any point in time. What data structures would you use?

Data Structures: Use two Heaps (Min-Heap and Max-Heap).

The Max-Heap stores the smaller half of the numbers.
The Min-Heap stores the larger half of the numbers.

48. Implement a spell checker. Given a list of words (dictionary) and a query word, find if the query word exists in the dictionary. If the query word doesn’t exist, return suggestions that are one character edit away (insert, delete, or replace a character). What data structure would you use?

Data Structure: Use a Trie (prefix tree) to store the dictionary and for efficient querying and suggestion generation.

Approach:

Insert all words from the dictionary into a Trie.
To check if the query word exists:
Traverse the Trie based on the characters of the query word. If you reach a terminating node, the word exists.
If the query word doesn’t exist, generate possible suggestions by: Checking for words in the Trie that can be formed by editing the query word (insertion, deletion, or replacement of a single character).
For each possible edit, traverse the Trie to find valid words.

49. Design a component in a single-page application (SPA) that fetches data from an API and displays it in a paginated table. Users should be able to sort the table by different columns. How would you implement this?

Pagination:

Use infinite scrolling or classic pagination with buttons (next/previous page). Fetch only a subset of data at a time (using API pagination) to avoid overloading the client with too much data.

Use query parameters (page, limit) when requesting data from the API to retrieve the correct page.

Sorting:

Implement client-side sorting if all data is loaded (for small datasets). Otherwise, implement server-side sorting by sending a query parameter indicating the column and sorting order (sort=column_name&order=asc/desc) when making API calls.

50. To improve the performance of a web application that has several large images and videos on the landing pagme. What techniques would you use to optimize the loading time and overall performance?

Image Optimization:

Use modern image formats like WebP that offer better compression than JPEG or PNG.

Lazy Loading:

Only load images when they appear in the viewport using the loading=”lazy” attribute for images.

Responsive Images:

Use the srcset attribute to load different image sizes based on the screen size or resolution.

Video Optimization:

Use lazy loading for videos as well.
Consider using video streaming services instead of self-hosting large video files.

Minification and Compression:

Minify CSS, JavaScript, and HTML files to reduce file size.
Enable gzip or Brotli compression on the server to compress files before they are sent to the client

Request more information

Advanced Full Stack Interview Questions