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

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.

I applied for an MTS C++ role at Adobe after spotting the opening on LinkedIn. I submitted my application through the careers page without a referral and received a call from the recruiter within a week. The interview process consisted of two technical rounds covering DSA, C++ fundamentals, puzzles, and low-level design.

Round 1: DSA, C++ Fundamentals and Puzzles

Duration: 60 minutes

The interview started with a DSA problem: Check for Symmetrical Binary Trees.

I hadn't solved this problem before, but I managed to work through it in around 30 minutes. With the remaining time, the interviewer moved on to C++ concepts and debugging.

The discussion included:

• Multiple Inheritance in C++: What happens when a class inherits from two base classes that have a method with the same name? How would you resolve the ambiguity?

• Virtual Functions and Destructors: Why should a base class have a virtual destructor when objects of derived classes are deleted through a base-class pointer?

• Memory Management and Debugging: How would you identify and fix a memory leak or dangling pointer in a C++ program?

I was able to answer these questions.

The round also included two puzzles:

1. Poisoned Bottle Puzzle: Find one poisoned bottle among 1,000 identical bottles using the minimum number of prisoners or rats within a specified time limit.

2. Defective Ball Puzzle: Given eight balls, with one weighing less than the others, identify the defective ball in exactly two weighings.

I couldn't solve either puzzle within the given constraints.

Round 2: C++ and Low-Level Design

Duration: 60 minutes

The second round focused entirely on C++ concepts and implementation. The interviewer asked questions about smart pointers, RAII, the Singleton pattern, constructors, and related topics.

Two major coding tasks were discussed:

• Implement the Singleton Pattern in C++: This took approximately 15 minutes.

• Implement Smart Pointers using LLD in C++: This took around 30 minutes.

I found this round more challenging because I didn't have much hands-on experience with C++. I had spent only the preceding couple of days revising C++ concepts, so implementing the low-level design of smart pointers was particularly difficult.

Rejected

The interview covered a broad range of topics, from DSA and debugging to C++ fundamentals, puzzles, and low-level design. My main challenge was the depth of C++ implementation expected, especially in the second round.

For anyone preparing for a similar MTS C++ role, revising core language concepts is useful, but practising implementation-heavy questions such as smart pointers and design patterns is equally important.

I interviewed with Postman for the Software Engineer role in Bangalore. I applied directly through the company's careers website and received a call from the recruiter a few days later.

Hiring Manager Round

The first round focused mainly on my previous work experience and projects. The hiring manager selected a few projects from my background and explored them in detail.

The discussion covered performance optimization, scalability, technical decisions, and areas where I felt the implementation could have been improved.

I was also asked what I would do differently if I had the opportunity to revisit those projects. The focus was on understanding my technical reasoning, ownership, and ability to learn from past decisions.

Machine Coding

This round involved building a dynamic Form Builder using React.js.

The application needed a side panel from which users could configure and add different types of form fields, such as text inputs, number inputs, and checkboxes. Whenever a new field was added, it had to appear in the form on the right in real time.

The form also needed a Submit button that collected all the entered values and logged them as a JavaScript object in the console.

The main focus was on component design, state management, dynamic rendering, handling different input types, and implementing the required functionality within the given time.

The final 15 minutes were dedicated to discussing my previous experience again, with deeper questions about the concepts and technical decisions behind my projects.

Frontend System Design

This was an open-ended system design discussion in which I was asked to design a social media platform.

The focus was specifically on the main feed and the post details screen. Since the position was frontend-focused, the expected discussion was approximately 70% frontend and 30% backend.

The discussion centred on how the UI would be structured, how components would interact, how data would flow through the application, and how the frontend could handle feeds and post details efficiently.

The backend portion involved understanding the APIs and data interactions needed to support these screens.

General Discussion and Culture Fit

This was a 30-minute conversation with a Principal Designer. The discussion focused on culture fit and how I would collaborate with the UX team as a frontend engineer.

Some notable questions were:

• What new feature would you add to Postman from a frontend perspective?

• Which three apps have the best user experience, in your opinion, and why?

The discussion explored my product thinking, design awareness, and ability to work closely with designers to build intuitive user experiences.

Final Verdict: Offer Received

I received a positive outcome and got the offer within three days of the final round. The entire interview process took around seven days.

Overall, it was a great experience. The recruiters were responsive to my questions and shared preparation material for the rounds beforehand.

I accepted the offer.

Recently went through the interview process for a Platform Engineer role at NVIDIA with 10 years of experience. The interviews focused on Kubernetes, cloud infrastructure, platform design, troubleshooting, and SRE practices. Here’s a quick breakdown of the questions and topics covered across the five rounds.

Round 1

The first round focused on core Kubernetes concepts and platform engineering tools. Topics included:

• Kubernetes architecture

• OIDC and RBAC

• AWS workload identity

• Terraform vs. Helm

• Argo CD

• Controllers vs. Operators

• HashiCorp Vault

Round 2

This round focused on designing scalable and secure platforms. The discussion covered shared vs. dedicated clusters, multi-tenancy, RBAC, resource quotas, NetworkPolicy, EKS vs. GKE, cluster upgrades, Terraform state management, and observability.

Round 3

The interviewer tested practical Kubernetes troubleshooting skills, including resource requests and limits, QoS classes, pod eviction, and enforcing resource policies across workloads.

Round 4

This round covered real-world platform management challenges, such as:

• Managing multiple Kubernetes clusters

• Argo CD vs. Flux

• Detecting and handling configuration drift

• Helm-based deployments

• Building developer self-service capabilities

• Maintaining consistent platform standards

Round 5

The final round focused on my overall SRE and platform engineering experience. The discussion included troubleshooting approaches, architectural trade-offs, design decisions, and scaling infrastructure to meet growing demands.

Interview Outcome and Difficulty

Result: Selected

The overall difficulty was medium to hard. A common pattern across the rounds was the emphasis on follow-up questions, such as why a particular design was chosen, what could happen if it failed, and how the solution would scale.

The interviews focused not just on theoretical knowledge but also on practical experience, architectural reasoning, and the ability to handle real-world infrastructure challenges.

My Google L3 interview process in India included a phone screen and a Googlyness round. The process started in early August when a recruiter reached out to me on LinkedIn. Here’s how the process went, along with the coding question and behavioral questions I encountered.

Interview Timeline

• Early August: Recruiter reached out on LinkedIn.

• 2 days later: Completed the GHA (agree/disagree questions).

• 3 days after GHA: Received the online assessment invitation.

• About a week later: Completed the OA, which had two DSA questions. I was able to solve both.

• Around 10 days after the OA: Recruiter contacted me about the phone screen.

• 3 weeks later: Attended the phone screen.

Phone Screen (Virtual)

The coding question involved merging employee shifts into a timeline of non-overlapping intervals. Each shift was represented as [name, startTime, endTime], and the goal was to identify every time segment along with the employees working during that interval.

For example, if multiple employees had overlapping shifts, the output needed to split the timeline at the relevant start and end times and list the active employees for each segment.

I initially jumped into coding without clarifying my approach, which made things a little difficult. However, the recruiter was supportive, and I managed to complete the implementation within the allotted time. There was a bug in my solution, but after receiving a hint and an example, I identified and fixed it.

Googlyness (Virtual)

This round focused on behavioral questions and how I handle situations at work. Some of the questions included:

• Tell me about a time when project requirements changed midway. How did you handle it?

• Describe a conflict you had with your manager and how you resolved it.

• Tell me about a time you failed and what you learned from the experience.

There were around three to four basic questions. Overall, it was a positive experience, and I felt comfortable discussing my past experiences.

The phone screen tested coding ability and problem-solving, while the Googlyness round focused on behavioral skills and handling workplace situations. One important lesson from the coding round was to clarify the approach and edge cases before starting implementation.

I received an offer for the SDE-1 role at Amazon after working at TCS for around two years. The interview process was challenging and helped me understand the importance of problem-solving, communication, and project knowledge.

Online Assessment (OA)

OA included DSA questions, a work-style assessment, and a work simulation.

The coding section covered topics such as dynamic programming, greedy algorithms, trees, graphs, two pointers, and binary search. The questions were mostly story-based, so understanding the problem statement was important.

The work-style assessment was also an important part of the process. I recommend understanding Amazon's Leadership Principles before attempting it.

Technical Interview 1

The interviewer asked two coding questions:

• BFS, Trees, and Graphs: A medium-level problem involving concepts similar to Rotting Oranges.

• Recursion and Backtracking: A harder problem based on Android Unlock Patterns.

I explained my approach, discussed time and space complexity, and worked towards an optimal solution.

I was also asked a behavioural question about handling a tight deadline when requirements kept changing.

Technical Interview 2

This round focused on problem-solving and project experience.

• Greedy Algorithms: A medium-level problem involving root-related optimization.

• Dynamic Programming: A medium-level problem based on variations of the House Robber problem.

The interviewer also asked detailed questions about a project I had worked on, including my responsibilities and how I handled challenges.

Technical Interview 3

This was the most challenging coding round for me.

I was asked a three-dimensional dynamic programming question related to buying and selling stocks with a maximum of two transactions. I explained my solution and discussed how it could be generalized to support K transactions.

We then discussed my experience with generative AI tools, including how I use them during development and my understanding of AI agents and workflows.

Bar Raiser Interview

This round did not include coding questions. Instead, the interviewer focused on my previous work, technical decisions, and project ownership.

Questions included:

• Why did I choose a particular technical approach?

• Why did I use multithreading, and how did I determine whether it was beneficial?

• What alternatives did I consider?

• Tell me about a time I received critical feedback and how I acted on it.

The interviewer wanted to understand my reasoning, ownership, and ability to explain technical decisions clearly.

Preparation Tips

• Focus on understanding DSA patterns instead of memorizing solutions.

• Practise explaining your approach before writing code.

• Discuss brute-force, improved, and optimal solutions along with their complexity.

• Prepare project-related questions, especially about architecture, trade-offs, and your individual contribution.

• Revise Amazon's Leadership Principles and prepare real examples from your experience.

Final Thoughts

The process was challenging, but each round helped me understand what interviewers were looking for. Strong problem-solving skills are important, but clear communication, project ownership, and the ability to explain technical decisions matter just as much.

My biggest takeaway is to practise consistently and prepare behavioural examples alongside coding problems.

I appeared for the Infosys on-campus hiring process, which included an online assessment followed by a technical interview at the Infosys office.

Although I was shortlisted for the interview, I struggled during the final coding round.

Online Assessment (OA)

The assessment had four coding questions, out of which candidates had to solve any three. Different candidates received different sets with varying difficulty levels. I managed to solve one question completely and partially solve another.

Problem 1: Greedy Selection Within a Budget

Despite being named Buy and Sell Stocks II, the problem was unrelated to stock trading. We had to select high-value packets from an array while following an alternating even- and odd-index constraint without exceeding a fixed budget.

I sorted the array and used a greedy approach. I completed it in around 15 minutes, and all 12 private test cases passed.

Problem 2: Trapping Rainwater With Contaminated Pillars

This was similar to the standard rainwater-trapping problem, but some pillars were contaminated. Water touching these pillars could not be counted, so we had to calculate the total valid water collected.

My greedy approach passed only one test case. I then tried a segment tree, which passed a few more cases, but I couldn't find a completely correct solution.

Problem 3: Count Valid String Partitions

We were given a string, such as abcbba, and had to count the ways to partition it into contiguous substrings such that every substring contained the same number of distinct characters.

For example, a | b | c | b | b | a is valid because every substring contains one distinct character. However, abc | bba is invalid because the substrings contain three and two distinct characters, respectively.

The string length could reach (10^5), making brute force too expensive. My solution passed the public test cases but failed the hidden ones.

Problem 4: Minimum Cost to Split an Array

We were given an integer array and had to divide it into contiguous subarrays while minimizing the total partitioning cost.

The challenge was to choose the partition boundaries carefully, as a locally optimal choice might not produce the minimum overall cost. I couldn't figure out an efficient approach.

Despite my performance in the OA, I was shortlisted for the next interview stage. The exact role allocation between SP and DSE was not yet confirmed.
Similar Pattern:

Technical Interview at Infosys Indore

Around 60-70 candidates from different colleges were present, and my interview started later than scheduled.

Introduction and Project Discussion

The interviewer was friendly and started with my introduction, followed by questions about my projects, technologies, and application architecture.

I was asked how my domain-blocking application could handle around one million requests. I explained a caching-based approach to reduce repeated processing and improve performance.

The interviewer liked the project and suggested publishing it on the Play Store. I explained why that wasn't feasible for my application.

Low-Level Design and OOP

We discussed another project where I had followed a production-oriented architecture. The questions covered:

• Factory Design Pattern

• SOLID Principles

• Basic Object-Oriented Programming concepts

The interviewer also asked whether I knew SQL, but no queries were asked.

Overall, the discussion was comfortable, and I felt confident explaining my projects and technical decisions.

Final Coding Round

After the technical discussion, the interviewer opened Wingspan and gave me two DSA questions. I had to solve at least one within 30 minutes.

The interviewer started attending to another candidate while I worked. Since multiple interviews were happening simultaneously in the same hall, the environment was somewhat distracting.

Both questions were within my preparation level, but I froze under pressure and couldn't solve either.

Problem 1: Minimum Flips to Make a Binary String Alternating

We were given a binary string, such as 10101010001. One operation allowed us to flip a bit from 0 to 1 or vice versa, but operations could not be performed on adjacent positions.

We had to find the minimum number of flips needed to make the string alternating, meaning every two adjacent characters must be different.

The key observation is that there are only two possible target patterns: 010101... and 101010.... We can compare the original string against both patterns and determine the minimum required flips while respecting the operation restriction.

I couldn't identify the solution during the interview.

Problem 2: Maximize the Gap Between Products

We were given an array divided into two groups based on the original indices:

• One group contained elements at even indices.

• The other contained elements at odd indices.

We had to maximize the difference between the maximum product of two elements from the first group and the minimum product of two elements from the second group.

The approach involved separating the groups, considering possible pairs, and carefully handling positive, negative, and zero values to determine the required products.

Again, I couldn't organize the cases properly under pressure.

Key Takeaways

• Practise solving coding problems under strict time limits.

• Focus on identifying patterns and explaining your reasoning before coding.

• Revise OOP, SOLID principles, design patterns, and project architecture.

• Prepare for scenario-based questions involving scalability and performance.

• Learn when to abandon an unproductive approach and try another one.

• Practise staying focused even in distracting environments.

Final Thoughts

I was disappointed because the project discussion went well, and both coding questions seemed manageable during preparation. However, I couldn't perform as expected when it mattered.

This experience taught me that knowing the concepts is not enough, applying them calmly under pressure is equally important.

Hello everyone,

I recently interviewed for the Software Engineer (L4) role at Google India, but unfortunately, I did not clear the interview process. I wanted to share my experience and get feedback from people who may have faced similar situations.

I connected with a recruiter for the L4 SWE position and completed the GHA and coding assessment. After getting shortlisted, I attended two virtual interview rounds: one technical round and one Googliness round.

Although I was able to solve the first part of the technical question, I struggled with the follow-up question and one of the behavioural questions. I want to understand where I went wrong and how I can improve before my next attempt.

• Role: Software Engineer (L4)

• Location: India

• Interview Rounds: 2

• Format: Virtual

• Final Result: Rejected

Round 1: Technical Interview

My technical interview involved a problem based on a satellite image represented as an (N * M) grid.

The grid contained two types of cells:

• X represented land or islands.

• . represented water.

A coordinate ((r, c)) was also provided as part of the problem.

Finding the Island Using BFS

For the first part, I was asked to solve a problem similar to the classic island-counting problem.

I proposed using Breadth-First Search (BFS) to traverse the grid and explore the connected land cells. The interviewer agreed with my approach and asked me to implement the solution.

I completed the implementation and explained my approach. I felt that this part went well.

Identifying Lakes Enclosed by Islands

The follow-up question was about identifying or counting lakes enclosed by islands.

I found this part difficult because I could not fully understand the exact requirements. I asked the interviewer for clarification multiple times, but I still struggled to understand what was expected.

Based on my understanding, I suggested checking for lakes while traversing the islands using BFS.

The interviewer said that my approach could also work but mentioned that I did not need to implement the code. We then moved to the question-and-answer portion of the interview.

After the interview, I thought the expected solution might have involved a boundary-based flood-fill approach, but I am still not entirely sure whether that was what the interviewer wanted.

I believe my main difficulty was understanding the follow-up question correctly and identifying the expected approach before proceeding with the solution.

Round 2: Googliness Interview

My second round focused on behavioural questions, with follow-up questions based on my responses.

Most of the questions were standard behavioural questions, but I struggled with one in particular:

"If a project is unclear or there is ambiguity, how would you handle it?"

I could not organise my thoughts properly and struggled to give a structured answer. I stumbled over my words and started discussing things that did not directly address the question.

Looking back, I feel I could have communicated my approach much more clearly.

A better way for me to approach this situation would have been to explain how I would identify the unclear requirements, ask relevant questions, discuss possible solutions with my team, break the project into smaller tasks, and communicate any assumptions or risks before moving forward.

I realised that I need to work on expressing my thoughts clearly and confidently during behavioural interviews, especially when answering questions about teamwork, ownership, and handling ambiguity.

Final Result and Recruiter Feedback

Unfortunately, I received a rejection after completing both interview rounds.

When I spoke with the recruiter, I was told that I needed to strengthen my technical concepts and practise more coding problems.

I was confused by this feedback because the interviewer had accepted my BFS approach and implementation for the first part of the technical question.

However, I understand that solving one part correctly does not necessarily mean that my overall performance met Google's expectations for the L4 role.

I also struggled with the follow-up question and could have communicated my thoughts better during the Googliness round. These areas may have contributed to the final decision, although I do not know the exact reasons behind the rejection.

Final Thoughts

Although I am disappointed with the result, I want to use this experience to identify my weaknesses and improve.

I plan to focus on data structures and algorithms, practise more grid and graph problems, improve my understanding of flood-fill techniques, and work on explaining my reasoning more clearly. I also want to practise behavioural questions so that I can structure my answers better and communicate with more confidence.

I would genuinely appreciate honest feedback and suggestions that could help me perform better in my next interview.

Thanks for reading!

HCLTech's latest quarterly results have brought fresh attention to the growing role of AI in the Indian IT industry. The company reported stronger-than-expected quarterly profits, supported by increasing demand for AI-related services. Following the announcement, its shares rose by 8.4%, reflecting a positive market response to its performance.

While financial results are important for investors, they also raise a bigger question for students, freshers, and working software engineers: How is the growing adoption of AI changing the skills companies expect from engineers?

Why Does HCLTech's Performance Matter?

Indian IT companies have traditionally built large businesses around software development, IT services, application maintenance, cloud migration, and enterprise solutions. AI is now becoming an increasingly important part of this landscape.

Companies are exploring ways to use AI to automate repetitive tasks, improve productivity, modernize existing systems, and deliver solutions more efficiently. As demand for these services grows, software engineers may find new opportunities in AI integration, backend development, data engineering, cloud infrastructure, and automation.

However, the impact may not be the same across every role. While some areas could create new opportunities, others may see changes in the type of work engineers perform and the skills employers prioritize.

What Does This Mean for Freshers Preparing for Software Engineering Roles?

For students preparing for placements, the question is no longer just about learning a programming language. It is also about understanding how to apply technical knowledge to solve real-world problems.

Here are a few areas worth focusing on:

1. DSA and Problem-Solving

Data Structures and Algorithms remain important for many software engineering interviews. A strong understanding of arrays, trees, graphs, dynamic programming, and problem-solving techniques helps candidates build logical thinking and prepare for coding assessments.

2. Development and Real-World Projects

Solving coding problems is useful, but building applications helps demonstrate how well you can apply your knowledge. Working on projects involving APIs, databases, authentication, deployment, and debugging can help you understand the complete development process.

3. AI Tools and AI Integration

Understanding how AI coding assistants work and using them responsibly can help improve productivity. Beyond generating code, engineers should learn to review outputs, identify errors, test solutions, and understand the underlying implementation. Building applications that integrate AI APIs can also provide practical experience.

4. Core Computer Science Fundamentals

Operating Systems, DBMS, Computer Networks, and Object-Oriented Programming continue to provide the foundation for understanding how software systems work. These concepts remain valuable even as development tools evolve.

5. Adaptability and Continuous Learning

The tools and technologies used by engineering teams will continue to change. Being able to learn new frameworks, understand unfamiliar codebases, and adapt to different project requirements can be just as important as knowing a particular technology.

Is AI Creating More Opportunities or Increasing Competition?

There are two sides to this discussion.

On one hand, AI adoption may create demand for engineers who can integrate AI into existing products, automate workflows, and build new applications. It may also allow smaller teams to develop solutions that previously required more time and resources.

On the other hand, automation could reduce the amount of time spent on certain repetitive development tasks. This may change entry-level responsibilities and increase expectations around productivity, practical knowledge, and independent problem-solving.

The overall impact will depend on the company, role, and type of work involved. Growing AI revenue at an IT services company does not automatically mean that fresher hiring will increase or decrease.

What Should Students Prioritize in 2026?

For someone targeting a software engineering role, a balanced preparation strategy could include:

• Building strong DSA and problem-solving fundamentals.

• Learning at least one programming language thoroughly.

• Developing and deploying practical projects.

• Understanding core CS subjects.

• Learning to use AI tools without depending on them blindly.

• Practising technical interviews and explaining project decisions clearly.

The goal should not be to chase every new AI tool. It should be to develop the fundamentals needed to understand, build, debug, and improve software while learning how new technologies can make that work more effective.

With companies such as HCLTech expanding their AI-related business, the expectations for software engineers may continue to evolve.

What do you think will matter most for freshers entering the software industry?

1. Strong DSA and competitive programming skills.

2. Development skills and real-world projects.

3. AI tools, AI integration, and automation.

4. Core CS fundamentals and system design.

5. A combination of all these skills.

If you are currently preparing for placements or already working as a software engineer, share your perspective. Are you changing your preparation strategy because of AI, or do you believe the fundamentals of software engineering will remain the same?

I went through the interview process for the Senior Software Engineer I position at MakeMyTrip (MMT). With around 3 years of experience, I had three technical rounds that covered DSA, React machine coding, system design, and real-world frontend engineering challenges.

I’m sharing my experience and the questions discussed in each round.

Round 1: DSA, React and Project Discussion

The first round started with a DSA problem, followed by a React coding task and a discussion about my previous work.

• DSA: Minimum Platforms Required - Practice here

• React Machine Coding: Build a stopwatch with start, pause, and reset functionality.

• Project Discussion: Questions about my current project, responsibilities, features I had developed, and the technical decisions I made.

This round focused on problem-solving, React fundamentals, and my practical development experience.

Round 2: High-Level Design and React Machine Coding

The second round focused on frontend architecture and handling API requests efficiently.

I was asked to explain the high-level architecture of my current project using Excalidraw. I had around 15-20 minutes to describe the major components, their responsibilities, and how they interacted.

The coding task was to build a search feature in React with debouncing and AbortController. The requirements included API integration, reducing unnecessary requests, cancelling previous requests, and handling rapidly changing search queries without race conditions.

Round 3: Detailed System Design and Technical Discussion

The final round involved a deeper discussion of my project architecture, frontend tooling, AI-assisted development, and collaboration scenarios.

I spent around 30-40 minutes explaining my current project's architecture, including design decisions, component interactions, and the reasoning behind the implementation.

Some of the other topics discussed were:

• Frontend concepts: What is a bundler?

• Dependency injection: What is it, and how is it used in Webpack?

• AI in development: How does my organization use AI, and how can token usage be optimized when working with AI tools?

• Git and collaboration: How would I resolve merge conflicts involving changes from multiple developers?

• Teamwork: How do I handle technical disagreements and collaborate with other developers?

This round was largely discussion-based and tested my understanding of frontend architecture, engineering decisions, and real-world development challenges.

Final Outcome

I was selected for the Senior Software Engineer I role at MakeMyTrip.

Introduction

Hi everyone,

I recently interviewed for the Software Engineer L3 role at Google India, and I’m happy to share that I have received and accepted the offer.

I’m sharing my interview experience in detail because TUF helped me a lot during my preparation. I hope this post helps others who are preparing for software engineering interviews at Google.

Round-by-Round Experience

Round 1: Virtual Technical Interview

The first round was a technical interview conducted virtually. The interviewer asked a coding question based on an existing problem, but with a small variation.

Question: Maximum Good Subarray Sum (Modified Version)

In the original problem, we need to find the maximum sum of a good subarray. In this interview, the requirement was slightly different. Instead of finding the maximum sum, I had to return any valid pair of indices (i, j) that satisfied the given conditions.

The main challenge was to understand the modified requirement and identify a suitable approach to find the required indices.

This round tested my problem-solving skills and my ability to modify an existing approach according to the question's requirements.

Round 2: Virtual Googliness Interview

The second round was a behavioural interview, commonly referred to as the Googliness round at Google.

The interviewer asked simple behavioural and hypothetical questions. These questions focused more on how I think, how I handle different situations, and how I approach problems outside of coding.

The questions were not particularly difficult, but they required clear and thoughtful answers.

My approach was to understand the situation described in each question and explain how I would handle it.

Round 3: Onsite Technical Interview (String and Partitioning Problem)

The third round took place at Google's office. It was one of two technical interviews scheduled back-to-back on the same day.

The interviewer presented a story-based problem. After understanding the story, the actual problem could be described as follows.

Problem Statement:

You are given a string containing only two characters: 'a' and 'b'.

It is guaranteed that the total number of 'a' characters and the total number of 'b' characters in the string are both even.

You can make at most two cuts in the string to divide it into smaller parts. These parts must be distributed between Alice and Bob so that both receive the same number of 'a' characters and the same number of 'b' characters.

In other words:

• Alice and Bob must have an equal number of 'a' characters.

• Alice and Bob must have an equal number of 'b' characters.

• You can make no more than two cuts.

• You need to return the index or indices where the cuts should be made.

What made this question interesting?

The main challenge was to determine where the string should be divided so that both Alice and Bob receive equal numbers of both characters.

Since the string contains only two types of characters, it was important to track their counts carefully and identify valid cutting positions.

This question tested logical thinking, string processing, and the ability to identify a valid partition under a limited number of operations.

Round 4: Onsite Technical Interview - Array and Equal Sum Problem

The fourth and final round was also conducted at Google's office on the same day as the previous technical round.

Like the previous question, this was presented as a story-based problem. Once the story was simplified, the actual requirement became clearer.

Problem Statement:

You are given an array of integers.

In one operation, you can select any element from the array and remove it. After removing that element, you need to determine whether the remaining array can be divided into two contiguous subarrays with equal sums.

The task is to check whether such a division is possible after removing exactly one element.

What was the main challenge?

The important part was to consider which element to remove and whether the remaining elements could be divided into two parts with equal sums.

The solution required careful reasoning about array elements, their total sum, and the possible positions where the array could be split.

This question tested array manipulation, prefix-sum-style reasoning, and the ability to evaluate different possibilities efficiently.

Interview Feedback and Result

I was able to solve all four interview questions and received positive feedback from every round.

One piece of feedback I received was to improve my time management. Although the overall feedback was positive, this was an area where I could improve further.

After completing all the interviews, I received a call from my recruiter within two days. The recruiter informed me that I had cleared the interviews and that my profile was being sent to the team-matching stage.

Google Hiring Process After the Interviews

After clearing the interview rounds, the remaining process moved forward quite quickly.

1. Interview Results

Within two days of completing the interviews, the recruiter informed me that I had cleared all the rounds.

2. Team Matching

My profile was sent for team matching, and I received a team match within two business days. I also had a good conversation with the hiring manager.

3. Hiring Committee (HC)

After the team-matching stage, my profile and interview feedback were sent to the Hiring Committee for review.

4. Compensation Discussion

Around three days after my profile was sent to the Hiring Committee, the recruiter contacted me to discuss compensation.

5. Offer Received

I received the offer on the same day as the compensation discussion and accepted it.

Overall, the process after the interviews was relatively quick, with updates coming within a few business days at each stage.

Preparation Advice and Final Thoughts

If I had to share one piece of advice with anyone preparing for Google interviews, it would be to believe in yourself and keep preparing, even when things don't go your way.

Before receiving this offer, I had faced around 10 rejections from Google. I had not even progressed to the online assessment or interview stage in those earlier attempts.

Because of those experiences, I never expected that things would work out this time. However, on a random Wednesday, I received the news that I had cleared the interviews.

Looking back, the journey taught me that rejection does not necessarily mean you are incapable. Sometimes, you need to keep improving, stay consistent, and be ready when the right opportunity comes along.

My suggestion is to keep practising DSA, focus on understanding the logic behind problems instead of memorising solutions, and work on explaining your thought process clearly during interviews. Also, pay attention to time management, as solving a problem efficiently is just as important as arriving at the correct answer.

Most importantly, don't let previous rejections decide what you believe you can achieve.

Whatever you believe in, whether it is God, destiny, or fate, remember to believe in yourself too.

Thanks for reading, and all the best to everyone preparing for their interviews!

Recently appeared for the Amazon Online Assessment (OA) for a full-time SDE role and wanted to share my experience with the new assessment format.

1. DSA Coding Round

The question was Constructing Two Increasing Arrays. The problem was presented as a story, so I had to understand the scenario before identifying the underlying logic.

I had practised this question earlier after coming across a discussion about a similar assessment. This helped me recognise the problem and approach it with confidence.

2. AI-Assisted Coding and Debugging

This was the most challenging section for me. I could not pass any of the six test cases.

Before starting, I had to choose a framework. I selected Django because I know Python, although I had never built a project using Django. Node.js and C++ were also available.

The task involved an existing car rental website with two main issues:

• Users could not publish their cars for rent.

• Some cars were being displayed when they should not have been.

I used AI to navigate the codebase and identify bugs in functions such as host_car. Some functions had incomplete implementations, including missing input handling and response logic.

Although AI helped me locate the issues, I struggled to fix them successfully. This made me realise that I need more hands-on experience with frameworks and debugging existing applications.

3. Work Simulation

This section was described as a 45-minute assessment, but I did not see a timer.

I was given three workplace scenarios and had to rate responses on a scale of 1 to 5. The questions focused mainly on teamwork, decision-making, and Amazon's Leadership Principles.

I found the Amazon Bound YouTube channel useful for preparation.

4. Work Style Survey

This section was also untimed in my experience. I had to choose which of two statements best described my working style, including how I plan tasks and learn new things.

I answered based on my usual habits and preferences.

My Suggestions

Based on my experience, I would recommend the following:

• Practise DSA: Focus on understanding problem-solving patterns rather than memorising solutions.

• Learn a framework practically: Knowing Python alone was not enough when working with an unfamiliar Django codebase.

• Practise debugging: Learn to trace function calls, understand incomplete implementations, and test fixes.

• Prepare for workplace scenarios: Understand Amazon's Leadership Principles and practise behavioural questions.

One Important Suggestion

Amazon's practice OA is useful for understanding the assessment format, but I would not rely on it to judge the actual difficulty.

In my practice attempt, the DSA questions were relatively easy, and I only had to identify two bugs in the debugging section. My actual OA was quite different, especially the AI-assisted coding task.

My biggest takeaway: Knowing a programming language is not the same as being able to debug an existing application.

I hope my experience helps others prepare for the different sections of the Amazon OA. Thanks for reading!