I recently had an interview experience with Adobe for a CS1 role. I have 4 years of experience and was interviewing for their ALM Org. The process involved three distinct rounds, each testing different facets of my technical and behavioral skills.

Round 1 (Technical)

Round 2 (Technical)

Round 3 (System Design & Behavioral)

I recently had my interview experience for the Adobe MTS 2 role, which spanned a total of six rounds and took two months to complete.

ROUND 1: Technical Interview

This round involved a medium-level question primarily focused on the Disjoint Set Union (DSU) data structure, followed by several follow-up questions to delve deeper into my understanding.

ROUND 2: Technical Interview - Toughest Round

This was by far the toughest round for me. It covered a wide array of in-depth topics:

• Extensive questions on Multithreading.
• Detailed discussion on B+ trees.
• Problems related to Bipartite graphs.
• Questions on Virtual Destructors in C++: what they are, why they're needed, and how they function.
• The infamous Diamond Problem in C++.

There was a significant number of questions from these topics, pushing my knowledge boundaries.

ROUND 3: Technical Interview

This round also had a strong focus on C++ concepts. Key areas included:

• Numerous C++ questions.
• A problem based on the Two-Pointer technique.
• Questions regarding Connected Components in graphs.
• One Low-Level Design (LLD) question: designing a garbage collector in C++.

ROUND 4: Technical Interview

Similar to previous rounds, this one also heavily featured C++ questions. A lot of focus was placed on Smart Pointers. Additionally, I faced one question that required a Backtracking approach.

ROUND 5: Hiring Manager Round

Having successfully navigated four technical rounds, this round was purely behavioral. The Hiring Manager posed many tricky questions, which I tried to answer as diplomatically as possible. I must admit, I fumbled quite a bit due to panic, but I tried my best to maintain composure.

ROUND 6: Director Round

In stark contrast to the previous rounds, especially Round 2, this was the easiest. I had a very pleasant and insightful discussion with the Director, who seemed like a genuinely nice person – a rare trait to find at such a senior position. After this discussion, I felt quite confident about receiving an offer.

True to my feeling, after two days, the HR informed me that I had successfully cleared all rounds! I was absolutely thrilled to receive the offer.

Round 1: Data Structures & Algorithms

I was presented with two questions. The first problem asked me to minimize the sum of array elements after performing a division operation K times. I solved this LeetCode easy question using a PriorityQueue, achieving a time complexity of O(N log N) and space complexity of O(N).

The second question was a slight variation of the classic Knapsack Problem, which I approached with a 2D DP solution and some optimizations, resulting in O(N) time and O(1) space complexity.

Round 2: Low-Level Design (LLD)

In this round, I was asked to design a configuration management service, detailing the class designs, attributes, methods, and appropriate design patterns.

Round 3: Low-Level Design (LLD)

This round also focused on LLD and included two questions. The first was to design an auto-complete search system that predicts Top K elements based on search frequency. I tackled this problem using a Trie data structure with some variations, identifying it as a LeetCode hard question. The second question involved designing the Java implementations for Linux commands like mkdir, ls, and delete for files and directories. I used a Tree Data Structure for this, but unfortunately, I could only complete one function within the given time.

Despite my efforts, the final verdict was a rejection.

As a Data Scientist/MLE with 3+ years of experience and a B.Tech from IIT (non-circuital branch), I went through a structured interview process at Adobe. The first round was an end-to-end design question focusing on image + text (document-type) data, requiring a complete pipeline to predict aspect ratio from the given data/document. The second round included a Python coding question followed by a deep dive into LLMs, transformers, and attention mechanisms. The third round was a managerial discussion on projects, teamwork, and behavioral questions. The fourth round involved a system design question to create a color suggestion system, along with team and work-related discussions. I was offered the position and will share compensation details in another post soon.

My interview process for a Senior Android Design Engineer role on the Spectrum Design Team at Adobe consisted of three rounds.

Round 1: Hiring Manager Round
This round was with a very friendly Hiring Manager. We discussed my previous experiences, with a particular focus on Jetpack Compose and my experience with Design Systems. The manager was especially interested in the interoperability between View systems and Compose.

Round 2: Android Coding
In this coding round, the interviewer asked me to implement a Compose function. The question revolved around drawing objects on the screen and ensuring they were retained correctly during orientation changes. Key concepts discussed included remember, rememberSaveable, and Custom Saver.

Round 3: Android Coding
For this coding round, I was allowed to use Android Studio with auto-complete, which was helpful. The core problem was about retrieving data from a given endpoint and then efficiently populating that data into a list view.

Throughout the coding rounds, the focus was heavily on Android Jetpack Compose View concepts such as Stable and Immutable states, as well as performance considerations for views, including efficient data handling, pagination, and lazy loading. There were no DSA (Data Structures & Algorithms) rounds.

I had my first interview round for an MTS2 C++ position at Adobe on August 26th. The interview felt positive, and I believe I performed well during the session. However, since then, there has been no communication or notification from their side regarding the outcome or next steps.

I applied for several roles at Adobe, primarily MTS 2, and received a callback from a recruiter after about a month. The interview process at Adobe is structured with sequential rounds.

Round 1: DSA, System Design, OOPs, DBMS

My first round focused on Data Structures & Algorithms, System Design, Object-Oriented Programming (OOPs), and Database Management Systems (DBMS). I was asked a LeetCode medium-hard question:

• Find Median from Data Stream: I clearly built the solution using two priority queues and explained my approach, writing pseudo code.

Then, the interviewer delved into various system design questions covering scaling, performance, concurrency, load balancers, CAP theorem, and DBMS concepts like locking, SQL vs NoSQL, normalization, OS-level locks, and atomicity. I also had to implement an LRU cache, again providing pseudo code. This round lasted approximately 70 minutes.

I received an email for Round 2 the same day.

Round 2: DSA, CI/CD, AWS, Kubernetes, Docker, Kafka

The second interviewer was very approachable. They posed a medium DSA question that was quite lengthy to read but essentially involved backtracking with proper constraint handling. I had to write the full code and test it with sample cases. My second question was LeetCode 825 (Friends Of Appropriate Ages), which I solved and demonstrated with provided inputs. Following this, we discussed my experiences with Jenkins, CI/CD pipelines, build processes, production tools, AWS, Kubernetes, Docker, scaling, and Kafka.

Two days later, I received an email for Round 3. By this point, I had already secured a better offer, so I approached this round very calmly, mostly out of curiosity.

Round 3: Hiring Manager (HM) - Projects, Behavioral, Release Engineering

This was a hiring manager round where I was thoroughly grilled on my projects and past experiences. The questions covered ownership, challenges encountered, end-to-end project involvement, leadership skills, innovation, voluntary acts, and debugging skills.

The HM then informed me that the role was primarily for a Release Engineer with a strong focus on Jenkins, which significantly diminished my interest in joining Adobe. Despite this, I maintained a facade of interest, and they proceeded with Jenkins-specific questions.

• Job Scheduling (Two Schedulers): Given an array of job times, I was asked to determine the minimum time to complete all jobs using two schedulers, where each scheduler can perform one task at a time. I solved it and explained my approach.
• Job Scheduling with Dependencies: The next question involved tackling job scheduling when jobs have dependencies. I discussed using topological sort and how the presence of a loop would make the problem unsolvable, outlining my strategy to handle this.

The interviewer seemed pleased with my responses.

After another two days, I received an email stating I had cleared all rounds, with only a director round remaining (described as similar to a standard HM round). However, I ultimately declined the offer as I decided not to proceed further.

Overall, my experience was positive. The HR team was very accommodating and adjusted interview times promptly upon my request. Interviewers were friendly and provided ample time for me to think through and articulate my approaches.

I interviewed with Adobe for an MTS 2 JAVA role, coming from a Tier 3 college with 2+ years of experience. This was my first time interviewing with the company.

Round 1 (Problem Solving)

1. Tell whether at least two non-overlapping increasing subarrays of length k exist in an array.
2. Find the maximum length of a subarray such that it contains at least two non-overlapping increasing subarrays.

Round 2 (Problem Solving - Java Focus)

1. Implement a concurrent HashMap with get, put, and delete operations.
2. Given a tree where each node has left, right and parent pointers, implement lock() and unlock() methods for a node. The condition for locking a node was that all its ancestor nodes and all its descendant nodes must be unlocked.

Adobe MTS 2 Interview Journey

I recently had the opportunity to interview for the MTS-2 role at Adobe in Noida. The process began after HR contacted me via Instahyre regarding an SDE position. Following an initial call, my first technical round was scheduled.

Technical Round 1

This round primarily focused on algorithmic problem-solving and included two challenging questions. The difficulty ranged from medium to hard on LeetCode. First, I was asked to find the longest continuous sequence in an array, a classic problem requiring a strong understanding of array manipulation and dynamic programming. Fortunately, I had encountered and solved this problem previously, which helped me complete it efficiently.

The second question was directly from LeetCode: "Apply Operations to Make Two Strings Equal." This problem tested my string manipulation skills and required an analytical approach to find an optimal solution. We spent about 10 minutes discussing various approaches before I wrote the code, which successfully passed the test cases presented by the interviewer.

Technical Round 2

The second technical round was again centered on Data Structures and Algorithms, with a particular emphasis on modified binary search. The interviewer presented an interesting twist: the mid-point in the binary search was generated by a random function. My task was to write code for numbers that would be searched appropriately with this modified binary search approach. The discussion also included follow-up questions aimed at identifying elements in an array that would be correctly found using this particular binary search method.

EM Round

The third technical round, led by an Engineering Manager, delved into system design and practical scenarios related to my prior job experience. The interviewer asked questions on operating systems to assess my understanding of core concepts and their real-world applications. We also discussed my current job responsibilities and past projects, which provided insight into my professional background. I was asked to elaborate on the system design of WhatsApp, which naturally led to discussions about message queues and scalability challenges. Furthermore, I shared my long-term career goals and explained why Adobe was an ideal fit for my aspirations.

Director Round

The final round was with a Director, starting with general discussions about job-related queries before moving into technical discussions on data structures and system architecture. The conversation began with designing an airline system, focusing on graph theory and complexity analysis. Additionally, we talked about caching mechanisms and on-call support, addressing practical challenges encountered in software development and maintenance. I also shared my perspectives on monitoring tools and request authentication mechanisms, demonstrating my understanding of industry best practices and emerging trends.

Verdict

I later received a call from HR confirming my selection for the MTS-2 role, which was a very satisfying outcome.

I applied for a CS1 position at Adobe through an employee referral and received an interview call within two weeks. The entire process lasted about 4-5 weeks.

Round 1: Technical
This round focused on data structures and algorithms. I was asked to solve two LeetCode problems: Group Anagrams and Merge Intervals.

Round 2: Technical
Another technical round where I tackled the Median of Two Sorted Arrays problem.

Round 3: System Design
The focus here was on the Low-Level Design (LLD) of a client-side rate limiting library. The interviewer expected me to code a rate-limiting algorithm. I designed and explained a complete, thread-safe solution with a driver class demonstrating client ID-based rate limiting. We then discussed potential test cases for this code, including how to test threaded clients here, etc.

Round 4: Hiring Manager
This round started with extensive discussions about my previous work experience. The interviewer asked some quick questions on concurrency, binary semaphores, and mutexes.

Then, an open-ended question about linear search in an array was posed. I was asked to write an algorithm to search an element in an unsorted array, then modify the loop to be unbounded, and finally, address potential issues without using try/catch blocks. I explained that an unbounded loop would eventually lead to memory issues like stack overflow or integer overflow. I suggested increasing JVM memory or breaking the loop under certain conditions, but acknowledged that the linear search algorithm itself would eventually fail for some test cases. I attempted to use some things like bit manipulations or 'hacks' to control the infinite loop by decrementing the loop variable, but these weren't what the interviewer was looking for. I realized I wasn't clear on their expectations, which I believe was a turning point. Later, typical operational questions followed, such as how I handle conflict, what my manager would say about me, and how I react to not receiving credit for my work. I answered these confidently.

Verdict: Rejected!

My interview journey for the MTS-2 role at Adobe in Noida was insightful. I hold a B.Tech in CS and have 3.5 years of experience as an SDE in a product-based company. The process consisted of four rounds.

Technical Round 1 (1 hr):
This round included questions based on Binary Search, with a specific constraint to use exception handling for certain cases. I also encountered a variation of the chocolate distribution problem. Additionally, the interviewer delved into C++ and OS concepts.

Technical Round 2 (1 hr):
During this round, I was asked to implement a function to copy a linked list with random pointers. I had to write multiple test cases and dry run them until the interviewer was satisfied with my explanation. A significant portion of this round also involved questions on C++ and OS.

Manager Round (40 mins):
I tackled the Balanced Parenthesis Problem and a puzzle involving 100 people in a circle, which is essentially the Josephus Problem, requiring me to write generalized code for it. This round also included more questions on OS.

Director Round (1 hr):
The final round involved some behavioral questions and a discussion about my projects. C++ and OS concepts were revisited. A notable question involved implementing a solution to safely share a variable between multiple threads, similar to the Reader-Writer problem, which I had to compile and run on an IDE.

Overall, my opinion is that Adobe generally asks easy to medium level coding problems, but their primary emphasis is on OOP concepts.

Round 1: Coding and Problem Solving

This round focused on my coding and algorithmic skills. The interviewer presented two problems:

1. First, I was asked to determine if there exists any contiguous subarray within a given array that sums to zero.
2. Following that, the second question built upon the first, requiring me to find the longest contiguous subarray within the array that sums to zero.

Round 2: Low Level Design

This round delved into my object-oriented design capabilities. I was tasked with designing a single entry-exit, single-floor parking lot, emphasizing OOP principles. A follow-up to this question introduced multi-threading, where I had to explain how parking slots would be assigned to multiple vehicles concurrently, testing my knowledge of concurrent data structures, synchronized keywords, and locks.

Round 3: Managerial Round

The managerial round started with a deep dive into my past projects, discussing their architecture, challenges, and my contributions. After the project discussion, I was presented with two more programming questions:

1. I needed to find the minimum number of jumps required to reach the end of an array, with a specific instruction to solve it using a greedy approach in O(n) time complexity.
2. The second problem involved finding the largest mountain subarray within a given array.

I found it important to maintain extreme calm and composure during this round, as it could become frustrating at times.

Round 4: Directoral Round

I recently completed my directorial round and am currently awaiting feedback. I will update this post once I receive the outcome.

I recently interviewed for a C++ developer position at Adobe, which consisted of two distinct rounds.

In the first round, I was presented with a problem from LeetCode, specifically Jump Game IV. I attempted to solve this problem but was not able to fully complete it during the interview. Following that, I was given a small C++ question involving class instantiation and asked to identify if it would compile successfully. The code snippet was:

Class A{
}
int main(){
A obj;
A *obj=new A();
}

The second round featured another LeetCode problem, Open the Lock. Additionally, I was questioned about various C++ constructor types and tasked with implementing them for a custom String class.

Status and Background

I was working as an SDE-1 at Samsung Research Institute Delhi and graduated in 2018 with a B. Tech. in Computer Science from NIT Kurukshetra, India. My interview for the MTS-1 position at Adobe Systems in Noida, India took place on May 1, 2019.

1. Online Assessment Test (HackerRank)

The first stage was an online assessment on HackerRank. It comprised:

• 15 aptitude questions (15 mins)
• 5 input-output programs (15 mins)
• 2 programming questions (45 mins)

2. On-site Round 1 - Technical Round (1 Hour)

This round began with a discussion on my projects, including their architecture diagrams. Following that, I was asked several programming and theoretical questions:

• How to sort an array containing 0s and 1s in a single pass with O(n) time and O(1) space complexity.
• A problem to add 1 to a number represented as a singly linked list. Each node represented a digit, with the head pointing to the most significant digit. The challenge was to do this in a single traversal.
• I had to determine the number of different ways to form an N-bit binary number such that no two consecutive 1s occur. For N=3, examples like 101, 010, 000, 001, 100 are valid (output: 5), while 110, 111, 011 are invalid. I wrote a program, but the interviewer mentioned there's also a mathematical formula for it.
• I was asked about the Producer-Consumer problem, including writing pseudo-code. We also discussed semaphores, mutexes, critical sections, and potential deadlock scenarios involving wait() and signal() operations.

3. On-site Round 2 - Technical Round (1 Hour)

This round involved a deep dive into one of my projects. The interviewer skillfully transformed the project discussion into a problem and posed many follow-up questions. The core problem was:

How would you represent an image in memory, for example, as a matrix where each cell is a pixel? Considering a monochrome image represented by such a matrix, how would you programmatically draw a line segment on it? This meant filling the cells that the line segment would pass through. I had to account for both axis-aligned and non-aligned line segments and write a program for it. I initially assumed integer endpoints for the line segment and coded accordingly. The interviewer then challenged me on whether the code would work for float/double endpoints and we discussed generalizing the solution. We also covered boundary cases: what if the line segment's endpoints are outside the matrix, or if the segment is only partially inside? For a line segment not aligned to any axis and not bounded by the matrix, I was asked how to find the point where it first enters or exits the matrix.

4. On-site Round 3 - Technical Round (1 Hour)

This round covered a mix of C/C++ fundamentals, data structures, and algorithms:

• Questions on pointers, such as the validity of pointer differences and pass-by-reference in functions.
• What happens when an object of a class is declared and memory is allocated to it?
• Questions on object-oriented programming concepts like inheritance, polymorphism, and virtual functions.
• I was asked to implement a Hash Table with the following APIs: void insert(int key, int value), void delete(int key), int search(int key), and int getRecentElement(). The getRecentElement() API should return the key of the element most recently touched by either insert() or search(). All APIs were expected to operate in O(1) time, assuming no duplicate keys.
• A problem to search for an element in an array where each consecutive pair of elements differs by exactly 1 (i.e., |A[i] - A[i+1]| = 1 and |A[i-1] - A[i]| = 1).
• Given N threads and single instances of N different types of resources, how would I allocate resources to threads to avoid deadlock and minimize waiting time? This assumed threads could arrive at any time and request any number of resources, without knowing their arrival schedule.

5. On-site Round 4 - Director Round (1 Hour)

This was a broader discussion round:

• We discussed my projects.
• I was asked how to identify whether software I'm about to install on my PC is malware, providing methods for both pre-installation and post-installation.
• Following up on that, I was asked how to identify if the software had deleted or added files to my file system. I suggested comparing the file system's tree structure before and after installation.
• Building on the previous question, I was given two files containing lists of file names (representing states before and after installation) and asked to write pseudocode for a fileDifference(File A, File B) function to find the differences.
• A combinatorics problem: Given an N x N matrix, how many ways are there to reach the top-right corner from the bottom-left, moving only Up, Right, and Up-Right diagonally? I used a dynamic programming approach, but the interviewer prompted me to derive a mathematical formula. (I later learned this relates to Delannoy Numbers).

6. On-site Round 5 - Manager Round (1 Hour)

The final round was with a manager, focusing on problem-solving and logic:

• I had to write a program to convert a number into English word format, specifically using the Indian Currency system (e.g., 1,23,500 to “One Lakh Twenty Three Thousand Five Hundred”, 100 to “One Hundred”).
• Another task was to write a program to check if two given binary trees are mirror images of each other.