My Swiggy Interview Experience: Insights and Tips for Aspiring Developers

Hi, I'm Thanmai, a 2023 B.Tech graduate specializing in Computer Science and Engineering. Recently, I had the opportunity to interview with Swiggy for the ASDE role, and I wanted to share my experience to help others prepare for similar opportunities.

Table of Contents

• Application Process
• Advancing to the Machine Coding Round
• Machine Coding Round Experience (90 mins)
• Machine Coding Round Interview (120 mins)
• PSDS / Domain Round Interview (90 mins)
• Hiring Manager Round (60 mins)
• Conclusion: Reflecting on My Swiggy Interview Journey

For detailed insights into each stage of my Swiggy interview process, please explore the corresponding sections below.

Application Process

At the end of January, I received an email from Unstop (formerly Dare2Compete) about an Associate Software Development Engineer (ASDE) position at Swiggy, mentioning a salary of 23 LPA. Intrigued by the opportunity, I clicked on the "Apply" button, which redirected me to the Unstop website.

I was asked to provide my information and fill out some basic details on the Unstop site. While reviewing the job listing, I noticed that the salary information was not disclosed on the website, and some of the requirements differed from what I had expected. Despite this, my interest and excitement about the role at Swiggy encouraged me to proceed with the application.

I completed the application by filling in my details on the Unstop website and submitting the required information. After applying, I received an acknowledgment from Swiggy's team about my application status and a portal link to stay informed and updated on the process.

Follow-Up and Next Steps

At the end of March, I received another email from Swiggy, indicating that I had progressed to the next step of the application process. They requested some additional details, which I promptly provided by filling out a Google form they sent.

Given my background as a frontend intern for a year before transitioning to full stack, I am more comfortable with frontend technologies, particularly React and JavaScript. Consequently, most of my interview steps were focused on frontend skills and the tech stack I have experience with.

Machine Coding Round (90 mins)

The day after I submitted the Google form, I received an email from Swiggy's recruitment team with a link to the machine coding round hosted on the HackerRank platform. The test was 90 minutes long and consisted of three parts:

1. Problem-Solving Question: This section included one coding problem to be solved using JavaScript. The problem required determining whether a given number is a power of 2. Initially, I wrote a straightforward solution but then optimized it with the following logic:

function isPowerOfTwo(n) {

       // A number is a power of 2 if and only if it is positive and has exactly one bit set

       return n > 0 && (n & (n - 1)) === 0;

}        

This optimized solution passed all 10 test cases.

2. Multiple Choice Questions: There were six MCQs focused on CSS, HTML, and JavaScript.

3. React Application Task: This task involved a partially written React application. The objective was to add functionality to cards displayed on the website. Each card displayed a question on the front, and when clicked, the card should flip to reveal the answer. My main tasks were to:

- Implement the flipping functionality.

- Loop over the data using React component functionality.

Initially, my code did not pass all the unit test cases. After checking the test case descriptions for failures, I identified that adding an ID to each card was necessary. Once I made this adjustment, all unit test cases passed.

By the end of the test, which took me 50 minutes to complete, I had successfully passed all the test cases for the problem-solving question, and all the unit test cases for the React application task, and answered all the MCQs to the best of my knowledge.

Within a week after the machine coding round, I received a call from the HR team at Swiggy. They provided detailed information about the job and asked for my consent to proceed.

When they mentioned that the pay was between 7-8 LPA, it was a bit of a roadblock for me. However, I decided to continue with the process because Swiggy is a highly reputed product-based company.

Within an hour of the call, I received an email from the Swiggy recruitment team stating that I had qualified for the next stage and that there would be a machine coding round interview.

Machine Coding Round Interview (120 mins)

The worst experience I had with Swiggy was during this stage. They scheduled the interview within two days of the email but postponed it three times, taking almost ten days for me to actually attend the interview. Although this allowed me more time for preparation and to cover many topics, it was disappointing to get ready each time only to hear about another postponement.

Before the interview, I inquired with the HR (which I recommend you do before attending any interview) regarding the interview format. I learned that the questions would mostly relate to my work and JavaScript. To prepare, I went through numerous tutorials and would like to thank my senior Aaryan, who suggested many preparation strategies and references.

Unfortunately, despite my extensive preparation, I missed one tutorial that turned out to be crucial. The interviewer asked about implementing an infinite nested message structure in a reply section, similar to what you see on platforms like YouTube or Facebook. They wanted this code implemented in JavaScript with a UI in React.

Here’s how the process unfolded:

• The interviewer provided a document with the details and a sample UI, asking me to develop it.The interviewer asked me to proceed step-by-step and guided me through each step.
• Steps Taken During the Interview:
• Strategy Explanation: When I began coding, the interviewer asked for my strategy, which is a crucial first step in interviews. I explained my strategy of using recursion (thanks to Coding Club Mafia for teaching me these concepts and DSA for which I am very grateful).
• Creating the JSON File:

    {
  "messages": [
    {
      "id": 1,
      "text": "First message",
      "replies": [
        {
          "id": 2,
          "text": "First reply",
          "replies": [
            {
              "id": 3,
              "text": "Reply to first reply",
              "replies": []
            }
          ]
        }
      ]
    },
    {
      "id": 4,
      "text": "Second message",
      "replies": []
    }
  ]
}
        

• Fetching Data into the UI:

I initially tried implementing the nested structure using margin-left: 20px for indentation, but it didn't work well. The interviewer suggested using ordered and unordered lists instead, which worked fine.

import React from 'react';
import nestedData from './nestedData.json';

const Message = ({ message }) => (
  <div>
    <p>{message.text}</p>
    {message.replies.length > 0 && (
      <div style={{ marginLeft: '20px' }}>
        {message.replies.map((reply) => (
          <Message key={reply.id} message={reply} />
        ))}
      </div>
    )}
  </div>
);

const App = () => (
  <div>
    {nestedData.messages.map((message) => (
      <Message key={message.id} message={message} />
    ))}
  </div>
);

export default App;
        

The interviewer suggested using ordered and unordered lists instead, which worked fine.

import React from 'react';
import nestedData from './nestedData.json';

const Message = ({ message }) => (
  <li>
    {message.text}
    {message.replies.length > 0 && (
      <ul>
        {message.replies.map((reply) => (
          <Message key={reply.id} message={reply} />
        ))}
      </ul>
    )}
  </li>
);

const App = () => (
  <ul>
    {nestedData.messages.map((message) => (
      <Message key={message.id} message={message} />
    ))}
  </ul>
);

export default App;
        

• Adding a Message Field:

const App = () => {
  const [messages, setMessages] = useState(nestedData.messages);
  const [newMessage, setNewMessage] = useState("");

  const handleAddMessage = () => {
    const newMessageObj = {
      id: messages.length + 1,
      text: newMessage,
      replies: []
    };
    setMessages([...messages, newMessageObj]);
    setNewMessage("");
  };

  return (
    <div>
      <input
        type="text"
        value={newMessage}
        onChange={(e) => setNewMessage(e.target.value)}
      />
      <button onClick={handleAddMessage}>OK</button>
      <ul>
        {messages.map((message) => (
          <Message key={message.id} message={message} />
        ))}
      </ul>
    </div>
  );
};

export default App;        

• Implementing Nested Message Addition:

The next task was to add the same functionality for nested messages. I attempted to implement the logic but missed a crucial line of code, causing the implementation to fail. I spent too much time trying to fix this issue and neglected the design part.

When the interview was about to end in 30 minutes, the interviewer asked me to stop and explain my code, which I did and I found pretty satisfaction from him as I am good in code. He then asked CSS questions (animations), in which I was not well-versed, followed by React questions. I missed a few questions since my experience was limited to my internship. He advised me to refer to topics like CSS Flex, Grid, animations, and React hooks (beyond useState) like useRef, as well as actions and reducers.

After the interview, my self-assessment was mixed: I felt very proud of using learned concepts but not satisfied with the overall performance. I regretted missing out on designing the UI and not answering the React core concepts very well.

I thought I wouldn't receive the next call from them, but after a month, by that time I had almost lost my hopes and forgotten about it, I received a call from HR informing me that I got selected for the next round (PSDS/Domain Round), and they scheduled it within the next 4 days.

Here are a few reference links that might be helpful:

• Swiggy Interview Experience | Frontend Intern | Kunal Jain
• Swiggy Interview Experience | UI Developer | Frontend Engineer | Akshay Saini
• Why Swiggy rejected me ? (My Swiggy interview experience) | Vasanth Bhat
• Machine Coding Round | Web Developer Interview | Akshay Saini
• Webinar | My Interview Experience at Swiggy | Shashank Hiremath

PSDS / Domain Round - Interview (90 mins)

During the PSDS/Domain Round with Swiggy, the most frustrating part was the numerous reschedulings—almost five times—before I finally faced the interview panel.

When I was handed a problem-solving question, I had extensively prepared for it during the extended waiting periods. The question involved determining the correct order of task execution based on dependencies

Problem statement:

You have a set of tasks, each with dependencies that determine the order in which they need to be executed. Given these dependencies and a specific task, determine the correct order of execution for that task. 
A → {B, C} 
B → {E}
C → {D, E, F} 
D → {F} 
E → {}
F → {B}        

I quickly analyzed the dependencies and formulated the execution sequence:

1. E: This task has no dependencies.
2. B: Depends on E.
3. F: Depends on B.
4. D: Depends on F.
5. C: Depends on D, E, and F.
6. A: Depends on B and C.

The interviewer was pleased with my explanation and asked me to think of logic, so I initially considered the approach of deleting completed tasks. Then the interviewer challenged me to rethink the logic to make it simpler. After a moment's reflection, I suggested maintaining a visited list while adding tasks to the executed tasks, ensuring dependencies were respected at each step.

Once I completed the code, the interviewer asked me to explain it thoroughly. I discussed how the algorithm handled various edge cases, such as cyclic dependencies, where tasks loop back on themselves, and how I managed these scenarios with checks in the code. The interviewer was impressed with my problem-solving approach, especially in handling complex scenarios effectively.

After reviewing the code, the interviewer inquired about the time complexity of my solution, to which I promptly provided an answer.Later in the interview, the interviewer delved into how browsers function. They specifically asked about the Domain Name System (DNS) and its role in internet browsing. To illustrate my understanding, I used drawings to visually explain how DNS translates domain names into IP addresses, facilitating communication between devices on the internet. The interviewer was impressed by my ability to simplify and clarify this complex technical concept.

Satisfied with my technical depth, the interviewer then transitioned to theoretical questions about React. Despite my limited practical experience in React beyond internships, I engaged in the discussion, and the interviewer provided valuable feedback on strengthening my understanding of core React concepts.

After feeling satisfied with my performance, I anticipated moving forward to the next round. However, a month later, I received disappointing news that I wouldn't be proceeding further.

The following day, I unexpectedly received a call from the HR team and attended another meeting where they surprised me with the news of my selection for the HM round. Initially, there was confusion about a backend role, but it was clarified that I had been consistently evaluated for a frontend position, which brought a smile back to my face.

I promptly inquired about the next steps and learned that the Hiring Manager round would focus on discussing my previous work experience and personal development. The meeting was scheduled for the following week, marking another step forward in the process.

Hiring Manager Round (60 mins)

This time, I attended the interview without preparing specific code, anticipating questions about my role and personal growth. However, the interviewer surprised me by delving deeply into discussions about my past projects.

When asked to highlight an area I was familiar with, I discussed my work during my internship on e-commerce platform and I highlighted my contributions to key pages like products, cart, and FAQs, explaining how I implemented filters to improve user interaction. When asked about my approach to implementing filters, the interviewer delved into sorting algorithms. I confidently demonstrated my understanding by coding merge sort on the spot, despite initial nervousness. The interviewer stressed the importance of understanding problem complexity before proposing solutions, given React's built-in sorting capabilities.

We also discussed handling overflow data, where I advocated for pagination and React's infinite scroll component. However, I stumbled when asked about managing infinite products.

The interviewer showed various websites to discuss effective web design, allowing me to reaffirm the benefits of pagination and infinite scroll. They then shifted focus to discussing how I would approach developing a platform like Swiggy. I emphasized a structured approach with header, footer, and main blocks, each serving distinct functions. Detailing a block within the main division, I outlined a component-based design approach for items.

The discussion pivoted to defining what makes a high-quality website. Initially, I emphasized responsiveness and fast loading times. However, when asked about technical solutions for low network conditions, I hesitated. The interviewer guided me towards caching as a solution, which I explained as an effective approach.

After reflecting on the interview, despite my uncertainties and challenges with unexpected questions, I valued the opportunity to discuss my work and aspirations. Getting a rejection email later was disappointing, but it's a part of the learning process in pursuing career goals.

This is how my journey with the Swiggy interview process unfolded: from initial excitement and preparation, facing multiple reschedulings, to navigating through technical challenges and unexpected questions. Despite moments of uncertainty and disappointment, each step taught me valuable lessons about preparation, resilience, and the pursuit of career growth.

-Thanmai Boddoju