Application Process: The interview process began with an online coding round, followed by technical and HR rounds.
Interview Rounds:
Round 1 - Coding Round:
Questions Asked:
2 coding questions.
20 MCQs based on DBMS, OOPs (specifically in C and C++).
Your Approach: Focused on solving the coding questions efficiently and reviewed key concepts for the MCQs.
Outcome: Cleared the round and moved to the next stage.
Round 2 - Technical Interview 1:
Questions Asked: Details not provided.
Your Approach: Prepared by revising core CS concepts and practicing problem-solving.
Outcome: Advanced to the next round.
Round 3 - Technical Interview 2:
Questions Asked: Details not provided.
Your Approach: Continued focusing on technical depth and problem-solving skills.
Outcome: Cleared the round.
Round 4 - HR Round:
Questions Asked: Details not provided.
Your Approach: Prepared to discuss my background, interests, and fit for the role.
Outcome: Final selection.
Preparation Tips:
Practice coding problems regularly.
Revise core CS subjects like DBMS and OOPs.
Be thorough with C and C++ for MCQ sections.
Conclusion:
The interview process was structured and tested both technical and problem-solving skills. Preparing well for the coding round and technical interviews was key to my success. Future candidates should focus on strong fundamentals and consistent practice.
Application Process: [Application process details not provided]
Interview Rounds:
Round 1 - Screening Round (Technical):
Questions Asked:
Two coding questions were asked during this round. The interviewer allowed the use of any preferred programming language. Candidates were expected to handle all edge cases.
Your Approach:
The candidate used their preferred programming language to solve the problems. They focused on writing clean, efficient code and ensured all edge cases were addressed.
Outcome:
The candidate successfully passed this round.
Preparation Tips:
Practice coding problems focusing on edge cases and efficiency.
Be comfortable with your preferred programming language and its nuances.
Conclusion:
The screening round was straightforward, with a focus on coding skills and problem-solving abilities. Handling edge cases effectively was key to passing this round. Future candidates should ensure they are well-prepared for technical problem-solving and can demonstrate their coding proficiency clearly.
Application Process: Applied through the company’s career portal.
Interview Rounds:
Round 1 - Technical Interview:
Questions Asked: Medium-level coding problems focused on data structures and algorithms. Puzzle-solving questions were also included.
Your Approach: I practiced coding problems extensively beforehand and focused on explaining my thought process clearly. The interviewer was helpful and guided me when I got stuck.
Outcome: Passed the round.
Round 2 - Technical Interview (Continued):
Questions Asked: More in-depth questions on system design and software engineering fundamentals.
Your Approach: I reviewed system design concepts and ensured I could articulate my solutions logically. Communication was key here.
Outcome: Successfully cleared the round.
Preparation Tips:
Practice coding problems regularly, especially on data structures and algorithms.
Brush up on system design principles and software engineering fundamentals.
Focus on clear communication during the interview—explain your thought process step-by-step.
Conclusion:
The interview experience was positive, and the interviewer was supportive. Practicing problem-solving and improving communication skills were crucial. For future candidates, I’d recommend thorough preparation and staying calm during the interview.
Application Process: Applied through the company’s hiring process.
Interview Rounds:
Round 1 - System Design:
Questions Asked: The questions were unclear, and no sample inputs were provided.
Your Approach: Tried to clarify the requirements but faced challenges due to the ambiguity.
Outcome: Advanced to the next round despite the confusion.
Round 2 - Data Structures & Algorithms:
Questions Asked: Standard DSA problems.
Your Approach: Solved the problems using optimal approaches and explained the thought process.
Outcome: Successfully cleared this round.
Round 3 - Technical Design/Problem Solving:
Questions Asked: Technical design and problem-solving questions.
Your Approach: Discussed possible solutions and trade-offs.
Outcome: Cleared this round and was asked to return for a face-to-face interview the next day.
Round 4 - Face-to-Face with SVP:
Questions Asked: High-level technical and behavioral questions.
Your Approach: Prepared thoroughly and arrived early for the interview.
Outcome: No feedback was provided post-interview, which was disappointing.
Conclusion:
The interview process was rigorous, and while I cleared the initial rounds, the lack of clarity in the system design round and the absence of feedback after the final interview were frustrating. My advice to future candidates is to prepare thoroughly for all technical rounds and to follow up for feedback if the company doesn’t provide it proactively.
Application Process: The application was part of a campus placement drive for the Software Developer role.
Interview Rounds:
Round 1 - Coding Round:
Questions Asked: The coding round consisted of algorithmic and data structure-based problems. The exact questions were not specified, but they were typical of competitive programming challenges.
Your Approach: I focused on optimizing my solutions for time and space complexity, ensuring I covered edge cases. I practiced similar problems on coding platforms beforehand.
Outcome: Cleared the round successfully.
Round 2 - Face-to-Face Interview (Technical):
Questions Asked: Questions ranged from core computer science topics like OOPs, DBMS, and operating systems to problem-solving and coding. Some system design questions were also included.
Your Approach: I explained my thought process clearly and wrote clean, modular code. For system design, I broke down the problem into smaller components and discussed trade-offs.
Outcome: Advanced to the next round.
Round 3 - Face-to-Face Interview (Technical):
Questions Asked: This round was more in-depth, with questions on advanced algorithms, system design, and real-world problem-solving scenarios.
Your Approach: I focused on demonstrating my problem-solving skills and how I approach complex problems. I also made sure to communicate my reasoning effectively.
Outcome: Cleared the round and moved to the final HR round.
Round 4 - HR Round:
Questions Asked: Typical HR questions about my background, career goals, why I wanted to join MakeMyTrip, and situational questions to assess cultural fit.
Your Approach: I answered honestly and aligned my responses with the company’s values and culture. I also asked thoughtful questions about the team and work environment.
Outcome: Received a positive response and an offer.
Preparation Tips:
Practice coding problems on platforms like LeetCode and CodeChef.
Revise core CS concepts thoroughly, especially data structures, algorithms, and system design.
Mock interviews with peers can help improve communication and problem-solving under pressure.
Conclusion:
The overall experience was challenging but rewarding. The interviewers were supportive and focused on understanding my thought process. I could have prepared more for system design questions, but my coding practice paid off. For future candidates, I’d recommend balancing technical preparation with soft skills, especially for the HR round.
Application Process: Applied through campus placement.
Interview Rounds:
Round 1 - Online Coding Test:
Questions Asked: The test included coding problems focusing on data structures and algorithms. Topics covered arrays, strings, and dynamic programming.
Your Approach: I practiced extensively on platforms like LeetCode and GeeksforGeeks to prepare. During the test, I focused on optimizing my solutions for efficiency.
Outcome: Cleared the round and was shortlisted for the next stage.
Round 2 - Technical Interview (F2F):
Questions Asked: Questions ranged from basic data structures to problem-solving scenarios. Some questions included:
Reverse a linked list.
Find the longest palindromic substring in a given string.
Explain the concept of polymorphism in OOP.
Your Approach: I explained my thought process clearly and wrote clean, efficient code. For the OOP question, I gave real-world examples to illustrate the concept.
Outcome: Performed well and moved to the next round.
Round 3 - Technical Interview (F2F):
Questions Asked: This round was more in-depth, with questions like:
Design a URL shortening service.
Optimize a given SQL query.
Discuss your approach to handling concurrency in a multi-threaded environment.
Your Approach: For the design question, I broke it down into components like database schema, API design, and scalability. For SQL, I focused on indexing and query optimization.
Outcome: Cleared this round and was directly called for the HR round.
Round 4 - HR Interview:
Questions Asked: Typical HR questions like:
Tell me about yourself.
Why do you want to join MakeMyTrip?
How do you handle work pressure?
Your Approach: I kept my answers concise and aligned them with the company’s values and my career goals.
Outcome: Received positive feedback and was selected for the role.
Preparation Tips:
Focus on data structures and algorithms, especially arrays, strings, and dynamic programming.
Practice system design questions, as they are crucial for senior roles.
Be clear with OOP concepts and their real-world applications.
For HR rounds, research the company and align your answers with their culture and values.
Conclusion:
The interview process at MakeMyTrip was smooth, and the interviewers were supportive. I felt well-prepared, but I could have practiced more system design scenarios. My advice to future candidates is to focus on problem-solving and communication skills, as they are equally important.
Application Process: [Application process details not provided]
Interview Rounds:
Round 1 - Online Assessment:
Questions Asked:
20 aptitude MCQs (basic logical reasoning and aptitude)
2 coding questions (details not specified)
Your Approach:
Started the approach for both coding questions but couldn’t complete them due to time constraints.
Outcome:
Selected for the next round despite incomplete solutions.
Round 2 - Technical Interview (CV-Based):
Questions Asked:
Detailed discussion about projects mentioned in the CV.
Basic OOPs concepts.
Basics of C, Unix/Linux programming, and computer networks (as mentioned in the CV).
Your Approach:
Explained projects clearly and answered conceptual questions to the best of my knowledge.
Outcome:
Advanced to the next round.
Round 3 - Technical Interview (Coding + Puzzles):
Questions Asked:
Coding problems (details not specified).
3 puzzles.
Your Approach:
Solved all 3 puzzles correctly.
Attempted the coding problems.
Outcome:
Positive feedback but no offer received.
Round 4 - HR Round:
Questions Asked:
General HR questions (details not specified).
Your Approach:
Answered confidently and professionally.
Outcome:
Received positive feedback but no offer.
Conclusion:
Overall, the interview process was thorough, covering aptitude, technical skills, and problem-solving abilities. While I performed well in the puzzles and conceptual rounds, I could have managed my time better in the coding assessment. Future candidates should focus on time management during coding tests and ensure a strong grasp of fundamentals mentioned in their CV.
Application Process: Applied through the company’s career portal.
Interview Rounds:
Round 1 - Technical Interview:
Questions Asked:
Deep dive into Java, Spring, and Spring Boot.
What is Autowired? If Autowire is not present, how would you solve this?
A DSA question on finding the median.
Explain how HashMaps are implemented in Java.
Your Approach:
For the Java/Spring questions, I explained the concepts clearly and provided examples where necessary. For the Autowire question, I discussed alternatives like manual dependency injection.
For the DSA question, I walked through my thought process step-by-step and wrote clean, efficient code.
For the HashMap question, I explained the internal workings, including hashing, collision resolution, and the role of equals() and hashCode().
Outcome: Cleared the round successfully.
Preparation Tips:
Focus on core Java concepts, especially collections, concurrency, and JVM internals.
Revise Spring and Spring Boot thoroughly, including dependency injection and common annotations.
Practice DSA problems, especially those related to arrays, hashing, and sorting.
Conclusion:
The interview was quite technical but fair. I felt confident in my answers, but I could have prepared more for the DSA question to optimize my solution further. My advice to future candidates is to balance your preparation between core concepts and problem-solving skills.
Application Process: Applied through campus placement.
Interview Rounds:
Round 1 - Technical Interview:
Questions Asked: Focused on Data Structures and Algorithms (DSA) with medium to hard difficulty questions.
Your Approach: I practiced a variety of DSA problems beforehand, which helped me tackle the questions confidently. I also made sure to explain my thought process clearly while solving the problems.
Outcome: Passed this round and moved to the next stage.
Round 2 - Technical Interview:
Questions Asked: Another set of DSA questions, this time with a mix of medium and hard problems. Some questions also touched on Low-Level Design (LLD).
Your Approach: I relied on my problem-solving skills and tried to optimize my solutions as much as possible. For the LLD part, I focused on designing scalable and maintainable systems.
Outcome: Successfully cleared this round as well.
Round 3 - Managerial + Technical Interview:
Questions Asked: A combination of technical questions (DSA and LLD) and behavioral/managerial questions to assess problem-solving and teamwork.
Your Approach: I balanced technical answers with examples from past projects to demonstrate my experience. For the managerial part, I highlighted my ability to collaborate and lead when necessary.
Outcome: Cleared the final round and received the offer.
Preparation Tips:
Practice a wide range of DSA problems, especially medium to hard difficulty ones.
Focus on Low-Level Design (LLD) to handle design-related questions effectively.
Mock interviews can help simulate the actual interview environment and improve confidence.
Conclusion:
Overall, the interview process was challenging but fair. Practicing DSA and LLD thoroughly was key to my success. For future candidates, I’d recommend dedicating ample time to problem-solving and system design to ace the interviews.
Application Process: Applied through an online platform.
Interview Rounds:
Round 1 - Coding Round:
Questions Asked:
3 easy-level coding questions.
A quiz.
Your Approach: Tried to solve the coding questions methodically and attempted the quiz to the best of my ability.
Outcome: The coding round was of medium difficulty. I couldn’t answer all questions correctly, so I didn’t proceed further.
Round 2 - Technical Interview:
Questions Asked: Not disclosed (as I didn’t clear Round 1).
Your Approach: N/A
Outcome: N/A
Conclusion:
The interview process was smooth, but I realized I need to strengthen my coding skills further to tackle medium-level problems more effectively. For future candidates, I’d recommend practicing a variety of coding problems to build confidence and speed.
Your Approach: Solved the problems efficiently, ensuring optimal time complexity.
Outcome: Successfully cleared the round.
Round 3 - DSA Round 2 (Graph Theory):
Questions Asked: Leetcode Medium level graph theory questions.
Your Approach: Applied standard graph algorithms and optimized the solutions.
Outcome: Selected for the role.
Preparation Tips:
Focus on Leetcode DSA topics, especially graph theory and system design.
Practice standard system design scenarios to build confidence.
Conclusion:
The interview process was smooth, and the questions were manageable with good preparation. I would recommend practicing Leetcode problems thoroughly and understanding system design fundamentals to ace such interviews.
Application Process: The interview process was conducted over a single day (except for the online coding round). The first step was an online coding round, followed by two online face-to-face interviews, and finally an HR round. The results were announced later the same day at around 9 pm.
Interview Rounds:
Round 1 - Online Coding Round:
Questions Asked:
Two coding questions.
20 technical multiple-choice questions (MCQs).
Your Approach: Focused on solving the coding questions efficiently and ensuring accuracy in the MCQs.
Outcome: Cleared this round and moved to the next stage.
More in-depth technical questions, including system design and real-world problem-solving scenarios.
Your Approach: Demonstrated a structured approach to system design and discussed trade-offs.
Outcome: Cleared this round as well.
Round 4 - HR Round:
Questions Asked:
General HR questions about my background, career goals, and fit for the company.
Your Approach: Answered honestly and aligned my responses with the company’s values.
Outcome: Received positive feedback and moved forward in the process.
Preparation Tips:
Practice coding problems regularly, especially those involving data structures and algorithms.
Brush up on system design concepts and be prepared to discuss trade-offs.
Review your resume thoroughly, as technical interviews often delve into projects and experiences mentioned.
Conclusion:
The overall experience was smooth and well-organized. The technical rounds were challenging but fair, and the HR round was conversational. I would advise future candidates to focus on problem-solving skills and clarity in communication during interviews.
Application Process: I applied through my university’s placement process.
Interview Rounds:
Round 1 - Online Coding Round:
Questions Asked:
2 coding questions (moderate difficulty)
Technical MCQs covering topics like data structures, algorithms, OS, networking, and DBMS
Your Approach: I focused on solving the coding questions efficiently, ensuring optimal time and space complexity. For the MCQs, I relied on my fundamentals and eliminated incorrect options.
Outcome: Cleared this round and moved to the next stage.
Round 2 - Technical Interview 1:
Questions Asked:
In-depth questions on data structures and algorithms
Problem-solving scenarios and coding challenges
Basics of OS, networking, and DBMS
Your Approach: I explained my thought process clearly while solving problems and wrote clean, efficient code. For theoretical questions, I provided concise answers backed by examples.
Outcome: Successfully cleared this round.
Round 3 - Technical Interview 2:
Questions Asked:
More advanced DSA problems
System design basics
Questions on my preferred programming language (Java/Python/C++, etc.)
Your Approach: I tackled the problems methodically, discussing trade-offs and optimizations. For system design, I broke down the problem into smaller components and explained my reasoning.
Your Approach: I answered honestly, highlighting my strengths and learnings from past experiences. I also asked about the company culture and growth opportunities.
Outcome: Received positive feedback and moved forward in the process.
Preparation Tips:
Focus on mastering data structures and algorithms, as they form the core of the technical rounds.
Practice coding problems on platforms like LeetCode and GeeksforGeeks.
Revise the basics of OS, networking, and DBMS, as they are frequently tested.
Be thorough with at least one programming language and its nuances.
For the HR round, prepare answers for common behavioral questions and know your resume well.
Conclusion:
Overall, the interview process was structured and focused on both technical and behavioral aspects. I felt well-prepared for the technical rounds, but I could have practiced more system design questions. My advice to future candidates is to start early, build a strong foundation, and stay calm during interviews. Good luck!
Application Process: The application process was conducted remotely, with all rounds except the final one being held online. The process was smooth and well-organized.
Interview Rounds:
Round 1 - HR Screening:
Questions Asked: General questions about my background, experience, and interest in the role.
Your Approach: I kept my answers concise and focused on my relevant skills and enthusiasm for the position.
Outcome: Passed this round and moved to the next stage.
Round 2 - Data Structures and Algorithms (Conducted by Team Members):
Questions Asked: Problems related to data structures and algorithms, including coding challenges.
Your Approach: I practiced common DSA problems beforehand and explained my thought process clearly while solving the problems.
Outcome: Successfully cleared this round.
Round 3 - JavaScript (Conducted by Team Lead):
Questions Asked: Questions about JavaScript concepts, frameworks, and practical coding scenarios.
Your Approach: I revised core JavaScript concepts and frameworks, and demonstrated my problem-solving skills through live coding.
Outcome: Cleared this round as well.
Round 4 - System Design & Behavioural (Conducted by Engineering Manager):
Questions Asked: System design questions and behavioural questions to assess my problem-solving and teamwork skills.
Your Approach: I discussed my approach to designing scalable systems and shared examples of past experiences to answer behavioural questions.
Outcome: This was the final round, and I received positive feedback.
Preparation Tips:
Focus on core data structures and algorithms for technical rounds.
Revise JavaScript thoroughly, including frameworks and practical use cases.
Practice system design problems and be ready to discuss your thought process.
Prepare for behavioural questions by reflecting on past experiences and teamwork scenarios.
Conclusion:
The interview process with MakeMyTrip was well-structured and gave me a good opportunity to showcase my skills. The key to success was thorough preparation and clear communication during each round. I would advise future candidates to focus on both technical and soft skills to excel in such interviews.
Application Process: [Application process details not provided]
Interview Rounds:
Round 1 - Technical Interview:
Questions Asked: Questions were primarily focused on arrays and trees, typical for a fresher role. Some of the questions were similar to those found on GeeksforGeeks.
Your Approach: I prepared by revising data structures and algorithms, particularly arrays and trees, and practiced problems from GeeksforGeeks. During the interview, I tried to explain my thought process clearly and optimized my solutions where possible.
Outcome: The round went well, and I was able to answer most of the questions confidently.
Preparation Tips:
Focus on core data structures like arrays and trees, as they are commonly asked for fresher roles.
Practice problems from platforms like GeeksforGeeks to get familiar with typical interview questions.
Work on explaining your thought process clearly during the interview.
Conclusion:
The interview was a great learning experience. I felt well-prepared for the technical questions, but I could have practiced more to optimize my solutions further. For future candidates, I’d recommend thorough preparation on data structures and algorithms, especially those relevant to the role.
Application Process: I applied for the role of Software Engineer (SDE) through their online application process.
Interview Rounds:
Round 1 - Technical Interview:
Questions Asked:
A simple design question.
2-3 medium-level DSA (Data Structures and Algorithms) questions.
Your Approach: I focused on solving the DSA questions efficiently, ensuring I explained my thought process clearly. For the design question, I tried to break it down into smaller components and discussed the trade-offs of my approach.
Outcome: Passed this round. The interviewer seemed satisfied with my problem-solving approach.
Preparation Tips:
Practice medium-level DSA questions from platforms like LeetCode.
Brush up on basic system design principles to handle design-related questions confidently.
Ensure you can articulate your thought process clearly during the interview.
Conclusion:
Overall, the interview experience was smooth, and the questions were fair. I felt well-prepared, but I could have spent more time refining my design skills. For future candidates, I’d recommend balancing DSA practice with some basic design concepts to cover all bases.
Application Process: [Application process details not provided]
Interview Rounds:
Round 1 - Online Coding Assessment:
Questions Asked:
20 MCQs covering database, operating system, networking, and other CS fundamentals.
2 Coding Questions:
Dynamic Programming problem.
Graph data structure problem.
Your Approach: Focused on solving the coding questions efficiently while ensuring accuracy in the MCQs.
Outcome: Cleared the round.
Round 2 - Technical Interview 1 (1 hr):
Questions Asked:
Print the deepest node of a binary tree in a given sequence (Medium/Hard).
Given a series, print the nth sequence (Medium/Hard).
Your Approach: Used tree traversal techniques for the first question and pattern recognition for the second.
Outcome: Advanced to the next round.
Round 3 - Technical Interview 2 (1 hr):
Questions Asked:
Implement Binary Search.
Implement Binary Search in a sorted rotated array.
Reverse words of a given string.
Reverse a LinkedList.
Puzzle: Given 2 jugs (4 liters & 5 liters), measure 7 liters using the given jugs.
Your Approach: Solved the coding questions methodically and tackled the puzzle by breaking it down into steps.
Outcome: Successfully cleared the round.
Round 4 - Technical Interview 3 (1 hr):
Questions Asked:
Basic OOPs concepts, database, and operating systems questions.
2 Coding Questions:
Balanced string problem.
Modified balanced string problem.
Your Approach: Balanced theoretical knowledge with practical coding skills.
Outcome: Cleared the round.
Preparation Tips:
Focus on core CS fundamentals like databases, operating systems, and networking for MCQs.
Practice coding problems on Dynamic Programming, Graphs, Trees, and Arrays.
Revise OOPs concepts and puzzles for technical interviews.
Conclusion:
The interview process was rigorous but well-structured. Practicing a variety of coding problems and revising CS fundamentals helped a lot. For future candidates, I’d recommend focusing on problem-solving and understanding core concepts thoroughly.
Application Process: I applied through a referral. The HR contacted me and scheduled the interview. There were a total of 3 rounds, all of which were technical. The interviewers were very supportive throughout the process.
Interview Rounds:
Round 1 - Technical Interview:
Questions Asked: The interviewer asked about my previous projects, data structures, and algorithms. Specific questions included:
Explain a project you worked on and the challenges you faced.
Write a function to reverse a linked list.
Discuss time complexity for various sorting algorithms.
Your Approach: I explained my projects in detail, focusing on my contributions and problem-solving methods. For the coding question, I walked through my thought process before writing the solution and discussed the time complexity.
Outcome: I passed this round and moved to the next one.
Round 2 - Technical Interview:
Questions Asked: This round was more focused on system design and problem-solving. Questions included:
Design a URL shortening service like bit.ly.
How would you optimize a slow database query?
Your Approach: I started by clarifying requirements for the system design question and then broke it down into smaller components. For the database question, I discussed indexing and query optimization techniques.
Outcome: I successfully cleared this round as well.
Round 3 - Technical Interview:
Questions Asked: This round was a mix of coding and behavioral questions:
Solve a problem involving tree traversal.
How do you handle conflicts in a team?
Your Approach: I solved the coding problem efficiently and explained my approach. For the behavioral question, I shared a real-life example of resolving a team conflict.
Outcome: I cleared this round and received positive feedback.
Preparation Tips:
Focus on data structures and algorithms, especially linked lists, trees, and sorting algorithms.
Practice system design questions by breaking them down into smaller components.
Be ready to discuss your projects in detail, including challenges and solutions.
Conclusion:
Overall, the interview experience was smooth, and the interviewers were very supportive. I felt well-prepared, but I could have practiced more system design scenarios. My advice to future candidates is to thoroughly understand the basics and be confident in explaining your thought process.
Application Process: [Application process details not provided]
Interview Rounds:
Round 1 - Technical Interview:
Questions Asked:
Data structure and algorithm problems.
A database-based problem.
Questions about projects (with a focus on Android-specific topics).
Your Approach:
Focused on explaining data structures and algorithms clearly.
Demonstrated problem-solving skills for the database problem.
Clearly articulated project details, especially Android-related aspects.
Outcome: Positive feedback; advanced to the next round.
Preparation Tips:
Brush up on data structures and algorithms.
Be thorough with database concepts.
Practice explaining your projects clearly, especially if they involve Android development.
Conclusion:
The interview was a great learning experience. The interviewer was friendly and focused on problem-solving skills. I could have prepared more for Android-specific questions, but overall, it went well. For future candidates, make sure to practice both theoretical and practical aspects of your projects.