Recruiter reached out to me on LinkedIn for a Staff Software Development Engineer position at JioHotstar (JioStar), Bangalore. The interview process started a few days later and consisted of five rounds.

Role: Staff Software Development Engineer
Company: JioHotstar (JioStar)
Location: Bangalore

Round 1 - AI-Assisted Coding and LLD

Duration - (90 Minutes)

Before the interview, I was asked to set up an AI assistant and use an IDE of my choice.

Problem: Design a Workflow Management Service

Each workflow could contain a fixed number of tasks belonging to predefined task types. I started by clarifying requirements, defining entities and models, and discussing API design with the interviewer.

Once the design was approved, I used an IDE-integrated AI agent to implement the solution incrementally, reviewing and refining the generated code along the way.

The interviewer also explored design patterns and concurrency concepts. I completed the implementation with around 20 minutes remaining, which we used to discuss possible HLD extensions. Overall, this round went really well.

Round 2 - High-Level Design

Duration - (90 Minutes)

Problem: Design Hotstar's Live Viewer Counter

The objective was to design a scalable system to display the number of people watching a live stream.

I was able to address the follow-up questions, with particular focus on scalability and the trade-offs between read fanout and write fanout.

My experience building large-scale distributed systems helped me approach the problem from a practical engineering perspective.

Round 3 - Bar Raiser

This round was conducted by a Software Architect.

The first half focused on my previous projects, professional experience and how I handled conflicts and disagreements at work.

The second half involved a design problem:

Problem: Design a Clickstream Aggregator to Track Advertisement Clicks on Hotstar.

The discussion focused on designing a system to track and aggregate advertisement clicks. This round also went quite well, and we finished with some time to spare.

Round 4 - Managerial Interview

This was a general discussion covering:

• Projects and accomplishments I was proud of.

• Expectations from my next role.

• Experience with large-scale systems and end-to-end project ownership.

• Mentoring other engineers.

• How I use AI in my day-to-day engineering work.

About a week later, the recruiter confirmed that all technical rounds were complete and scheduled an HR discussion.

Round 5 - HR Discussion

The final round was fairly standard, covering my previous experience, expectations and what I was looking for in my next role.

Outcome

After the HR discussion, I waited for approximately two week before following up with the recruiter.

I was told that an update would be shared within a day, but unfortunately, I never received one. I decided not to follow up again. I didn't receive a formal rejection or detailed feedback.

Three rounds, multiple DSA problems and a few unexpected twists in the final interview.

My DP World SDE 1 interview journey was a mix of familiar problems and new challenges that pushed me to think beyond standard approaches.

Role: Software Development Engineer 1
Company: DP World

Round 1 - Online Assessment

The first stage was an online assessment. I don't remember the exact questions, but the overall pattern included three sections:

• MCQs: Questions based on REST, HTTP, APIs, databases and related fundamentals.

• DSA: Two coding problems of easy to medium difficulty, similar to LeetCode questions.

• SQL: One SQL-based problem.

I was able to clear the assessment and move to the technical interview.

Round 2 - DSA Interview (60 Minutes)

The discussion in this round revolved around Dynamic Programming.

Question: Longest Common Subsequence

I had practised similar DP problems before, so I started by explaining the recursive approach and then moved towards memoization.

After implementing the memoized solution, I discussed the tabulation approach and explained how the DP table could be used to reconstruct the actual longest common subsequence.

The interviewer also asked about the possibility of optimizing the space complexity. I walked through a few test cases and explained the time and space complexity of the different approaches.

Overall, I felt confident about my approach and was able to explain the optimizations clearly.

Result: Selected for the next round.

Round 3 - DSA Interview (60 Minutes)

This round consisted of two problems involving stacks and arrays.

Problem 1: Next Greater Element

I started by discussing the brute-force approach, where I would traverse the elements to the right of each element to find the nearest greater value.

Then I explained how a monotonic stack could optimize the solution to linear time complexity.

I implemented the optimized approach, discussed the edge cases and walked through a few test cases.

Problem 2: Intersection of Two Sorted Arrays

Since both arrays were sorted, I discussed using two pointers to find the common elements efficiently. I explained how to move the pointers based on the comparison between the current elements and how to handle duplicate values correctly.

The goal was to produce the intersection while maintaining the required order and avoiding unnecessary comparisons.

Unfortunately, I couldn't fully satisfy the interviewer with my overall performance in this round.

Final Result: Not Selected.

Unfortunately, I couldn't fully solve the second problem.

Final Result: Not Selected.

Sharing my experience in the hope that it helps others preparing for SDE 1 interviews.

Experience: 6 Years
Current Company: Flipkart
Role: Cloud & AI Engineer
Location: Bengaluru
I recently went through the interview process for a Cloud & AI Engineer position at IBM, Bengaluru.

Round 1 - Technical Interview

The first round was primarily focused on my professional experience, project architecture and technical fundamentals. Unlike a typical DSA-heavy interview, the discussion leaned more towards practical engineering knowledge.

Project and Experience Discussion

The interviewer started by asking about my current responsibilities and recent projects. I was asked to explain the high-level design, architecture and my individual contributions.

I discussed my experience working on fleet telemetry, observability and event-driven systems. The interviewer wanted to understand the actual implementation and the engineering decisions behind the projects.

Docker and Kubernetes

We then moved to containerization and orchestration concepts. The questions focused on Docker and Kubernetes fundamentals, along with my hands-on experience using these technologies.

Coding Questions

I was given two coding problems:

• Insert a node at the Kth position in a linked list.

• Merge two sorted arrays without using extra space.

I was able to solve both questions successfully and cleared the first round.

Round 2 - Technical Interview

The second round went deeper into my project experience and covered several areas of cloud infrastructure, Linux, networking, security and AI.

Here are the topics and questions discussed during the interview.

1. Projects and Linux

• Explain your recent projects and the architectural decisions involved.

• What is Linux inotify, and where have you used it?

• What happens when inotify generates duplicate notifications?

2. Cloud and Kubernetes

• How is Kubernetes different from OKE?

• What is Helm?

• How do Helm charts simplify application deployments in Kubernetes?

3. Networking and Security

• What are the differences between REST and gRPC?

• TLS vs mTLS - how do they differ?

• How does certificate verification work?

• Why does a browser sometimes display a certificate warning with an Advanced/Proceed option?

4. AI and Vector Databases

This section focused on vector databases and semantic search.

• What is a vector database?

• Where have you used vector databases?

• How does semantic similarity work?

• How would a system differentiate between Saswat and saswat and determine which one is more relevant?

5. Coding Question

The final coding problem was:

I was able to solve this problem successfully.

Unfortunately, I wasn't selected after the second technical round.

Round 1: DSA

This was the toughest round, but also the most fun.

I first thought the problem was a DP one and started working in that direction. It didn’t feel right, so I tried a brute-force approach with DFS and backtracking. That worked, but it was slow and messy. Then I noticed I could treat it as a graph problem and solve it with Dijkstra’s Algorithm. That was the cleanest solution of the three.

I explained and coded all three approaches within the time. The interviewer didn’t just want the final answer. He kept asking why I switched approaches and what made me change my mind, so it felt more like a discussion than a test.

Round 2: DSA

This round was much easier. The question was to split an array into k subarrays so that the largest subarray sum is as small as possible.

It’s a classic Binary Search on Answer problem. I explained how to check whether a given sum is possible, and then coded it. It went smoothly and helped me feel more relaxed after the first round.

Round 3: Projects and Internship

This round was mostly a conversation. We talked about my projects in detail: how I built them, why I chose certain things, and what problems I faced along the way.

Then we moved on to my internship, what my work was and what I contributed. At the end, we also talked about the role itself and what the team expects from someone in this position.

Round 4: HR

A simple and friendly round. The usual HR questions came up, along with my salary expectations. We also talked about Gurugram possibly being the PPO location.

Result

Still waiting to hear back.

Role: Member of Technical Staff (MTS)
Location: Bangalore
Experience: 2 years
Tech Stack: Java, Spring Boot, Kafka, PostgreSQL, React

My experience, primarily in backend development, so I was comfortable discussing Java, Spring Boot, Kafka, and databases.

I recently appeared for the Member of Technical Staff (MTS) interview process at Salesforce

Round 1: DSA (2 Coding Questions)

The first round focused entirely on DSA. Both questions were around medium-to-hard difficulty.

I don't remember the exact problem statements, but the patterns were:

• Sliding Window + Two Pointers: The problem involved finding the maximum number of requests within a given time window. It required using a variable-size sliding window, and it took me some time to identify the right approach.

• Sliding Window + HashMap: This problem was based on the Minimum Window Substring pattern, involving character frequency tracking and window adjustments.

I spent more time than expected on the first question, especially while handling edge cases and follow-up discussions. Unfortunately, I couldn't get enough time to code the second solution.

Instead of rushing through the implementation, I explained my approach to the interviewer, including the data structures I would use, how the window would move, and the expected time and space complexity.

Honestly, I logged off thinking I wouldn't make it to the next round because the process was eliminatory. However, around an hour later, the recruiter called and informed me that I had cleared the round.

Round 2: DSA + Low-Level Design (LLD)

This round covered both problem-solving and system design.

DSA Question

I was asked a medium-level interval-based problem involving merging overlapping time intervals and returning a consolidated list of non-overlapping intervals.

The main challenge was handling overlapping ranges correctly while maintaining the sorted order of intervals.

LLD: Movie Ticket Booking System

For the design part, I was asked to design a movie ticket booking platform similar to BookMyShow.

The expected functionality included allowing users to select a city, movie, showtime, and seats before completing the payment.

I covered the major entities, their relationships, and the overall booking flow. Some important aspects I discussed were:

• Designing classes for users, movies, theatres, shows, bookings, and seats.

• Managing seat availability during the booking process.

• Implementing seat locking to prevent two users from booking the same seat.

• Handling failed payments and expired seat reservations.

• Maintaining consistency throughout the booking workflow.

Overall, I felt the round went well, and I received positive feedback from both the first and second rounds.

One important piece of feedback I received was that I needed to write more of my explanations in the shared document. I was explaining concepts verbally, but the interviewer expected me to document more of the implementation details.

I realized that during an LLD interview, the shared document is essentially the final answer. Every class, attribute, method, and relationship discussed should also be represented in the design.

Don't prepare only DSA for MTS roles. LLD can be equally important, so make sure you practice translating your verbal explanations into an actual design.

Round 3: Hiring Manager (Director)

For this round, I had prepared High-Level Design. I had also revised my previous projects.

However, the discussion took a different direction.

The director opened my resume and went through it line by line. Most of the conversation revolved around my previous projects, the technical decisions I had made, and my understanding of the systems I had worked on.

Some of the questions included:

• How did I build this particular project?

• Why did I choose Kafka for this use case?

• Why did I select a particular database?

• What technical challenges did I face, and how did I resolve them?

• If I were rebuilding the same system today, what would I do differently?

I was also asked a couple of managerial and behavioral questions:

• How do I use AI in my day-to-day development work?

• Why do I want to join Salesforce?

The AI-related question was particularly interesting. I was expected to explain how I use AI to improve productivity, which tasks I trust it with, and where I prefer to validate everything manually.

My takeaway: Be thoroughly prepared to discuss everything mentioned in your resume. Understanding the reasoning behind your technical decisions is just as important as knowing how to implement them.

If you're preparing for a similar role, I would recommend focusing on:

• Practicing medium-to-hard DSA problems, especially sliding window, two pointers, hashing, and intervals.

• Preparing LLD problems such as movie booking systems.

• Revising your projects in depth and understanding every technology mentioned in your resume.

• Preparing for questions around AI tools and their practical use in software development.

One thing I learned is that your resume isn't just a summary of your experience; every technical decision mentioned in it can become an interview question.

Platform: HackerRank
Duration: 60 minutes
Language: Python

The interview was conducted with one primary interviewer and another interviewer observing the session. I was also given the option to use HackerRank's built-in AI assistant.

There was no starter code provided, so I had to design the class structure and implement all the required methods from scratch.

Problem 1: Delivery Cost Calculation

The interviewer presented a food delivery-related problem involving multiple drivers and their deliveries. I was asked to build a service that could calculate the total delivery cost.

The initial implementation required three methods:

• addDriver(driverId) - Register a new driver.

• addDelivery(startTime, endTime) - Record a delivery.

• getTotalCost() - Return the cumulative cost of all deliveries.

One important requirement was to make getTotalCost() efficient.

Instead of iterating through all deliveries every time the method was called, I maintained the running total whenever I added a new delivery. This allowed me to retrieve the total cost in constant time.

The interviewer tested my implementation using several custom test cases, and all of them passed. He was also satisfied with my optimization approach.

Problem 2: Extending the System with Payments

Once I completed the basic implementation, the interviewer introduced additional requirements.

I was asked to support two more operations:

• payUpToTime(upToTime) - Calculate and settle all delivery costs up to a specified timestamp.

• getCostToBePaid() - Return the outstanding amount that has not yet been paid.

For this part, I proposed using a global priority queue to maintain delivery entries ordered by their timestamps. I also used epoch-based timestamps to handle time-based calculations.

My approach was to process eligible delivery entries whenever a payment was made, maintain the amount already paid, and calculate the outstanding balance using:

costToBePaid = totalCost - paidCost

The interviewer agreed with my general approach, and I proceeded with the implementation.

I also discussed rate updates and how effective timestamps should influence delivery costs. I wrote sample test cases in main() to validate my implementation, but spent additional time debugging these timestamp-related scenarios.

Final Result: Rejected.

• Company: EPAM Systems

• Role: Junior Software Engineer

• Monthly In-Hand: Approximately ₹60,000

• Result: Selected

Online Assessment

It included aptitude questions and two coding problems. I managed to solve one coding question and was shortlisted for the next stage.

Round 1: Written Coding Test

I had to solve programming questions on paper without using an IDE.

One problem involved combining values belonging to the same name and calculating their final totals.

For example:

Input:
Aman 12
Neha 35
Aman 28
Ravi -15
Neha -35
Ravi 25

Output:
Aman 40
Ravi 10

I used a HashMap in Java to maintain the total for each name. After the evaluation, I was shortlisted.

Round 2: Group Discussion

The topic was "How Has UPI Changed Financial Transactions in Rural India?"

I discussed how UPI helps rural shopkeepers accept digital payments, maintain transaction records, track sales, and manage their businesses more efficiently.

There were around ten participants, and five were selected. I was among them.

Round 3: Technical Interview

The interviewer began with my introduction and asked about my coding practice. He appreciated that I had solved more than 400 programming problems.

The discussion covered:

• Valid Parentheses

• Recursive Binary Search

• Abstract class vs. interface in Java

• Storing images in SQL and alternative approaches

• REST APIs

• MongoDB vs. SQL databases

• My projects and their architecture

I struggled with the image-storage question, and the interviewer explained the concept. We also discussed my projects in detail.

Round 4: Technical Interview

I was informed that another technical evaluation was required. This round mainly focused on React and frontend development.

Some questions were:

• How do you structure a React project?

• How do you fetch and display backend data?

• What is useEffect, and how does its dependency array work?

• What happens when the dependency array is omitted?

• How can an infinite rendering loop occur?

• How do you pass data between parent and child components?

• What are different approaches to state management?

I missed a few details while explaining useEffect. The interviewer clarified that without a dependency array, the effect runs after every render. If it continuously updates state, it can cause repeated renders.

We also discussed Context API and Recoil, followed by behavioural questions about teamwork, disagreements, code quality, and learning new technologies.

Round 5: HR Interview

The HR discussion covered my background, projects, achievements, other offers, and reasons for joining EPAM.

I was also asked why I was looking for another opportunity after recently joining Cognizant. I explained that I had joined around ten days earlier in a testing-related role but wanted to pursue software development.

I clarified my joining availability and answered the remaining questions.

After a short wait of around ten minutes, HR informed me that I had been selected.

Result

I received an offer for the Junior Software Engineer role with a fixed package of ₹8 LPA, approximately ₹60,000 per month in hand.

• Practise DSA and learn to explain your approach clearly.

• Be thorough with everything mentioned in your resume.

• Revise Java, OOP, databases, and REST APIs.

• If you have React projects, prepare hooks and state management properly.

• Don't ignore communication and behavioural questions.

• Be honest about your current employment situation during HR discussions.

OYO Rooms visited our campus for its recruitment drive for the Associate Software Development Engineer position.

The selection process had an initial screening, followed by an online coding assessment and a technical interview. Although the coding assessment went quite well, the technical interview was a different experience altogether.

Round 1: Online Assessment (OA)

The process started with an initial screening, after which approximately 100-130 students were shortlisted for the coding assessment.

The assessment was conducted on campus and included four programming questions. The overall difficulty was around easy to medium.

Most of the questions tested basic problem-solving skills and commonly used DSA patterns, including:

• Sliding Window

• Two Pointers

• Array-based problems

• Basic DP Problem

I was able to solve all four questions within the given assessment.

After the evaluation, only seven students were shortlisted for the technical interview. This made the next stage quite competitive.

Round 2: Technical Interview

The technical interview was conducted online. The interviewer focused mainly on DSA and problem-solving.

I was given two coding problems during this round.

Question 1: Maximum Money Robbed in a Binary Tree

Topics: Binary Trees, Tree DP, Recursion, Dynamic Programming

The first problem involved a binary tree where every node represented the amount of money available in a house.

The objective was to calculate the maximum amount of money that could be collected, with one important condition: two directly connected houses (parent and child) could not be robbed together.
Similar Problem:

How I approached it:

I started by thinking recursively about the two choices available at every node:

• Rob the current node and skip its immediate children.

• Skip the current node and consider robbing its children.

The idea was to calculate the maximum possible amount for both choices and use these results to determine the best outcome.

I approached it using recursion and two states for every node:

1. Maximum amount when the current node is robbed.

2. Maximum amount when the current node is skipped.

This allowed the solution to avoid making locally optimal decisions without considering their impact on the rest of the tree.

Question 2: Maximum Number of Events That Can Be Attended

Topics: Greedy, Sorting, Intervals, Min Heap

The second problem was based on scheduling events.

We were given multiple events, each having a starting day and an ending day. The condition was that only one event could be attended on any particular day.

The task was to find the maximum number of events that could be attended.

How I approached it:

I considered a greedy strategy combined with sorting and a Min Heap.

The general approach was:

1. Sort all events according to their starting days.

2. Maintain a Min Heap containing the ending days of available events.

3. For each day, add events that have started.

4. Remove events that have already expired.

5. Attend the event that ends earliest.

6. Repeat the process to maximise the total number of events attended.

The important observation here was that choosing the event that finishes earliest leaves more opportunities to attend other events later.

This problem required a good understanding of interval scheduling and priority queue operations.

After discussing the interview experiences with my classmates, I found that the questions weren't limited to just these two problems.

Other candidates also encountered questions involving:

• Linked Lists

• Binary Trees

• Tree-based problem-solving

• Different DSA concepts

Overall, the technical interviews seemed to place a strong emphasis on data structures and algorithmic thinking.

I recently went through the TCS NQT recruitment process, and it was a good mix of aptitude, communication, coding and technical discussions. Sharing my experience here for anyone preparing for the same.

Online Assessment

The first stage was a three-hour online assessment covering aptitude, communication and programming skills.

The paper had five major sections:

• Aptitude: Quantitative and logical reasoning questions, mostly of easy to medium difficulty.

• Verbal Ability: Basic English grammar and communication-related questions.

• Reading and Passage Rewriting: We were shown a passage for approximately 30 seconds and then had to rewrite it based on our understanding. It tested reading comprehension, memory and writing skills.

• Email Writing: We had to draft a professional email in around 100 words, keeping grammar, clarity and structure in mind.

• Coding: Two programming questions tested our coding knowledge and problem-solving ability.

After completing the assessment, I successfully cleared it and qualified for the interview rounds.

Round 2 - Technical Interview: Projects, Java and Generative AI

The technical interview started with the classic introduction question: "Tell me about yourself."

From there, most of the discussion revolved around my projects and technical understanding.

The interviewer asked me to explain my project in detail, including its complete pipeline, system architecture and the role of different components. The focus was not just on what I had built but also on understanding how everything worked together.

The discussion then moved to a couple of other technical areas:

• Generative AI: Questions covering basic Generative AI concepts.

• Java: A few predict-the-output questions to evaluate my understanding of Java fundamentals.

Overall, the interviewer focused on my conceptual clarity and how well I could explain the technical work mentioned on my resume.

Round 3 - HR Interview: Getting to Know Me

The final round was more about understanding my personality, motivation and approach towards different situations.

Some questions asked during this round were:

1. Why do you want to join TCS?

2. What do you know about TCS?

3. Describe a situation when you felt like giving up. How did you overcome it?

The conversation focused on my reasons for joining the company, how I handle challenging situations and how I respond to setbacks.

A Few Things I Would Recommend

Based on my experience, I would suggest giving special attention to your resume projects. Don't just prepare a basic explanation, understand the architecture, complete workflow and implementation.

Along with that, revise Java fundamentals and practise output-based questions. Having a basic understanding of Generative AI can also be helpful.

For the online assessment, don't ignore aptitude, verbal ability, email writing or coding. Every section contributes to the overall process.

Hope this experience helps someone preparing for TCS NQT. All the best!

While preparing for coding interviews, I noticed that Sliding Window is one of those DSA topics where understanding the pattern matters much more than memorising individual solutions.

At first, many problems look different. Some ask for the longest substring, some ask for the smallest subarray, and others involve finding the maximum sum. But once I started grouping them by approach, I realised that a lot of these questions follow a few common patterns.

I thought I'd share the patterns I'm revising and the problems I'm practising so that I can recognise them more easily during interviews.

Fixed-Size Sliding Window

This is the simplest pattern to start with. The window size remains constant throughout the problem.

Instead of calculating the result for every possible subarray from scratch, I calculate the first window and then update it by removing the element that goes out and adding the new element that comes in.

Problems I'm practising:

• Maximum Sum Subarray of Size K

• First Negative Number in Every Window of Size K

• Maximum of All Subarrays of Size K

• Count Occurrences of Anagrams

Variable-Size Sliding Window

In this pattern, the window size changes depending on whether the current window satisfies a given condition.

I usually maintain two pointers, left and right. I expand the window by moving right and shrink it by moving left whenever the condition needs to be restored.

This pattern is especially useful for questions asking for the longest or shortest subarray or substring that satisfies a condition.

Problems I'm practising:

• Longest Substring Without Repeating Characters

• Longest Repeating Character Replacement

• Minimum Size Subarray Sum

• Max Consecutive Ones III

Sliding Window With Frequency Counting

Some problems require tracking how frequently characters or numbers appear inside a window.

For these, I maintain a frequency map or an array. Whenever the window expands or shrinks, I update the frequency accordingly.

This avoids repeatedly checking every element in the current window.

Problems I'm practising:

• Permutation in String

• Find All Anagrams in a String

• Minimum Window Substring

• Longest Substring With At Most K Distinct Characters

Sliding Window With Multiple Conditions

In some interview problems, maintaining a valid window requires tracking more than one condition.

For example, a question might ask for the longest substring containing at most K distinct characters, or the longest subarray with a limited number of zeros.

The important part is to understand when the current window becomes invalid and which elements need to be removed before continuing.

Problems I'm practising:

• Fruit Into Baskets

• Longest Substring With At Most Two Distinct Characters

• Subarrays With K Different Integers

• Binary Subarrays With Sum

Monotonic Deque With Sliding Window

This is a slightly different pattern. Sometimes, we need to maintain the maximum or minimum element inside a moving window.

A deque helps maintain useful candidates in sorted order, allowing us to find the maximum or minimum efficiently without scanning the entire window every time.

Problems I'm practising:

• Sliding Window Maximum

• Sliding Window Minimum

• Shortest Subarray With Sum at Least K

How I'm Practising These Patterns

Rather than jumping between random questions, I'm trying to solve problems pattern by pattern.

For every question, I first identify whether the window size is fixed or variable. Then I understand what makes the window valid, what information I need to maintain, and when I should move the left pointer.

I'm also trying to solve the same problem again after a few days without looking at my previous code. This helps me check whether I've actually understood the approach.

If you're revising Sliding Window too, which problem do you think is the best one to test your understanding of this topic?

Company: EPAM Systems
Role: Internship with Performance-Based PPO
Applied Through: Campus Placement
Difficulty: Easy-Medium

EPAM Systems visited our campus for its recruitment drive, offering an internship opportunity with a performance-based Pre-Placement Offer (PPO).

Online Assessment

The first round was an online assessment consisting of two medium-level DSA problems and technical MCQs.

The coding questions were:

Along with DSA, the assessment included MCQs covering various technical concepts.

For preparation, I would highly recommend Striver's SDE Sheet. It helped me build problem-solving skills and practice important DSA concepts that are useful for coding assessments.

I was able to clear the online assessment and move to the next round.

Round 2: Group Discussion

After clearing the online assessment, the EPAM team visited our college for the next stage of the recruitment process.

We had a Group Discussion (GD) round.

GD Topic: Is Artificial Intelligence a Threat to Freshers' Jobs?

We were given around 2-3 minutes to think about the topic and organize our thoughts. First, each candidate had to present their individual perspective, followed by an open group discussion.

The discussion revolved around how AI is changing the job market, its impact on freshers, and whether it should be seen as a threat or an opportunity for upcoming engineers.

A few things that helped me approach this round:

• Express your thoughts clearly and confidently.

• Listen carefully to what others are saying.

• Build on others' points whenever possible.

• Avoid interrupting or dominating the discussion.

• Support your opinions with logical reasoning and practical examples.

• Focus on teamwork rather than trying to win the discussion.

I successfully cleared this round as well.

Round 3: Technical Interview

This was one of the most important rounds of the selection process.

The interviewer started with DSA questions and then moved on to core computer science subjects and my projects.

DSA Questions:

• Balanced Parentheses

• Detect a Loop in a Linked List

Both questions were around Easy-to-Medium difficulty.

After the DSA discussion, the interviewer asked me questions related to core CS subjects and my projects.

I was able to clear this technical round and proceed to the final stage.

Round 4: HR Interview

This was the final round of the recruitment process.

The HR interviewer started with my introduction and asked a few questions to understand my interests, motivation, and flexibility.

Some of the questions included:

• Tell me about yourself.

• Why do you want to join EPAM Systems?

• Are you willing to relocate?

• Are you comfortable working from the office five days a week?

• A few other general behavioral questions.

This round was relatively straightforward. I focused on answering honestly and confidently.

My suggestion would be to be clear about your expectations, relocation preferences, and willingness to work according to the company's policies.

I successfully cleared the HR round and completed the selection process!

Compensation Details

Overall, it was a good learning experience. The recruitment process evaluated different aspects of my skills at every stage, starting with DSA and technical knowledge in the online assessment, followed by communication and teamwork in the GD, and finally my problem-solving and technical understanding in the interviews.

For anyone preparing for EPAM's campus recruitment, I would recommend practicing DSA regularly, revising core CS subjects, understanding your projects thoroughly, and working on your communication skills.

All the best to everyone preparing for EPAM Systems placements

Role: Software Development Engineer II (SDE 2)

Location: Amsterdam, Netherlands

Preparing for technical interviews while managing a full-time role is no easy feat, but hard work pays off.

Round 1: Recruiter Screening (60 mins)

This was an introductory conversational round with the recruiter focused on my background and culture alignment:

• My past engineering experience, key achievements, and project leadership.

• Discussion around my motivations for joining Booking.com and relocating to Amsterdam.

Tip: Be prepared to highlight impact metrics and specific ownership roles in your past projects.

Round 2: DSA

The interview lasted around one hour and focused on problem-solving and optimization.

Question: Maximum Number of Transactions Within a Time Window

I was given an array of integers representing the timestamps of transactions and an integer K representing a time window.

I had to find the maximum number of transactions that occurred within any continuous time window of length K.

Example:

timestamps = [1, 2, 3, 5, 6, 8, 10, 11]
K = 3

Output:

3

Explanation:

The time window from 1 to 3 contains three transactions: 1, 2, 3.

No other window of length 3 contains more transactions.

I approached this problem using the sliding window technique, maintaining a window of valid timestamps and updating the maximum count as I moved through the array.

I also discussed the time and space complexity and walked through the solution with an example.

Round 3: System Design (90 mins)

An interactive architecture and system design session centered around backend scalability, real-time data, and high concurrency.

• Problem Statement: Design a Food Delivery System, with a deep dive into rider-to-user order delivery dynamics.

• Key Technical Topics Covered:

  • Proximity Search: Evaluating Spatial Indexing (Geohash / Quadtrees / Uber H3) vs. Redis Geospatial queries for tracking active driver locations in real time.

  • Concurrency Control: Utilizing Optimistic Concurrency Control (OCC) to prevent race conditions during driver assignment and order state transitions.

  • Messaging & Data Flow: Leveraging Kafka for reliable event streams (order events, status tracking) and Redis for low-latency state caching.

Experience: Very collaborative whiteboard discussion. The interviewer engaged deeply in trade-off discussions, making it a great experience.

Round 4: Cultural & Behavioral Fit (60 mins)

This round evaluates leadership, collaboration, product mindset, and conflict management.

• Project Deep Dive:

  • Detailed discussion on my most recent high-impact project.

  • Crucial note: Pick a project where you had clear architectural and execution ownership. Expect heavy follow-ups on your exact contribution, how you drove architectural decisions, and how you built consensus across teams.

• Product & Experimentation:

  • Multiple questions centered around A/B testing, feature rollout strategies, metrics evaluation, and handling unexpected experiment outcomes.

• Soft Skills:

  • Scenario-based questions on cross-functional conflict resolution, handling technical debt vs. feature deadlines, and stakeholder management.

Company: Broccoli AI

Rounds Covered: 2

Result: Rejected after Round 2

Round 1: Resume Discussion (30 Minutes)

The first round started with a discussion around my resume.

The interviewer asked me to pick one of my projects and explain it in detail. We discussed how I had built it, the technical decisions I made, and the reasoning behind its overall design.

The discussion went beyond just explaining the project's features. I was also asked questions about its implementation and why I had chosen a particular approach.

One thing I'd suggest is to be thoroughly prepared with every project you mention on your resume. You should be comfortable explaining the architecture, implementation details, challenges, and technical decisions.

Round 2: System Design (60 Minutes)

Problem: Design a Feature Flag System

The requirement was to design a system that allows engineering teams to enable or disable features in a live production environment without having to deploy new code.

The interviewer expected the design to cover two major components:

1. Control Plane

This component would allow engineering teams to manage feature flags.

Some of its responsibilities included:

• Creating and managing feature flags.

• Configuring rollout rules.

• Enabling or disabling features.

• Controlling which users or groups get access to a particular feature.

2. Data Plane

This component would handle feature flag evaluations within running applications.

For example, an application should be able to make a simple call like:

flags.isEnabled("checkout_v2", userId)

Based on the configured rules, the system would return whether the particular feature should be enabled for that user.

I worked through the system design and presented my proposed architecture during the discussion.

However, I felt that the interviewer wasn't very engaged throughout the conversation. That was just my personal impression, and I can't say whether it had anything to do with the final decision.

Unfortunately, I was rejected after the second round.

Company: Amazon

Role: SDE Intern (6 Months)

Interview Mode: In-Person (Onsite)

Round: 1

The interviewer didn't jump directly into coding. We started with my resume and project experience, followed by two DSA problems that required me to think through different approaches and explain my reasoning.

Here's how the interview went.

1. Resume Discussion & Leadership Principles

We began with my resume, and the interviewer picked one of my projects, PlaceMate AI, to start the discussion.

The first question was:

Q. Tell me about a situation where you demonstrated ownership.

I used my PlaceMate AI project as an example and explained what motivated me to build it, the problem I wanted to solve, and the responsibilities I handled during its development.

The interviewer then asked a few follow-up questions:

• How much time did you spend building the project?

• What was the most challenging technical part?

• How did you gather and manage placement-related information?

I explained that collecting information from different sources, especially WhatsApp conversations, and converting it into properly structured data was one of the biggest challenges.

This part of the interview focused on understanding my contribution, decision-making, and the effort behind the project rather than just knowing its features.

2. DSA Round

After the project discussion, we moved to coding problems.

Question 1: Minimize Array Sum After X Operations

The problem was based on an array where each element represented a weight.

In one operation, I could select any element and replace it with half of its current value. I had to perform exactly X operations and minimize the final sum of the array.

Example:

arr = [2, 5, 10, 23]

For instance, I could select 10 and reduce it to 5 in one operation.

My approach:

Initially, I thought about sorting the array and repeatedly selecting the largest element.

However, after discussing the approach and getting a hint from the interviewer, I realised that the largest element could change after every operation. Re-sorting the array each time wouldn't be an efficient solution.

That's when I moved towards using a Max Heap (Priority Queue).

The approach was:

1. Insert all array elements into a Max Heap.

2. Perform X operations.

3. In every operation, remove the largest element from the heap.

4. Reduce its value to half and insert the updated value back.

5. Once all operations are completed, calculate the sum of the remaining elements.

The interviewer agreed with the Max Heap approach.

Complexity discussion:

We also discussed the time complexity of different heap operations.

Some important operations to remember:

I got a little confused while explaining some of the complexity details, so this was definitely something I felt I could have handled better.

Question 2: Word Break / String Segmentation

The second problem was related to string segmentation.

We were given an array of strings:

["catdog", "cat", "dog"]

The task was to identify strings that could be broken into smaller strings, where each smaller string was also present in the given array.

Example:

catdog = cat + dog

My approach:

I recognised this as a variation of the classic Word Break problem.

I suggested the following approach:

1. Store all the given strings in an unordered_set so that we can perform efficient lookups.

2. Use recursion to explore different ways of splitting a string.

3. Check whether the generated substrings exist in the set.

4. If a valid combination of smaller strings is found, consider the original string segmentable.

The interviewer then asked me to write the implementation again on a fresh sheet.

While explaining and rewriting the code, I struggled a little with handling substring boundaries and deciding the recursive choices correctly.

We also discussed the time complexity of the basic recursive solution and how it could become exponential because of the repeated exploration of possibilities.

This question made me realise the importance of being comfortable with recursion, substring handling, and optimising recursive solutions.

3. Questions I Asked the Interviewer

Towards the end, the interviewer gave me an opportunity to ask questions.

I asked two things:

• What kind of responsibilities and goals does Amazon expect an intern to achieve during the six-month internship?

• With AI evolving so quickly, how do you personally keep yourself updated and continue learning new things?

Both questions helped me understand more about the internship expectations and the engineer's approach to continuous learning.

Overall, the interview covered three major areas: project ownership, Amazon Leadership Principles, and DSA.

The two coding problems tested different problem-solving skills:

• Max Heap / Priority Queue: Selecting and updating the maximum element efficiently.

• Word Break: Recursion, string segmentation, and Hash Set-based lookups.

• Complexity Analysis: Understanding the time complexity of individual operations and the complete solution.

The project discussion was equally important. The interviewer wanted to understand why I built PlaceMate AI, what challenges I faced, and how much ownership I took during development.

A few things I would recommend based on this round:

• Be prepared to explain your motivation, technical decisions, challenges, and individual contributions.

• Don't just practise problems; understand the complexity of every operation.

• Try solving the problem using recursion first, then improve it using memoization or DP.

• Pay attention to substring boundaries, recursive conditions, and edge cases.

• Even if your initial approach isn't optimal, communicate your reasoning and be open to hints.

That's how my first Amazon SDE Intern interview went. It was a good learning experience, and I came away with a clearer idea of the areas I need to improve.

Company: Commvault

Role: SDE Intern + PPO

Full-Time CTC: ₹32 LPA

Internship Stipend: ₹50,000/month

Location: Bangalore

Hiring Mode: On-Campus

Hi everyone!

Commvault visited our campus for the SDE Intern + PPO hiring process, and I got the opportunity to go through multiple rounds, starting with an online assessment and ending with the HR interview.

Round 1: Online Assessment (OA)

The first step was an online assessment conducted on our college campus.

Before starting the test, we had to fill out a form and select our preferred programming language. I went with Java.

The assessment had a few MCQs followed by three DSA coding questions, with just 40 minutes allotted for the coding section.

The questions were based on topics like Graphs, Trees, and Dynamic Programming. Some of the questions included:

• Course Schedule I

• Number of Corner Rectangles

• A variation of Longest Palindromic Subsequence

Honestly, managing time was the biggest challenge here. Solving three DSA questions in 40 minutes wasn't easy.

I managed to solve two questions completely and made partial progress on the remaining one.

Thankfully, I cleared the assessment and was shortlisted for the next round.

Round 2: Machine Coding Round

This turned out to be the most challenging and exhausting part of the entire selection process.

We were asked to report to our college lab at around 10 AM, and the process continued until approximately 6 PM.

Each candidate was assigned an interviewer and given a machine coding problem to solve. My problem was to design a complete Cricbuzz application.

The expectations were not limited to writing code. We had to:

• Understand the requirements and clarify any doubts.

• Design the complete application.

• Explain the architecture and overall approach.

• Write clean, working code.

• Run test cases and make sure the implementation worked correctly.

The interviewer first explained the problem statement and gave us some time to go through the requirements.

Before jumping into coding, I was asked to explain my understanding of the problem. This helped ensure that both the interviewer and I were on the same page.

After that, we discussed the design and implementation approach, including:

• Overall application architecture.

• Class structure and responsibilities.

• Object-oriented design principles.

• Design patterns wherever applicable.

• How different components would interact with each other.

Once we were aligned on the design, I started implementing the application.

Throughout the round, interviewers would periodically check our progress, roughly once every hour. They asked questions about the decisions I had made, the implementation, and the reasoning behind my approach.

One thing I realised during this round was that simply getting the code to work wasn't enough. I also had to justify why I had designed something in a particular way and explain the alternatives.

I spent almost the entire day designing, coding, debugging, and testing the application.

By around 6 PM, I had managed to get almost all the test cases working successfully.

It was honestly quite exhausting to spend nearly eight hours continuously working on a single problem, but it was also a great learning experience.

After the round, the results were announced, and I was shortlisted for the technical interview.

Round 3: Technical Interview

After clearing the machine coding round, I appeared for the technical interview.

The interviewer started with a medium-level DSA problem:

Question: Sliding Window Maximum

We discussed the approach and solution, after which the conversation shifted towards my Cricbuzz machine coding implementation.

The interviewer wanted to understand the reasoning behind my design decisions. Some of the questions were:

• Why did you choose that particular design pattern for your Cricbuzz implementation?

• Why did you structure the application in that way?

• What alternative design patterns could you have considered?

• Explain some commonly used design patterns.

• Questions related to OOP concepts.

We then moved on to my college projects. The interviewer asked about their implementation and went into quite a bit of technical detail.

Other topics discussed included:

• Core Java concepts.

• Java internals and OOP.

• SQL and database-related concepts.

• Project architecture and implementation decisions.

I would say that having a clear understanding of my projects helped a lot here. The interviewer wasn't just interested in knowing what I had built but also wanted to understand how it worked internally and why I had made certain technical choices.

Based on the overall technical performance, candidates were evaluated for the internship and PPO opportunities. There were different selection outcomes, including performance-based PPO and regular PPO pathways.

Round 4: HR Interview

Finally, I reached the HR round.

Compared to the previous rounds, this one was relatively relaxed and mostly focused on getting to know me better.

Some of the questions and discussion points included:

• Tell me about yourself.

• Walk me through your college journey.

• Why do you want to join Commvault?

• Questions about the internship.

• Availability and joining details.

• Compensation-related discussions.

• A few general HR questions.

The conversation went smoothly, and after completing this round, the final results were announced.

My Preparation Strategy

Coming to preparation, I had started working on DSA during my second year of college.

I started building my DSA fundamentals in my second year and gradually moved towards solving more challenging problems.

My primary resource was Striver's A2Z DSA Sheet

It helped me cover important topics systematically, understand different problem-solving patterns, and build confidence in approaching unfamiliar problems.

I focused on understanding the logic behind each solution rather than just memorising code.

Recently, I have participated in the Infosys SP/DSE hiring drive. I have cleared the Online Assessment (OA) which was the round 1.

Offline Coding Round

• Received an invitation to an offline coding assessment at an engineering college with only 10 days to prepare.

• Heard that DP, Graphs, Greedy, and Trees were highly likely to show up on the test.

• Decided to focus entirely on Dynamic Programming (DP) and Greedy algorithms due to the tight timeline.

• Spent the 10 days grinding Striver’s playlists, completing the entire DP series twice and then working through the Greedy videos.

• The gamble paid off when two DP questions appeared on the assessment, both of which I solved successfully.

THANKS TO STRIVER

Overall I have solved 2.5 questions that day and after completing the assessment, I went to play pickle ball with my friends.

I have recieved the Interview shortlisting mail and my interview was scheduled on 30th of September, 2026. I had only 10 days left again. Good Enough to crack.

I have prepared my projects in and out with core subjects as well. I couldn't efficiently prepare SQL and DBMS.

Interview Experience

On the Interview day Interviewer didn't even ask for my introduction, he straight away asked about my interests and hobbies. I said cricket and movies. Next thing he said, "today there's an odi match right, are you going to watch it?" . I said "Right now, I'm here so I can't" . He laughed and said "Unfortunately?" I said, "No, this is more important to me, I'll watch when I go home". Then he asked about my on-campus placements and I said there were none. He was a bit surprised but moved on quickly.

He gave me two coding questions on Infosys Wingspan IDE and the asked me to solve any one of them under 25 mins. I did solve 1 question fully with all test cases passed. The interview looked at my solution and though "Hmm....okay, lets get into interview"

Questions he asked :

• RAG, cosine similarity related (didn't answer accurately but mnaged to answer it)
• Kafka related questions (missed one or two, but managed to explain what it is)
• Redis related questions (missed one or two, but managed to explain what it is)
• OS related question (answered)
• Computer networks related question (answered)
• Solid principles (answered partially) , ACID principles (answered partially), Index (answered)
• SQL query problem (couldn't write)
• How to optimize an SQL query (managed, but struggled)
• API gateway (answered), Reverse proxy (partially answered),
• Load balancer (answered)

Then he was about to write feedback in his portal but there was some issue with portal, he called someone and they were looking at the issue, and then he said "You may leave".

I have no hopes with this one because I know I struggled. I don't know when will I get any other opportunity or whether I will be able to get one or not.

Result : Pending (no update)

Company: Josh Technology Group (JTG)
Role: Software Developer
Location: Gurugram
Applied Through: College Placement Drive
Package: ₹15.88 LPA
Difficulty: Medium–Hard

I participated in Josh Technology Group’s (JTG) recruitment process for the Software Developer role through my college placement drive.The process included three college-level assessments, a separate coding assessment at JTG, and multiple technical interview rounds.

One important detail was that all the online assessments were conducted using the Safe Exam Browser (SEB) application.

Here’s how my interview process went.

1. College-Level Online Assessments

The process started with three online assessment rounds conducted at my college. All three were elimination rounds.

Round 1: Subjective Test

The first round was a technical assessment consisting mainly of MCQ-based and code-output questions. I had to analyze code snippets and answer questions based on their behavior.

Round 2: Objective Test

The second round included technical questions along with aptitude questions. It tested my understanding of technical concepts and my general problem-solving ability.

Round 3: Coding Test

The third round was a coding assessment containing three programming questions.

After clearing all three rounds, I was shortlisted for the next stage and had to travel to JTG's Gurugram office.

2. JTG Coding Assessment

After reaching the JTG office, I appeared for another online coding assessment. This round consisted of two DSA problems.

Problem 1: Deepest Level Sum of a Binary Tree

I was given a binary tree and had to calculate the sum of all nodes present at its deepest level.

Problem 2: Maximum Sum of Three Increasing Values

I was given an array of prices or values and had to select three indices (i < j < k) such that:

[
price[i] < price[j] < price[k]
]

The objective was to maximize:

[
price[i] + price[j] + price[k]
]

I was able to pass all the test cases in this assessment.

3. Technical Interview Process

After completing the JTG assessment, I expected to proceed through the technical interview rounds in sequence. However, I received an email directly for Technical Interview Round 2, skipping Round 1.

Towards the end of the process, the interviewer explained that my assessment solutions had been considered fully optimal, which was why I had been moved directly to Round 2.

All the technical interviews were conducted face-to-face at the JTG Gurugram office. Each round lasted approximately two hours, making the process quite intensive.

4. Technical Interview

The interview began with a brief introduction, followed by an in-depth discussion about my project.

The interviewer asked me about:

• My project's overall functionality

• Project architecture

• Technologies used

• My individual contribution

• How different components worked together

After the project discussion, we moved to DSA. The problems were around medium difficulty.

Problem 1: Minimum Length Subarray to Sort

I was given an array and had to find the length of the smallest contiguous subarray that needed to be sorted so that the entire array would become sorted.

If the array was already sorted, the expected output was -1.

Problem 2: Longest Consecutive Sequence in a Binary Tree

I was asked to find the longest downward path in a binary tree where each child node's value was exactly one greater than its parent's value.

The path could move only downward, from parent to child.

This problem was essentially the Binary Tree Longest Consecutive Sequence problem.

5. Technical Interview

After completing Round 2, I received an email for the next technical interview.

This round was also conducted face-to-face at the Gurugram office and lasted approximately two hours.

The interviewer started with my introduction and then discussed my project, including its implementation and technical details. After that, I was given two DSA problems that were around medium-to-hard difficulty.

Problem 1: Maximum Sum Subarray Using Inorder Traversal

I was given a binary tree and had to consider its inorder traversal to find the maximum sum of a contiguous subarray.

I recognized the connection with Kadane's Algorithm and explained how I could combine inorder traversal with Kadane's approach to solve the problem.

Problem 2: Split N into M Positive Integer Parts

I was given two integers, N and M, and had to generate all possible ways to divide N into exactly M positive integers such that their sum equaled N.

For example, the task was to generate every valid combination of positive integer parts satisfying the given conditions.

I identified backtracking as a suitable approach and explained my reasoning to the interviewer.

The difficulty increased as I progressed through the recruitment process.

My Overall Experience

My JTG interview experience was heavily focused on DSA, problem-solving, and project understanding. The interviewers were interested not only in the solutions I proposed but also in how I broke down problems and explained my reasoning.

Overall, the process progressed from college-level assessments to a dedicated coding assessment and then lengthy technical interviews. It tested both my coding ability and my understanding of the decisions behind my solutions.

Company: Echolerena Technologies Pvt. Ltd.

Type: Internship

Rounds: 3

Result: Selected for the Internship

HR Screening

The first round was a brief profile and HR screening discussion. I introduced myself, discussed my technical skills and explained some of my notable projects.

The discussion mainly focused on:

• Preferred technologies and libraries

• Technical background and projects

• Interest in the Data Engineer role

• Expectations from my first job

After clearing the initial screening, I proceeded to the technical assessment.

Technical Assessment

The assessment covered basic programming, data structures, SQL, and DBMS concepts.

Coding

The coding questions started with a basic string reversal problem and then moved to linked-list operations, including:

• Adding a node at the beginning of a linked list

• Adding a node at the end of a linked list

• Adding a node in the middle of a linked list

SQL

The SQL portion focused on fundamental database operations and concepts:

• SQL JOINs

• DML commands

• Differences between various SQL commands

DBMS

The remaining questions covered core DBMS principles:

• Database normalization

• ACID properties

Final Task & Manager Interview

The final round consisted of a programming task followed by a manager interview.

Programming Task

The programming task was to write a script that could transliterate English text into Hindi.

The task tested my ability to understand a practical problem, determine an appropriate approach, and implement the solution.

Manager Interview

After the programming task, the manager discussed questions related to my motivation, problem-solving approach, and career goals.

Some of the questions included:

• Why do you want to join the Data team despite your broader technical background?

• How would you approach a problem when you don't immediately know the solution?

• Why do you want to begin your career with this organization?

The discussion was more focused on understanding my reasoning, adaptability, and motivation rather than purely testing technical knowledge.

Result

I successfully reached the final stage and was selected for the internship.

Location: Bengaluru, Karnataka, India
Experience: 8+ years
Team: AI & Data Platforms (AiDP)
Role Number: 200692391-0321

Apple is hiring a Senior Applied AI Engineer to build AI applications, data platforms, and machine learning infrastructure. The role focuses on taking AI prototypes into production, developing agentic workflows, and building scalable AI solutions across Apple's internal platforms.

If you have strong software engineering experience and hands-on expertise in applied AI, LLMs, and AI agents, this could be an exciting opportunity.

Key Responsibilities

• Develop AI applications and transform prototypes into production-ready agentic workflows.

• Build and extend AI, data, and machine learning platforms.

• Take ownership of software delivery, user adoption, system monitoring, and production troubleshooting.

• Identify technical challenges and collaborate with stakeholders to design and implement solutions.

• Manage technical strategy, priorities, deadlines, and deliverables across distributed teams.

Required Qualifications

• Bachelor's degree in Computer Science, Engineering, Mathematics, Technology, or a related field, or equivalent practical experience.

• 8+ years of experience in software or platform development.

• Strong programming skills in Python; experience with TypeScript, Java, or Go is a plus.

• Experience architecting AI systems on cloud platforms.

Preferred Skills

• Experience deploying production-grade AI solutions for internal or external users.

• Knowledge of LLM serving and inference frameworks.

• Hands-on experience with LangChain, LangGraph, CrewAI, or AutoGen.

• Applied AI experience with prompt engineering, fine-tuning, RAG, and agent orchestration.

• Ability to build secure agentic workflows using MCP, tool calling, and OAuth authentication.

• Understanding of Data Structures and Algorithms.

• Experience with distributed systems such as Kafka, Hadoop, Spark, or Flink.

• Strong problem-solving skills and the ability to resolve complex technical issues independently.

• Excellent communication and stakeholder collaboration skills.

Apply Here:
https://jobs.apple.com/en-in/details/200692391-0321/senior-applied-ai-engineer-aidp?team=SFTWR

Status: Interview Process Completed

Difficulty: Easy to Medium

Technical + HR Interview

Method: Direct Call Interview

The interview was a combination of technical and HR discussion conducted over a call.

Technical Questions

Topics discussed:

• React Hooks

• JavaScript Basics

The interviewer asked questions related to React fundamentals, the purpose and usage of hooks, and core JavaScript concepts.

Project & Experience Discussion

A significant portion of the interview focused on previous experience and projects.

Topics discussed:

• Previous Hackathons

• Projects and Contributions

• Technical Experience

The interviewer asked about my participation in hackathons, the projects I had worked on, the technologies used, and the challenges faced during development.

HR Discussion

The HR portion focused on understanding my background, interests, experiences, and overall fit for the role.

The interview was conversational in nature and focused on assessing practical development knowledge, project experience, and communication skills rather than solving coding problems.