• 2 months, 3 weeks ago

Accenture Full Stack Development Interview Questions and Answers

Aadesh Shrivastav
Table of Contents

Dive into our comprehensive guide featuring a curated list of Accenture Full Stack Development interview questions and expertly crafted answers. Whether you're a seasoned developer or a recent graduate, this blog is designed to help you ace your technical interviews at Accenture.

Q1. What is the difference between <div> and <span>?

Ans: The <div> and <span> elements are both container elements used in HTML, but they have different purposes and default behaviors:





Block-level container

Inline container


Grouping and structuring content

Applying styles to specific text

Default Behavior

Takes up the full width, starts on a new line

Takes up only as much width as necessary, inline

Semantic Meaning

No inherent semantic meaning

No inherent semantic meaning


Used for layout and formatting purposes

Used for applying styles to a specific portion of text


<div>Content goes here</div>

<p>This is a <span style="color: red;">highlighted</span> word.</p>


Q2. What is useMemo?

Ans: useMemo is a React hook that is used for memoizing the result of a function or a computation. Memoization is an optimization technique where the result of a function is cached so that the function does not recompute the result unless its dependencies have changed. This can be particularly useful in scenarios where a function's execution is resource-intensive or time-consuming and you want to avoid unnecessary recalculations.

The syntax for useMemo is as follows:

const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);


  • computeExpensiveValue is the function whose result is being memoized.
  • [a, b] is the dependency array. The memoized value will only be recomputed when the values in this array change.


import React, { useMemo, useState } from 'react';

const ExpensiveComponent = ({ data }) => {
  const expensiveOperation = () => {
    // Simulating an expensive computation
    return => item * 2);

  const memoizedResult = useMemo(() => expensiveOperation(), [data]);

  return (
      <p>Memoized Result: {memoizedResult.join(', ')}</p>

const App = () => {
  const [dataArray, setDataArray] = useState([1, 2, 3, 4]);

  return (
      <button onClick={() => setDataArray(prevData => [...prevData, prevData.length + 1])}>
        Add Item
      <ExpensiveComponent data={dataArray} />

export default App;

In this example, the ExpensiveComponent performs a computation (doubling each item in the array) that can be resource-intensive. By using useMemo, we ensure that the computation is only performed when the data array changes, preventing unnecessary recalculations on every render. The console log inside the expensiveOperation function demonstrates that the calculation only happens when the dependencies change.


Q3. What is the difference between Middleware and React Router?

Ans: Middleware and React Router are different concepts that serve distinct purposes in the context of web development, and they are not directly comparable. Let's briefly discuss each:



React Router


Software components between applications and services, handling tasks like request processing, authentication, etc.

Library for handling client-side navigation in a React application.


Primarily used on the server side (e.g., Express middleware in Node.js).

Primarily used on the client side in React applications.


Task-specific functions, e.g., logging, authentication, error handling, etc.

Manages navigation within a React application, rendering components based on the URL.

Usage Example

javascript const loggerMiddleware = (req, res, next) => { console.log(`Request received at: ${new Date()}`); next(); }; app.use(loggerMiddleware);

javascript import { BrowserRouter as Router, Route, Switch } from 'react-router-dom'; const App = () => { return ( <Router> <Switch> <Route path="/home" component={Home} /> <Route path="/about" component={About} /> <Route path="/contact" component={Contact} /> </Switch> </Router> ); };


Typically used on the server side, often with Node.js frameworks like Express.

Used in client-side development within a React application.

Primary Focus

Server-side tasks and operations.

Client-side navigation and component rendering.


Integrated into server-side frameworks (e.g., Express middleware).

Integrated into React applications for client-side navigation.

Example Library

Express middleware (e.g., for logging, authentication).

React Router library (for managing routes and navigation in a React app).

Example for Middleware:

const loggerMiddleware = (req, res, next) => {
  console.log(`Request received at: ${new Date()}`);


Example for React Router:

import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';

const App = () => {
  return (
        <Route path="/home" component={Home} />
        <Route path="/about" component={About} />
        <Route path="/contact" component={Contact} />

This table provides a concise comparison of Middleware and React Router in terms of their definition, context, functionality, usage examples, location (server/client-side), primary focus, integration, and example libraries.


Q4. What is async/await?

Ans: async/await is a feature in JavaScript that allows you to work with asynchronous code more comfortably and with cleaner syntax. It was introduced in ECMAScript 2017 (ES8) and provides a way to work with promises in a more synchronous fashion.

Here's a breakdown of async/await:

1. async Function:

  • The async keyword is used to define a function that returns a promise.
  • An async function can contain one or more await expressions.
async function myAsyncFunction() {
  // Code here

2. await Expression:

  • The await keyword is used inside an async function to wait for a promise to resolve before moving on to the next line of code.
  • It can only be used within an async function.
  • In this example, fetchDataFromAPI returns a promise, and await pauses the execution of fetchData until the promise is resolved. This makes asynchronous code look and behave more like synchronous code.
async function fetchData() {
  const data = await fetchDataFromAPI(); // fetchDataFromAPI() returns a promise

3. Error Handling:

  • async/await simplifies error handling with the use of try and catch.
  • If a promise is rejected, the catch block is executed.
async function fetchData() {
  try {
    const data = await fetchDataFromAPI();
  } catch (error) {
    console.error('Error fetching data:', error);

4. Return Value:

  • An async function always returns a promise. If the function explicitly returns a value, the promise is resolved with that value.
  • If an async function does not explicitly return a value, it implicitly returns a promise that resolves to undefined.
async function example() {
  return 'Hello, Async/Await!';

example().then(result => console.log(result)); // Output: Hello, Async/Await!

The primary advantage of async/await is that it makes asynchronous code more readable and easier to reason about, especially when dealing with multiple asynchronous operations. It helps avoid the "callback hell" or "pyramid of doom" that can occur with deeply nested callbacks in traditional asynchronous JavaScript code.


Q5. What are the advantages and disadvantages of React?

Ans: React, a popular JavaScript library for building user interfaces, comes with its set of advantages and disadvantages. Let's explore both:

Advantages of React:

Declarative Syntax:

  • React uses declarative syntax, making it more intuitive and easier to understand. Developers can describe what they want the UI to look like, and React takes care of updating the DOM to match that description.

Component-Based Architecture:

  • React follows a component-based architecture, promoting modularity and reusability. UIs are built by combining small, isolated components, making it easier to manage and maintain code.

Virtual DOM:

  • React uses a virtual DOM, a lightweight copy of the actual DOM, to optimize updates. This results in faster rendering and improved performance as React only updates the parts of the DOM that have changed.

One-Way Data Binding:

  • React follows a unidirectional data flow, making it easier to trace and debug data changes. This helps prevent unexpected side effects and simplifies the understanding of the application's state.

React Native for Cross-Platform Development:

  • React can be used with React Native to build native mobile applications for iOS and Android. This allows developers to use their React knowledge to build cross-platform mobile apps.

Large and Active Community:

  • React has a large and active community, which means extensive documentation, a wide range of third-party libraries, and strong community support. This makes it easier to find solutions to problems and stay updated with best practices.

Developer Tools:

  • React Developer Tools offer powerful browser extensions that help developers inspect, debug, and profile React applications efficiently.

Disadvantages of React:

Learning Curve:

  • For beginners, the learning curve can be steep, especially if they are not familiar with concepts like JSX, virtual DOM, and one-way data binding. Additionally, the ecosystem evolves rapidly, requiring developers to stay updated.

JSX Syntax:

  • JSX, while powerful and expressive, might feel unfamiliar to developers who are used to working with traditional HTML. This can lead to a learning curve, and some developers might find JSX less readable.

Tooling Complexity:

  • The React ecosystem has a variety of build tools and configurations. Setting up a React project with tools like Webpack and Babel can be complex for beginners, and maintaining the build configuration might require ongoing effort.

SEO Challenges:

  • React applications primarily rely on client-side rendering. While server-side rendering (SSR) is possible, implementing it correctly can be challenging, and SEO optimization might require additional effort.

High Pace of Development:

  • React evolves rapidly, and new features are introduced regularly. While this is an advantage in terms of innovation, it can be a challenge for projects with tight deadlines, as developers need to stay updated with the latest changes.

Integration Issues:

  • Integrating React into existing projects, especially those using different frameworks or libraries, might pose challenges. The integration process can be smoother in projects built entirely with React.

Flux Architecture Complexity:

  • While Flux and Redux provide effective state management solutions for complex applications, they can introduce additional complexity, especially for simpler applications where simpler state management might suffice.

It's important to note that the advantages and disadvantages of React can be subjective and depend on factors such as project requirements, team expertise, and specific use cases. React is a powerful tool, and many of its disadvantages can be mitigated with experience and best practices.


Q6. What do you use for JavaScript styling?

Ans: For styling JavaScript applications, there are several popular approaches and tools available. The choice often depends on the project requirements, team preferences, and the specific use case. Here are some common options:

1. CSS (Cascading Style Sheets):

  • Description: Traditional CSS is a styling language used to describe the look and formatting of a document written in HTML or XML.
  • Pros:
    • Simple and widely adopted.
    • Clear separation of concerns (HTML for structure, CSS for styling).
  • Cons:
    • Limited modularity and reusability.
    • Global scope can lead to naming conflicts.

2. CSS Preprocessors (e.g., Sass, Less, Stylus):

  • Description: Preprocessors extend CSS with features like variables, nested rules, and functions.
  • Pros:
    • More maintainable and readable code.
    • Variables and mixins enhance reusability.
  • Cons:
    • Requires a compilation step.
    • Learning curve for new syntax features.

3. CSS-in-JS Libraries (e.g., styled-components, Emotion):

  • Description: These libraries allow you to write CSS directly in JavaScript files, often scoped to the component level.
  • Pros:
    • Encapsulation of styles at the component level.
    • Dynamic styling based on props or state.
  • Cons:
    • Learning curve for the new syntax.
    • Some developers may find it unconventional.

4. Utility-First CSS Frameworks (e.g., Tailwind CSS):

  • Description: Utility-first frameworks provide a set of pre-defined utility classes that you can compose to build components.
  • Pros:
    • Rapid development with consistent styles.
    • No need to write custom CSS for many common styles.
  • Cons:
    • Learning curve for the utility class syntax.
    • Limited customization without additional CSS.

5. CSS Modules:

  • Description: CSS Modules allow you to write modular and scoped CSS by generating unique class names for each module.
  • Pros:
    • Scoped styles, avoiding global conflicts.
    • Modular and reusable CSS.
  • Cons:
    • Requires a build step for bundling.
    • Some developers may prefer other solutions.

6. Tailwind CSS:

  • Description: Tailwind CSS is a utility-first CSS framework that provides a set of pre-designed utility classes.
  • Pros:
    • Extremely customizable and configurable.
    • Rapid development with consistent styles.
  • Cons:
    • Learning curve for the utility class syntax.
    • Some developers may prefer more traditional CSS.

7. BEM (Block Element Modifier):

  • Description: BEM is a naming convention for CSS classes that aims to make the code more readable and maintainable by providing a clear structure for class names.
  • Pros:
    • Clearly defined and structured naming convention.
    • Promotes maintainability and reusability.
  • Cons:
    • Longer class names can be verbose.
    • Some developers may prefer other approaches.

8. JSS (JavaScript Style Sheets):

  • Description: JSS is a JavaScript library for styling React applications. It allows you to write styles as objects directly in your JavaScript files.
  • Pros:
    • Scoped styles at the component level.
    • Dynamic styling based on props or state.
  • Cons:
    • Learning curve for the new syntax.
    • Some developers may prefer other solutions.


The choice of styling approach depends on various factors such as project requirements, team familiarity, and personal preferences. Often, a combination of these approaches is used within a single project, depending on specific use cases and requirements.


Q7. What is event bubbling and capturing?

Ans: Event bubbling and event capturing are two phases in the event propagation process in the DOM (Document Object Model) when handling events in JavaScript.

Event Bubbling:

In the event bubbling phase, the event starts from the target element that triggered the event and then bubbles up through its ancestors in the DOM hierarchy, reaching the root of the document. The order in which event handlers are executed is from the target element to the root.


<div id="parent">
  <button id="child">Click me</button>

  document.getElementById('parent').addEventListener('click', () => {
    console.log('Parent Clicked');

  document.getElementById('child').addEventListener('click', () => {
    console.log('Child Clicked');

If you click the button in this example, you'll see both "Child Clicked" and "Parent Clicked" in the console. This is because the event bubbles from the button to the parent div.

Event Capturing:

In the event capturing phase (also known as trickling or capturing), the event starts from the root of the document and trickles down through the DOM hierarchy until it reaches the target element that triggered the event. The order of execution of event handlers in this phase is from the root to the target element.


<div id="parent">
  <button id="child">Click me</button>

  document.getElementById('parent').addEventListener('click', () => {
    console.log('Parent Clicked');
  }, true); // The third parameter specifies capturing phase

  document.getElementById('child').addEventListener('click', () => {
    console.log('Child Clicked');
  }, true);

In this example, with event capturing enabled (true as the third parameter in the addEventListener method), if you click the button, you'll see "Parent Clicked" in the console before "Child Clicked."

Event Flow:

The event flow in the DOM involves both the capturing and bubbling phases:

1. Capturing Phase: The event travels from the root to the target element.

2. Target Phase: The event reaches the target element.

3. Bubbling Phase: The event bubbles up from the target element to the root.

By default, event handlers are set to work in the bubbling phase. If you want to enable event capturing, you need to set the third parameter of addEventListener to true.


Q8. How can you prevent a bot from scraping a publicly accessible API?

Ans: Preventing scraping entirely is challenging, especially when dealing with publicly accessible APIs. However, you can implement measures to deter scraping and make it more difficult for bots to access and collect data. Keep in mind that determined attackers may still find ways to circumvent these measures.

Here are some strategies to mitigate scraping attempts:

1. API Key Authentication:

  • Require an API key for accessing your API. This adds a layer of authentication and allows you to track usage. You can monitor and restrict access based on usage patterns, and revoke keys if abuse is detected.

2. Rate Limiting:

  • Implement rate limiting to restrict the number of requests a user or IP address can make within a specified time period. This helps prevent abuse by limiting the speed at which data can be scraped.

3. User-Agent Filtering:

  • Analyze the User-Agent header in incoming requests and block requests that appear to come from known bots or scraping tools. However, note that User-Agent headers can be easily spoofed.

4. CAPTCHA Challenges:

  • Integrate CAPTCHA challenges for suspicious or excessive requests. While this can be an effective deterrent, it may also inconvenience legitimate users.

5. Session Tokens or Cookies:

  • Use session tokens or cookies to authenticate and track user sessions. Bots may have difficulty handling session-based authentication.

6. Monitor and Analyze Traffic:

  • Regularly monitor and analyze your API traffic for unusual patterns or spikes in usage. Implement anomaly detection to identify potential scraping activities.

7. Honeypots:

  • Introduce hidden or fake data (honeypots) that should not be accessed by legitimate users. If requests are made for these resources, it may indicate scraping attempts.

8. Legal Measures:

  • Clearly define and communicate the terms of use for your API. Include usage policies in your API documentation. If scraping violates your terms of service, you may take legal action against violators.

9. Encryption (HTTPS):

  • Ensure that your API is accessed over HTTPS to encrypt data in transit. This helps prevent eavesdropping and unauthorized interception of data.

10. Monitoring and Response:

  • Set up monitoring systems to detect unusual activities or spikes in traffic. Be prepared to respond quickly to block or mitigate scraping attempts.

Remember that no solution is foolproof, and determined attackers may find ways to circumvent these measures. The goal is to increase the effort and complexity required for scraping, making it less attractive and more easily detectable. Always balance security measures with the impact on legitimate users and services.


Q9. What is a RESTful API?

Ans: RESTful API (Representational State Transfer) is an architectural style for designing networked applications. It was introduced by Roy Fielding in his doctoral dissertation in 2000. RESTful APIs are widely used for building web services because they provide a simple and lightweight way to communicate between systems over HTTP.

Key principles and characteristics of RESTful APIs include:

1. Stateless Communication:

  • Each request from a client to a server contains all the information needed to understand and process the request. The server does not store any information about the client's state between requests.

2. Resource-Based:

  • Resources are identified by URIs (Uniform Resource Identifiers), and interactions with resources are performed using standard HTTP methods (GET, POST, PUT, DELETE). Resources can represent entities such as objects, services, or data.

3. Uniform Interface:

  • RESTful APIs have a uniform and consistent interface, which simplifies the architecture and makes it more scalable. The uniform interface is defined by a set of constraints, including resource identification, manipulation through representations, and self-descriptive messages.

4. Representation:

  • Resources can have multiple representations (e.g., JSON, XML, HTML), and the client and server can negotiate the representation format. The representation includes both the data and metadata about the resource.

5. Stateless Server:

  • The server does not store any client state. Each request from a client to the server must contain all the information needed to understand and process the request. This constraint simplifies the server and improves scalability.

6. Stateless Communication:

  • Each request from a client to a server contains all the information needed to understand and process the request. The server does not store any information about the client's state between requests.

7. Hypermedia as the Engine of Application State (HATEOAS):

  • HATEOAS is a constraint in REST that says the communication between a client and a server should be driven by hypermedia (links) provided dynamically by applications. Clients interact with the application entirely through hypermedia provided dynamically by application servers.

RESTful APIs are commonly used for web services, providing a scalable and standardized way for different systems to communicate over the web. They are widely adopted due to their simplicity, scalability, and ease of integration with various technologies. Popular web services, such as those provided by Twitter, GitHub, and many others, follow RESTful principles.


Q10. What is the difference between “resetting” and “normalizing” CSS?

Ans: Resetting" and "normalizing" CSS are two different approaches to deal with the default styling provided by browsers. Both aim to create a consistent baseline styling for HTML elements across different browsers, addressing the inconsistencies that may arise due to default styles applied by browsers.


CSS Resetting

CSS Normalizing


To reset or zero out all default styles applied by browsers

To create a consistent baseline by making default styles more consistent across browsers


Sets margin, padding, and other styles to zero for many elements

Applies styles to make default styles more consistent across different elements


css html, body, div, span { margin: 0; padding: 0; } /* ... */

css /* Import Normalize.css from a CDN or include it in your project */ @import 'normalize.css'; /* Add additional styles if needed */


Elements start with a consistent baseline

Default styles are more consistent across different browsers


Eliminates all default styles, providing a clean slate

Adjusts default styles to create a more consistent appearance

Common Libraries

None (custom implementations)

Normalize.css is a popular library for normalization

Use Case

When complete control over styling is desired

When a more consistent appearance across browsers is desired

Keep in mind that the choice between resetting and normalizing depends on your specific project requirements and your preference for styling approaches

Add a comment: