Adobe MTS-2 Interview Experience | DSA, System Design, DevOps & Hiring Manager Round

I recently interviewed for the Member of Technical Staff 2 (MTS-2) role at Adobe. The hiring process took around 3–4 weeks and consisted of three technical rounds. The interviews covered a broad range of topics, including data structures and algorithms, system design, operating systems, databases, object-oriented programming, DevOps and project discussions.

Unlike interviews that focus solely on coding, Adobe evaluated both problem-solving ability and conceptual understanding across multiple domains. Here's a detailed breakdown of the interview process.

Interview Overview

Round 1 – DSA + CS Fundamentals

The first interview started with a classic streaming data structure problem before moving into rapid-fire discussions covering several core Computer Science topics.

Coding Discussion – Median in a Data Stream

The interviewer asked how to continuously maintain the median of a stream of incoming integers. Instead of writing complete production code, the focus was on explaining the algorithm, discussing the intuition and writing pseudocode.

Key Observation

The median divides the numbers into two halves:

• The smaller half
• The larger half

If we can efficiently maintain these two halves, finding the median becomes trivial.

This leads to using two heaps.

Approach

The optimal solution uses two priority queues (heaps):

• A max heap to store the smaller half of the numbers.
• A min heap to store the larger half.

Whenever a new number arrives:

1. Insert it into the appropriate heap.
2. Rebalance the heaps if their sizes differ by more than one.
3. The median is either the top element of one heap or the average of both heap tops.

//Pseudocode
initialize maxHeap
initialize minHeap

function addNum(num)

    if maxHeap is empty OR num <= maxHeap.peek()
        maxHeap.add(num)
    else
        minHeap.add(num)
    if maxHeap.size > minHeap.size + 1
        minHeap.add(maxHeap.removeTop())

    else if minHeap.size > maxHeap.size + 1
        maxHeap.add(minHeap.removeTop())

------------------------------------------------

function findMedian()

    if both heaps are empty
        return "No elements"
    if sizes are equal
        return (maxHeap.top + minHeap.top) / 2.0
    if maxHeap larger
        return maxHeap.top
    return minHeap.top

Complexity

• Insertion: O(log N)
• Median Query: O(1)
• Space Complexity: O(N)

The interviewer was interested in understanding why this approach works and how balancing the two heaps guarantees efficient median maintenance.

System Design Discussion

The conversation then shifted to distributed systems and scalability. Topics included:

• Horizontal scaling
• Load balancing
• Concurrency
• Performance bottlenecks
• Designing scalable services
• Handling increasing traffic

Rather than expecting a complete architecture, the interviewer focused on reasoning through design decisions and discussing trade-offs.

Database Management Systems (DBMS)

Several database concepts were discussed, including:

• SQL vs NoSQL databases
• Database normalization
• Transaction atomicity
• Locking mechanisms
• Concurrency control
• ACID properties
• Isolation levels

Most questions were scenario-based and assessed conceptual understanding rather than memorization.

Operating Systems

The interviewer also covered operating system fundamentals. Discussion topics included:

• Mutexes and locks
• Synchronization
• Isolation levels
• Transaction management
• Process concurrency

Object-Oriented Programming

The final topic in this round was designing an LRU Cache. Instead of asking for full code, the interviewer wanted a high-level design and pseudocode. The discussion covered:

• HashMap + Doubly Linked List implementation
• O(1) insertion and lookup
• O(1) eviction
• Design rationale
• Time complexity

Overall, the interviewer valued clear explanations and design thinking more than writing lengthy code.

Round 2 – DSA + DevOps Discussion

The second interview began with coding problems before moving to infrastructure and DevOps concepts.

Problem 1 – Backtracking with Constraints

The first coding problem involved a constraint-based backtracking algorithm. Although the problem statement was lengthy, the underlying approach was based on recursive exploration while validating constraints at every decision point. The interviewer evaluated:

• Recursive thinking
• Constraint handling
• Code organization
• Debugging skills
• Complexity analysis

The complete solution was implemented and tested against multiple cases during the interview.

Problem 2 – Friends of Appropriate Ages

The second question was the well-known Friends of Appropriate Ages problem. The task required determining the number of valid friend requests based on age-related constraints.

Problem Statement

Given an array ages, where ages[i] represents the age of the i-th person, determine the total number of friend requests sent.

A person x will not send a friend request to person y if any of the following conditions is true:

If none of the above conditions hold, then x can send a friend request to y. A person cannot send a friend request to themselves.

Return the total number of valid friend requests.

My Approach

The algorithm maintains these invariants:

• left always points to the first age greater than senderAge / 2 + 7.
• right always points to the last age less than or equal to senderAge.
• Every person between left and right satisfies:

senderAge / 2 + 7 < receiverAge <= senderAge

• The sender is included in this range exactly once, so right - left counts all valid receivers except the sender.

import java.util.Arrays;

public class FriendsOfAppropriateAges {

    public static int numFriendRequests(int[] ages) {

        Arrays.sort(ages);

        int left = 0;
        int right = 0;
        int requests = 0;

        for (int i = 0; i < ages.length; i++) {

            int senderAge = ages[i];
            int lowerBound = senderAge / 2 + 7; // by age[y] <= 0.5 * age[x] + 7

            // No possible receiver exists
            if (lowerBound >= senderAge) // by age[y] > age[x]
                continue;

            // First age > lowerBound
            while (left < ages.length &&
                    ages[left] <= lowerBound) {
                left++;
            }

            // Last age <= senderAge
            while (right + 1 < ages.length &&
                    ages[right + 1] <= senderAge) {
                right++;
            }
            // Exclude sender itself
            if (right >= left) {
                requests += right - left;
            }
        }
        return requests;
    }

    public static void main(String[] args) {

        int[] ages = {16, 17, 18};

        System.out.println(numFriendRequests(ages));
    }
}

DevOps and Infrastructure Discussion

The coding section was followed by an in-depth discussion on software delivery and production infrastructure. Topics included:

• Jenkins pipelines
• CI/CD workflows
• Build automation
• Deployment strategies
• Production debugging
• AWS services
• Docker
• Kubernetes
• Kafka
• Monitoring and troubleshooting

The interviewer also asked about scripting and practical experiences with deployment automation and production support.

This round emphasized real-world engineering practices alongside algorithmic problem solving.

Round 3 – Hiring Manager Discussion

The final interview focused on project experience, ownership and technical leadership. The hiring manager explored:

• Significant projects
• Technical challenges
• Ownership
• Leadership experiences
• Cross-team collaboration
• Decision-making under pressure
• Learning new technologies

A major discussion point was the actual nature of the role. The manager explained that the position involved substantial work related to:

• Release engineering
• Jenkins pipeline development
• Build automation
• Job scheduling

Since my primary interest was backend software development rather than release engineering, we discussed my prior exposure to these technologies and how I would approach learning areas where I had limited hands-on experience.

Scheduling Discussion

The interviewer also asked conceptual questions related to job scheduling. Topics included:

• Scheduling tasks across multiple executors
• Dependency management
• Topological sorting
• Detecting circular dependencies
• Why cyclic dependency graphs cannot be scheduled

These questions assessed understanding of graph algorithms in practical engineering scenarios.

Overall Experience

The Adobe MTS-2 interview process covered a broad spectrum of software engineering concepts rather than focusing exclusively on coding. While data structures and algorithms formed the foundation of the technical interviews, significant emphasis was placed on system design, operating systems, databases, object-oriented design, DevOps practices and real-world engineering experience.

The interviewers valued clear communication, structured thinking and the ability to explain trade-offs. Many discussions revolved around architectural decisions, production systems and practical problem solving instead of simply arriving at the correct algorithm.

One important takeaway was ensuring that the responsibilities of the role align with your technical interests. During the hiring manager discussion, it became clear that the position was centered more on release engineering and CI/CD infrastructure than backend product development, which ultimately influenced my enthusiasm for the role.

Preparation Tips

If you're preparing for Adobe's MTS-2 interviews, focus on the following areas:

• Arrays, Hashing, Heaps, Graphs and Backtracking
• Streaming data structures (Median Finder, LRU Cache)
• Object-Oriented Design
• System Design fundamentals
• Operating Systems and Concurrency
• Database concepts (SQL, NoSQL, ACID, Isolation Levels)
• CI/CD pipelines and Jenkins
• Docker and Kubernetes
• AWS fundamentals
• Kafka and distributed messaging
• Production debugging and troubleshooting

Practice explaining your solutions clearly, as interviewers often prioritize reasoning, design decisions and communication over writing lengthy code.

Final Verdict

• Round 1: DSA + System Design + DBMS + OS + OOP
• Round 2: Coding + DevOps Discussion
• Round 3: Hiring Manager + Project Discussion

Overall Result: Rejected

Although the outcome was not positive, the interview experience was insightful and provided valuable exposure to a wide range of software engineering topics commonly evaluated in senior technical interviews.