Recruitment Mode: On-Campus Placement
Difficulty: Easy

1. Online Assessment

Date: 9th August | Duration: 3 hours 21 minutes | Mode: On-Campus

The assessment was conducted on the college premises and consisted of six sections:

• Logical Reasoning: 20 questions

• Numerical Ability: 20 questions

• Verbal Ability: 20 timed fill-in-the-blank questions

• Email Writing

• Advanced Numerical and Logical Reasoning: 14 questions

• Coding: 2 questions

Note: Due to an initial system glitch, my system had to be changed during the assessment. As a result, I could solve only one of the two coding questions.

Coding Questions

1. Min-Heap - Patient Priority Management

Implement a min-heap to manage patients based on their priority numbers.

• 1 x: Insert a patient with priority x into the heap.

• 2: Remove and print the patient with the minimum priority. If the heap is empty, display an appropriate message.

2. Modified Selection Sort

Implement selection sort with a modification: perform only P passes instead of completing the entire sorting process.

Shortlisting

The assessment took place on 9th August, and the interview shortlist was announced on 13th August. I was shortlisted for the TCS Prime interview.

Technical + HR Interview

Date: 14th August | Duration: Approximately 45 minutes | Location: TCS Indore Campus

While most candidates had two separate interview rounds, I had a single combined Technical + HR interview.

Questions Asked

1. Introduction & Resume Discussion

• Self-introduction, resume, projects, and favourite subjects.

• Since I mentioned DBMS as one of my favourite subjects, the discussion primarily focused on DBMS and SQL.

2. SQL

• Rename a column using the ALTER TABLE statement.

• Find employees earning the third-highest salary using window functions, considering duplicate salaries and ranking.

I asked clarifying questions before writing the queries, and the interviewers were satisfied with my solutions.

3. Data Structures & Algorithms

• Implement Bubble Sort.

• Check whether a number is prime.

I successfully implemented both solutions, and the interviewers were satisfied with my approach.

4. DBMS & Data Engineering

• Difference between a database and a data warehouse.

• Questions about my projects and their technical implementation.

5. OOPs & SDLC

• Differences between encapsulation, abstraction, and polymorphism.

• Different phases of the Software Development Life Cycle (SDLC).

6. AI & Cloud Computing

• Difference between Generative AI and Agentic AI, explained with an example.

• Basics of Platform as a Service (PaaS) and Software as a Service (SaaS).

7. HR Questions

• My strengths and what makes me stand out as a technically oriented candidate.

Overall, the interview covered a mix of fundamental CS concepts, SQL, DSA, project discussions, emerging technologies, and HR questions.

Final Outcome: Selected for TCS Prime

Hi, I’m Riya Dhabuwala, a Computer Science and Engineering student at Nirma University, Ahmedabad, with a CGPA of 9.0. I’m passionate about software development, problem solving, and AI/ML.

My placement journey took me to JPMorgan Chase & Co., where I joined as a Software Engineer Program Intern and later received a full time offer.

The DSA Skills I Built Along the Way

takeUforward played an important role in my DSA preparation. I primarily used it to understand concepts in a structured way and then put those concepts into practice through problems.

What helped me most was the clarity of the explanations. Instead of simply memorising solutions, I focused on understanding the reasoning behind them and learning how to approach different types of problems.

Over time, this helped me become more comfortable with unfamiliar questions and gave me the confidence to tackle DSA based coding rounds.

From Concepts to Problem Solving

My preparation started with getting my DSA fundamentals right and then gradually building consistency through regular practice.

I covered important areas such as:

• Arrays and Strings

• Linked Lists, Stacks and Queues

• Trees and Graphs

• Recursion and Dynamic Programming

• Common problem solving patterns

The focus was never just on finishing topics. I wanted to understand the patterns behind the problems and become faster at recognising which approach could work.

Alongside DSA, I also prepared core CS subjects, projects, and communication skills so that I was ready for different stages of the placement process.

The First Real Test of My Preparation

The JPMorgan Chase selection process gave me an opportunity to put my preparation to the test. The initial stage involved DSA based questions, where the fundamentals and problem solving approach I had built became especially useful.

Being able to break down a problem, think through the approach, and arrive at a solution gave me the confidence to move through the technical stages.

Eventually, I secured the Software Engineer Program internship.

The Internship Wasn’t the Finish Line

• Getting the internship was a major milestone, but there was still another step ahead.

• During my internship, I had the opportunity to learn in a professional environment and apply what I had prepared for beyond coding rounds. After completing the internship, I was fortunate to receive a full time offer from JPMorgan Chase & Co.

• That made the journey even more meaningful because the preparation had taken me from learning DSA to securing an internship and eventually converting it into a full time opportunity.

Build Before You Chase

My biggest advice is to focus on consistency rather than trying to finish everything as quickly as possible.

• Build your DSA fundamentals properly.

• Understand the logic instead of memorising solutions.

• Learn from the problems you get wrong.

• Revise concepts and patterns regularly.

• Balance DSA with core CS subjects and projects.

• Work on your communication so you can explain your thinking clearly.

• Don’t let difficult problems or rejections discourage you.

You don’t need to have everything figured out at once. Keep improving one step at a time.

The Work That Led Me Here

Looking back, my journey was built through small improvements over a long period of time. takeUforward gave me a structured way to learn DSA and helped me develop the problem solving foundation I needed for technical interviews.

What started with learning concepts and solving problems eventually led to an internship at JPMorgan Chase & Co., and that internship later became a full time opportunity.

I’m genuinely grateful to takeUforward for being a part of this journey and for helping me build the confidence to take the next step in my career.

Amazon is hiring a Software Development Engineer II for its India CFX team. This opportunity is suited for experienced software engineers interested in designing and building large-scale distributed applications and customer-focused technology solutions.

Job Details

• Company: Amazon

• Role: Software Development Engineer II (SDE II)

• Team: Amazon India CFX

• Location: Haryana, India

• Experience: 4-8 years

• Job Type: Full-time

• Job ID: 10578008

What You'll Work On

• Design and develop software solutions for broadly defined problems.

• Build and support large-scale, multi-tiered distributed applications and tools.

• Contribute to system architecture and design decisions.

• Improve engineering standards, system reliability, and performance.

• Collaborate with engineers in an Agile development environment.

• Deliver high-quality software supporting Amazon's customer experience and cost-efficiency initiatives.

Basic Qualifications

• 4+ years of professional, non-internship software development experience.

• 4+ years of experience in software design or architecture, including design patterns, reliability, and scaling.

• Programming experience in at least one software development language.

Preferred Qualifications

• 4+ years of experience across the software development lifecycle, including coding standards, code reviews, source control, builds, testing, and operations.

• Bachelor's degree in Computer Science or equivalent.

Why Consider This Role?

• Work on products and technologies serving customers at scale.

• Solve challenges involving distributed systems, performance, and reliability.

• Collaborate with engineers across different architectures and technologies.

Apply Now

https://www.amazon.jobs/en/jobs/10578008/software-dev-engineer-ii-amazon-india-cfx-team

• Role: SDE-2 (Backend)

• Result: Selected

• Interview Rounds: AI-Assisted Machine Coding, followed by two technical rounds

I reached out to a recruiter through a cold email and received a call the very next day. My first interview was scheduled for the following day.

Before the technical rounds, I also had an AI-assisted machine coding round, which I cleared. After that, I proceeded to the following interview rounds.

Round 1: Problem Solving / DSA (1.5 Hours)

This round focused on algorithmic problem-solving, optimization, and efficient data structures.

1. Maximum Sum Matrix from Row and Column Maximums

Given an array containing the maximum value of each row and another containing the maximum value of each column, determine the maximum possible sum of a matrix satisfying those constraints.

Example:

rows = [2, 5, 8]
columns = [6, 7, 8]

Maximum-sum matrix:
[[2, 2, 2],
 [5, 5, 5],
 [6, 7, 8]]

Maximum sum = 42

• Time Complexity: O(N + M), excluding sorting.

• Auxiliary Space: O(1).

2. Next Element with a Higher Frequency

Given an integer array, find the closest element to the right whose frequency in the array is greater than the frequency of the current element.

The problem was similar to Next Greater Element, but the comparison was based on element frequencies rather than values. A stack-based approach could be used to efficiently identify the next qualifying element.

The related problem mentioned during the discussion was Next Greater Element, with the frequency-based comparison adding a different condition.

I received positive feedback for this round on the same day, and the second round was scheduled for the following day.

Round 2: DSA + Hiring Manager (1.5 Hours)

Problem: Parking Lot Slot Allocation

The interviewer asked me to design a parking lot system supporting allocateSlot and vacateSlot operations.

The parking lot consisted of z floors, each containing x rows and y columns. The entry point was at coordinates (0, 0, 0).

For simplicity, the distance of a parking slot from the entry point was defined as:

distance = floor + row + column

If multiple slots had the same distance, the selection priority was:

1. Smallest floor number.

2. Smallest column number.

3. Smallest row number.

A priority queue could be used to maintain available slots in the required order, along with a three-dimensional data structure to track slot availability.

The interviewer also asked detailed questions about my previous projects, current responsibilities, team leadership experience, and behavioral scenarios. Although the round was initially scheduled for one hour, it extended to approximately 1.5 hours because of the in-depth discussion.

I received positive feedback the following day.

Final Verdict: Selected

The process involved AI-assisted machine coding, DSA, a parking lot design problem, and an in-depth discussion of previous projects and leadership experience.

Role: SDE-2
Location: Bengaluru
Team: Alexa
Result: Rejected

Interview Process and Timeline

The interview process took place between August and September 2026 and included a phone screening followed by four interview rounds. The interviews covered DSA, LLD, HLD, and Amazon Leadership Principles.

Phone Screening

The interviewer began with my introduction and questions about my responsibilities at my current company. I was asked to discuss challenging and impactful work, including one implementation in detail using the STAR format.

Coding Problem: Longest Continuous Subarray with Sum Zero

Given an array, find the longest contiguous subarray whose sum equals zero.

Example:

Array = [6, 3, -3, 2, -2, 5, -5, 4]

Output: Length = 6
Subarray = [3, -3, 2, -2, 5, -5]

The optimized approach uses prefix sums and a hash map, with O(n) time and O(n) auxiliary space.

Round 1: Low-Level Design (LLD)

The main question was to design an in-memory logging system where multiple modules generate logs that must eventually be written to a flash partition with a capacity of 96 KB.

The discussion involved log collection, memory management, buffering, and handling limited storage efficiently.

Leadership Principles:

• Have Backbone; Disagree and Commit: A situation involving disagreement with a decision.

• Deliver Results: Delivering a project or task under a tight deadline.

Round 2: High-Level Design (HLD)

I was asked to design a smart thermostat capable of transmitting data over the air. The discussion started with the software components and then moved toward the device's input components, communication, and overall architecture.

Leadership Principles:

• Ownership: A time I took responsibility for a problem outside my assigned role.

• Bias for Action: A situation where I took a calculated risk during a project.

Round 3: Data Structures and Algorithms (DSA)

The interviewer mentioned that two coding problems would be asked, but I managed to solve only one.

Problem: Minimum Removals from Either End to Reach a Target Sum

Given an array of positive integers and a target x, remove elements only from the left or right end until their sum equals x. Return the minimum number of operations, or -1 if impossible.

Example:

readings = [2, 5, 1, 3, 4]
x = 9

Output: 2

Remove 5 and 4 to obtain a total of 9 in two operations.

The optimized approach is to find the longest subarray whose sum equals totalSum - x, using a sliding window.

• Time complexity: O(n)

• Auxiliary space: O(1)

The interviewer also asked about my use of AI tools in engineering workflows, including their applications in debugging and firmware bring-up.

Leadership Principles:

• Dive Deep

• Customer Obsession

Round 4: Bar Raiser

The interviewer was a Software Engineering Leader from another team. Despite some network issues, the discussion was friendly and comfortable.

I was given two coding options and could choose either one.

Problem 1: Implement an LRU Cache

Implement an LRU cache with average O(1) get and put operations using a hash map and a doubly linked list.

Problem 2: Group Anagrams

Given a list of strings, group those that contain the same characters.

Example:

Input:
["arc", "car", "elbow", "below", "state", "taste"]

Output:
[["arc", "car"], ["elbow", "below"], ["state", "taste"]]

I chose the anagram problem. The interviewer asked three follow-up questions involving streaming inputs, input separation, and edge cases. I was also asked to explain the time and space complexity. The discussion lasted approximately 30 minutes.

Leadership Principle: Insist on the Highest Standards

Behavioral questions included:

• A disagreement with my manager.

• Convincing my manager to consider a different approach.

• A failure I experienced and how I recovered from it.

Overall Experience

The interview covered coding, system design, and behavioral questions. The technical rounds tested problem-solving, optimization, design fundamentals, and the ability to handle follow-up requirements.

The Leadership Principles were equally important throughout the process. Preparing examples from previous projects and practicing coding problems with edge cases and complexity analysis would be valuable for candidates preparing for similar Amazon SDE-2 interviews.

Although I was rejected, the experience provided useful insights into Amazon's interview expectations and areas to improve for future opportunities.

First-round interview for an Amazon SDE-1 / Intern opportunity through off-campus hiring. Before the interview, there was an online assessment based on a new pattern.

The interview itself lasted around 60 minutes and covered Amazon's Leadership Principles along with two DSA problems. The focus was not just on getting the correct answer but also on explaining the approach and discussing possible optimizations.

Interview Process

Round 1: Leadership Principles and DSA

1. Leadership Principles (Around 10 minutes)

The interview started with a brief introduction, followed by behavioral questions based on Amazon's Leadership Principles. This part focused on how I approach situations, make decisions, and handle challenges.

2. DSA Coding (Around 50 minutes)

The remaining time was spent solving two coding problems. The interviewer expected me to explain my reasoning, compare brute-force and optimized approaches, discuss time and space complexity, and consider edge cases while writing the code.

The questions were based on the following topics:

• Tree: Maximum Subtree Sum (with a slight modification).

• Sliding Window: Minimum Window Substring.

Both questions required a clear understanding of the underlying concepts and the ability to explain the solution step by step.

I appeared for HSBC’s on-campus internship process, which had four rounds. The experience was a mix of English and aptitude questions, coding, technical discussions, and HR questions. Each round covered something different, so it wasn’t just about solving DSA problems.

I was selected for the summer internship, with Pune or Hyderabad as the possible locations and a stipend of ₹50,000.

Round 1: Behavioural and English Assessment

The first round was mainly about English communication and understanding questions correctly. Most questions came in audio format, so I had to listen carefully before answering.

The questions covered:

• Listening comprehension and paragraph-based questions.

• Puzzles and pattern-based reasoning.

• Basic grammar, including prepositions.

• English language and verbal aptitude.

This round was more about comprehension, accuracy, and logical thinking than technical knowledge.

Round 2: DSA and Coding Assessment

The second round was an online assessment that covered coding, debugging, and working with data. There were a few different types of questions, so I had to switch between programming concepts and practical problem-solving.

Some of the topics included:

• DSA: Reversing a linked list and searching in a Binary Search Tree (BST).

• Debugging: Finding errors in a given piece of code and figuring out how to fix them.

• SQL and Python: A task involving an Excel sheet and concepts related to SQL and Python.

• AI assistance: An AI assistant was available during the assessment.

The round tested basic coding skills, the ability to understand existing code, and familiarity with data-related tasks.

Round 3: Technical Interview

This round started with an introduction and a discussion about my projects and DSA preparation. The interviewer also asked a couple of logical reasoning and pattern-based questions.

Question 1: Day-of-the-Week Pattern

I was given a question based on the sequence of weekdays, such as Monday, Tuesday, Wednesday, and so on. The pattern continued over a period of two weeks, and I had to work through the given conditions to figure out the required day.

Question 2: Number Pattern

The interviewer gave me the following sequence:

24, 45, 56, 67, 78

I had to look for the pattern in the numbers and work out the required result. The interviewer indicated 78 as the relevant answer.

Apart from these questions, the discussion around my projects and problem-solving approach was also important. I had to explain my thinking rather than just jump to an answer.

Round 4: HR Interview

The final round was more conversational and focused on my background, previous experience, and expectations from the internship.

Some of the questions I was asked were:

• Tell me about yourself.

• What do you remember from the presentation session conducted about a month earlier?

• Have you done any internships before?

• What are your expectations from HSBC?

This round was a chance to talk about my experience, explain my interests, and share what I was looking for from the internship.

Final Outcome

I’m happy to share that I got selected for the HSBC summer internship with a stipend of ₹50,000. The available locations were Hyderabad and Pune.

I interviewed for a Senior Backend Engineer position at Apollo.io in September 2026. With over 7 years of experience.

Exploratory Call with the Engineering Manager

The initial conversation covered my previous projects, experience working with systems at scale, and approach to AI-driven coding. The engineering manager also introduced the team and discussed its work.

Round 1: AI-Assisted Coding

The main technical round involved fixing three issues in a large, poorly written codebase within 90 minutes.

The project ran inside Docker and resembled a Stack Overflow-style question-and-answer platform. Its frontend was served directly by a backend application written in Go.

AI tool constraints: Only mid-tier models, such as Claude Sonnet, were permitted, Claude Opus was not allowed.

Approach and Challenges

I investigated the reported issues, examined the relevant code, identified the root causes, and asked Claude to implement the fixes. However, one of the issues was not resolved correctly.

In retrospect, I felt the expected approach might have involved initializing Claude, providing it with all three issues upfront, allowing it to investigate the codebase independently, and parallelizing the tasks after initialization.

This made the round particularly interesting because it tested not only debugging skills but also how effectively AI tools could be used to navigate an unfamiliar codebase and solve multiple problems within a strict deadline.

Result: Rejected

I did not receive formal feedback, so the rejection was my own assessment rather than a confirmed decision.

With 4.5 years of experience and a current compensation of 33 LPA, I interviewed for a Senior Software Engineer position at Multiplier in October 2026. The process included a recruiter screening focused on AI experience and a basic DSA question, followed by an AI-assisted coding round involving API design and implementation.

Round 1: Recruiter Screening

The first round was a short call with the recruiter. Most of the discussion revolved around my experience using AI tools in software development and some basic questions about different AI models and their capabilities.

I was also asked one basic DSA question on Level Order Traversal of a binary tree. I only needed to explain the approach, not write the complete code.

Round 2: AI-Assisted Coding

The technical round involved designing and implementing an API for bulk employee uploads. The API was expected to call an internal employee API to persist employee records.

I spent some time clarifying the requirements before using Claude to build the solution. After implementing the functionality, I cleaned up the code and focused on making the design extensible. I then walked the interviewer through my implementation and explained the decisions behind it.

Towards the end, the interviewer asked me to make a change to the code without using AI. Since the specific change wasn't defined, I was a little confused about what exactly was expected from this task.

Result: Rejected.

My interview journey with Snabbit for the SDE-3 role involved a mix of coding challenges, system design problems, and discussions around engineering leadership. With around six years of experience at a product-based company, I found the process covered both technical depth and the ability to make sound decisions as a senior engineer.

Interview Process

• Round 1: Machine Coding and Low-Level Design

• Round 2: High-Level System Design

• Round 3: Hiring Manager Discussion

Round 1: Building a Twitter-Like Application

The first round was a practical design-and-coding exercise. I was asked to build a basic Twitter-like application in Java, with the constraint that no database would be used.

The application needed to support four primary operations:

• Publishing a tweet.

• Following another user.

• Unfollowing an account.

• Generating a feed containing the latest K tweets from the user and the accounts they follow.

An important part of the problem was maintaining the correct order of tweets using timestamps or sequence numbers.

After discussing the requirements, we explored different data structures for implementing the functionality efficiently. I considered using a PriorityQueue to retrieve the most recent tweets, but this brought up questions about accessing the top K elements without removing entries from the queue.

I also discussed an alternative using a TreeMap and compared the trade-offs between the approaches.

For the final part, I used an AI-assisted coding tool to implement the LLD based on the design notes we had discussed. The exercise was less about simply writing code and more about choosing the right data structures, explaining the design, and translating the solution into a working implementation.

Round 2: Designing a Scalable Like-Counting System

The next round moved from application-level design to system architecture.

Problem statement: Design a service that tracks likes on videos for a large video-streaming platform.

The main challenge was to build a system that could process a huge number of like requests while providing accurate counts and fast responses when users viewed videos.

We discussed how to handle simultaneous updates, prevent increments from being lost, and choose suitable storage for maintaining like counts. Read performance was another important consideration, since the service would need to return counts quickly even as traffic increased.

The conversation also covered scalability and reliability as the platform grew in terms of both users and videos.

This round tested my ability to reason about system bottlenecks, data consistency, concurrent operations, and architectural decisions under high traffic.

Round 3: Hiring Manager Interview

The last round was more focused on my experience and how I work with people and teams.

The interviewer asked questions around my current responsibilities, motivation for joining Snabbit, and approach to mentoring and collaboration.

A few questions from the discussion were:

• What have been your major contributions at your current organization?

• Why do you want to work at Snabbit?

• How do you approach mentoring less-experienced engineers?

• Describe a disagreement with a product or business team and how you handled it.

• How do you manage priorities and deliver results in a fast-moving environment?

The discussion focused on taking ownership, helping other engineers grow, resolving conflicts constructively, and balancing technical decisions with business requirements.

Final Result: Selected

I cleared all three rounds and was selected for the SDE-3 position at Snabbit.

Sharing this in the hope that it gives other experienced engineers a useful reference while preparing for similar opportunities.