Jobra
🐞Step 1 of Jobra:AI Debugging Rounds
DSA+AIPreparing you for both.
JOBRA · AI DEBUG ROUND (PREVIEW)sum.cpp
// buggy snippet
int total(vector<int>& a, int n) {
    int sum = 0;
    for (int i = 0; i <= n; i++) { // 🐞        sum += a[i];
    }
    return sum;
}
A real codebase. A real bug. You + AI.

Jobra drops you into a broken repo. Find it, fix it, ship it. AI helps you debug like on the job.

Prompt:Correct the loop condition
Tap 'Let Jobra fix it' below to simulate AI debugging...

How to Crack Adobe: The Software Engineer Interview, From Real Experiences

33 min read

How the Adobe software engineer interview works: hackathon OA, DSA, design, hiring manager and director rounds, with real candidate experiences and a prep plan.

In this article
On this page

How to Crack Adobe: The Software Engineer Interview, From Real Experiences

Last reviewed November 20, 2026 · 26 min read · For campus and new-grad hires, MTS-2, CS-1 and CS-2 or senior candidates

Built by the Codinzhub team. This guide is built from Adobe software engineer interview experiences that candidates shared, including posts on Codinzhub. The process changes by year, level and team, so treat this as a map, not a promise.

The 30-second version. Experienced candidates in the reports mostly skip the online test and go straight to interviews, while students often enter through a hackathon-style online assessment (OA, a timed coding test). The most common round count in the reports is 4, with rounds of about 1 hour: a DSA (data structures and algorithms) round, a design round (low-level design, LLD, or high-level design, HLD), a hiring manager round and a director round. Drives run several rounds in a single day. Rounds are conducted on HackerRank or a shared document, and some interviewers expect runnable code. C++, Java or JavaScript questions follow the role's stack. Project deep dives run through many loops. The habit that matters most: know every project on your resume well enough to defend each design choice.

What this guide is, and what it is not

This guide is built from 63 candidate experiences of Adobe's software engineer interviews, mostly from 2025 and 2026, covering campus hiring, MTS-2, CS-1 and senior roles, mostly in India. MTS means Member of Technical Staff and CS means Computer Scientist; Adobe's ladder in the reports runs MTS-1, MTS-2, CS-1 and CS-2. Intern reports are left out of this guide.

It is:

  • A map of the process, stage by stage, as candidates described it
  • The question patterns that keep coming back, and the follow-ups to expect
  • A six-week plan and practice problems matched to those patterns

It is not:

  • A list of leaked questions or a promise of what you will be asked
  • An official description of Adobe's process
  • An offer rate. Outcomes in candidate posts are self-reported and are not a statistical sample.

Important things to know before you start

These are the Adobe-specific facts that change how you prepare.

Coding surface. Reports that named a surface most often named HackerRank (6 reports), with a few using a shared document or Notepad. Five reports expected runnable or compilable code, one of them against 6 to 8 of the interviewer's own test cases, while three said pseudo code was enough for some questions. Practise writing complete, runnable code and your own tests, and also explaining an approach without running it.

Projects decide a lot. A project deep dive appears in 12 of the 21 reports that described the hiring manager and director rounds. Interviewers asked why you chose a design, what happens at scale and what you would change. One candidate with a C++ resume was rejected after round 1 for a Java and Spring Boot role and said the interview mostly checked whether the experience carried over.

The role's stack sets the questions. C++ roles asked about smart pointers, virtual destructors and threads. Java roles asked about concurrency and Spring. Frontend roles asked JavaScript and React. Check the job description and prepare that stack before general DSA.

Some outcomes are outside your control. One candidate got positive feedback in all rounds but was told the team had already identified an internal candidate. Another heard after 45 days that hiring had been put on hold, and a third heard in 2026 that a hiring freeze had paused the process after three positive rounds.

Round-by-round breakdown

Candidates described five stages: application, shortlisting, an online assessment for students, the interview loop, and a decision with offer.

Stage 1: Application, where candidates applied

Reports come mostly from India. Experienced candidates describe referrals, recruiter outreach and job boards; students describe campus drives and Adobe's hackathon.

ChannelWhat candidates said
Referral7 reports, including one candidate who used a referral app and one whose recruiter called after a referral from a teammate. In these reports a referral was followed by a recruiter call; nothing here shows a referral secures an interview.
Recruiter outreach and job boards7 reports describe a recruiter reaching out directly or through a job board such as Instahyre, and one candidate said it took about a month to hear back after applying to several MTS-2 roles.
Hiring drives4 reports describe drives where several rounds ran on one day, such as an MTS-2 drive in May 2025 and a CS-1 drive in Bangalore in August 2026.
Careers site2 reports applied on the careers site, and one heard from a recruiter within a week.
Campus and hackathonCampus candidates (2 reports) and 14 reports on the Adobe India Hackathon, which acts as a coding assessment for students.

What helped. Two candidates described getting the recruiter call after a referral from a friend or teammate.

Stage 2: Shortlisting, how candidates moved forward

For experienced candidates the step before the interviews was a recruiter call, and for students it was a timed test.

  1. Recruiter or HR call (experienced candidates). One HR call outlined 4 to 5 technical rounds including a manager and a director; another covered why the candidate wanted to leave, daily work, notice period and years of experience. A third recruiter said all rounds would run in a single day because it was a hiring drive.
  2. Hackathon assessment (students, 2025 and 2026). Round 1 was a timed test with MCQs and DSA questions. In 2026, one report described about 17 MCQs, 1 SQL join question and 1 DSA question; another described MCQs with a 1-minute timer each and 2 DSA questions. One 2025 report named Unstop as the platform. One 2026 report described round 2 as a 45-minute live proctored case study with 4 written answers.
  3. Campus online test (2024 report). One campus fresher described 2 coding questions plus MCQs on OS, DBMS and OOP.

What candidates advised. Practise LeetCode-style mediums, and expect the MCQs to be dense and timed.

Stage 3: Online assessment or phone screen

Students going through the hackathon or campus drives took an OA. Most experienced candidates described no OA or phone screen: the first technical round was the first test. One 2026 SDE 2 candidate did report an OA with 2 easy-to-medium DSA questions.

Online assessment

How it works. The reports describe timed coding with MCQs. The 2026 hackathon posts described MCQs plus 1 or 2 DSA questions, and one C++ question tested object-oriented modelling instead of an algorithm. No report in the data stated an AI-tool policy for the OA.

At a glance

  • Length: Not reported
  • Questions: 2 coding questions in the campus and SDE 2 reports; MCQs plus 1 or 2 DSA questions in the 2026 hackathon reports
  • What was asked: Graphs and greedy, trees, string transformations, simulation and game theory, plus one C++ class-design question
  • Most common: No single repeated question
QuestionWhat it testsLevel
Count tree nodes whose value plus child values equals kTree building and recursionHackathon (students)
Largest binary number from concatenating binary strings in the best orderCustom sort comparatorHackathon (students)
Fewest changed values to compress an array into a byte limitSorting, counting and a sliding rangeHackathon (students)
Total time for an orb on flipping-arrow tiles, from every starting tileSimulation with reuse across startsHackathon (students)
Two-player game on an array with optimal play, answered per queryGame theory with range queriesHackathon (students)
Drone energy model with inheritance and virtual functions in C++C++ object model and virtual dispatchHackathon (students)
Maximum revenue selling candies when a preferred candy sold first changes the priceGraph structure with a choice of orderHackathon (students)
Minimum travel time on a grid where only every P-th road is a fast roadShortest path with a closed-form insightHackathon (students)

See all Adobe OA questions in the question bank. Adobe OA questions shared on Codinzhub:

QuestionDriveTopic
Maximum Value on Tree PathsHackathon 2026Tree paths
Pair Sum (Easy Version)Hackathon 2026Hashing
Exactly K Distinct ContaminantsHackathon 2026Counting, sliding window
Closest NumbersACS Applied AI Engineer, off-campusSorting, two pointers
Frequency CalculatorACS Applied AI Engineer, off-campusHashing
Beautiful String (Regex)IIT RoorkeeStrings, regex
Maximum Score 22025 PYQ, IIT-preferredDP
Good Binary Strings2025 PYQ, IIT-preferredStrings, DP

Full Adobe interview experiences on Codinzhub: SDE intern, IIT Guwahati.

More Codinzhub questions: Browse Adobe questions.

Stage 4: The interview loop

The loop in the reports is a set of building blocks: DSA or coding, language-specific rounds, design, a hiring manager round and a director round. Of the 46 reports that gave a round count, 18 said 4 rounds, the most common value, and counts ran from 1 to 6, with many shorter counts being rejections after the first or second round. Some loops ran virtually on MS Teams or Zoom, others in person at Adobe's offices, and a few mixed both. Candidates who gave a round length mostly described about 1 hour, with 45 minutes and 70 minutes reported for some DSA rounds.

Coding and DSA rounds

At a glance

  • Length: About 1 hour in several reports; 45 minutes in two
  • Questions: 1 to 4 coding problems per round, with follow-ups on complexity and edge cases
  • What was asked: Intervals, caches, linked lists, trees, graphs, DP and sliding windows; three reports included puzzles
  • Most common: No single question. LRU cache with a pluggable policy and House Robber tied at 3 reports each

Two reports describe interviewers who asked for the approach first and discussed brute force without coding it, while two others wanted the most optimal solution immediately. One DSA round acted as an elimination round: the candidate's remaining rounds were not held. Round 1 sometimes also tested C++ or Java.

QuestionFollow-upLevel
House Robber, then House Robber IICircular arrangementCS-1
LRU cache in O(1), then a pluggable eviction policy such as LFUMake the eviction algorithm selectableMTS-2
Merge overlapping intervalsNot reportedMTS-2
Intersection of two linked lists, then group millions of lists by shared tailMillions of lists with millions of nodesMTS-2
Longest substring with at most k distinct charactersNot reportedCS-1
Best time to buy and sell stock, then its variationsUnlimited transactions; At most two transactionsCS-2
Number of trailing zeroes in n factorialNot reportedMTS-2
Evaluate an arithmetic expression with parenthesesNot reportedMTS (C++)

Language and frontend rounds

At a glance

  • Length: About 1 hour in the reports that gave a length
  • Questions: 3 to 5 questions in the reports that listed them, plus a short coding or debugging task
  • What was asked: C++ memory, virtual functions and smart pointers; Java concurrency and OOP; SQL and database basics; JavaScript, React and Android fundamentals
  • Most common: Smart pointers, in 5 reports

Some of these questions appeared inside round 1 or round 2 rather than as a separate round. In C++ roles, three reports described a round that was mostly or entirely about C++.

QuestionFollow-upLevel
Smart pointers: types, use cases, and a leak with a fixShow a leak that smart pointers can still have; Circular referencesMTS-2
Database questions: joins, isolation, replication, normalisation, SQL query tuningNot reportedMTS-2
Diamond problem, virtual functions and virtual destructorsNot reportedMTS (C++)
Thread-safe singletonThread safety in Kotlin and multiplatformMTS-2
Debounce versus throttleNot reportedMTS-2
Implement a simplified shared_ptr with reference countingNot reportedMTS-2
Thread-safe producer-consumer queueConsumers waiting before producers start; Auto-scaling and infinite capacityMTS-2
Debug a segmentation fault; find bugs in leaking and locking codeNot reportedMTS (C++)

Low-level design round

At a glance

  • Length: Not reported
  • Rounds: 1 or 2 at MTS-2 and CS-1
  • What was asked: Classes, interfaces, patterns, then APIs, schema and concurrency
  • Most common: Rate limiter, in 4 reports

Interviewers pushed every design decision with follow-ups, and some asked for production-ready code. One 2026 round was AI-assisted on HackerRank, where the interviewer judged how well the candidate used AI; the candidate approached it as a normal LLD round and said it went badly.

Reported designs.

  • Rate limiter, then scale to millions of users, then scale from a small system to millions of users
  • Autocomplete with top-K suggestions by search frequency, then millions of queries
  • Notification service for SMS, WhatsApp and push, then add WhatsApp three months later
  • In-memory file system with directories and shell-style commands, then make file content a generic type
  • Elevator system that is time and energy efficient, then choose the database first
  • Logger with asynchronous writes, file and console outputs
  • Interface to fetch the next upcoming birthday
  • File upload system from LLD to HLD, then concurrency, failure cases, DB design

System design (HLD) round

At a glance

  • Length: Not reported for a full round; one HLD discussion ran about 30 minutes
  • Rounds: 1 at most levels; a design question also appeared in manager and director rounds
  • What was asked: Requirements, schema, APIs, caching, scale and trade-offs
  • Most common: URL shortener, in 2 reports

Most of the HLD reports came from CS-1 and above (8 of 13). Reports also include two frontend designs and a retrieval-based Gen AI design.

Reported designs.

  • URL shortener with schema, caching and eviction
  • YouTube: upload, transcoding, adaptive bitrate streaming and CDN
  • Session lifecycle for a 3-minute 1-on-1 video platform at millions of matches
  • PDF search box that loops through matches
  • Document question answering with retrieval for enterprise users
  • Cache design in a resume-based round
  • Goodreads: entities, schemas and queries
  • BookMyShow schema and the ticket-finding flow

Hiring manager and director rounds

At a glance

  • Length: 40 minutes to 2 hours in the reports that gave one
  • Questions: Mixed project deep dives, behavioral prompts and a technical or design problem; one report listed 12 to 15 cultural-fit questions
  • Themes: Projects, motivation, conflict, ownership, AI and architecture
  • Most common: A project walk-through, in 12 reports

These rounds are scored. Five reports describe a rejection at the manager or director round, which was the last or second-last round, including one after a question about the hardest problem solved; in two of them the candidate said the earlier rounds went well. In two reports the director skipped introductions and went straight to depth, and in two a director added a coding problem.

Reported questions.

  • Walk through a project: design decisions, trade-offs, failures and scale, then what happens at scale
  • Why do you want to join Adobe?
  • Tell me about a time you disagreed with upper management or a senior engineer
  • How do you use AI at work, and where would it fit in your project?, then how models work and how to make them efficient
  • Why are you looking to switch jobs?
  • Most challenging or toughest technical problem you have solved
  • Production issues and on-call incidents
  • Tight timeline and a stakeholder who wants dev time halved

See all behavioral questions in the question bank.

Stage 5: Hiring committee, team match and offer

Decision. After the last round, candidates described waiting from days to weeks: a recruiter call about a week later in one report, a rejection email the next day in another, and no response for 20 days in one report and 11 days in another. One candidate heard after 45 days that hiring for the position was on hold, and another was told, after positive feedback on three rounds, that a hiring freeze had paused the process.

Level and team. One candidate who applied for CS-1 with under 4 years of experience received an MTS-2 offer; another who applied for MTS-2 was moved up to CS-1. One candidate with positive feedback was told the team had picked an internal candidate and that the recruiter would try to find another team, and one reported a 21-day wait before a new team required another round.

Offer. Reports mention an offer call from the recruiter. Compensation is left out here.

Adobe experiences shared on Codinzhub

These are full-time experiences candidates posted on Codinzhub. Public links to the original posts are Not stated.

CollegeRole and resultWhat was asked
IIT IndoreSDE, on-campus, selectedR1: arrays, strings, hashing, linked lists, trees and binary search with complexity and edge-case follow-ups, plus basic OOP, DBMS and OS. R2: project architecture and scaling, DBMS, SQL, OOP, OS and networks, debugging and optimising practical scenarios, then teamwork questions.
Not statedComputer Scientist 1, offered CS-1R1: current-work behavioral questions, Two Sum, mirror image of a binary tree. R2: HashMap internals with rehashing and load factor. R3: middle stack in O(1), producer-consumer. R4: what happens when a program crashes, an event-driven to API-based conversion, trains passing a station, why Adobe.
Not statedComputer Scientist 2, stepped back after 4 roundsR1: an island-style graph problem and a stock pattern. R2: a React shopping cart. R3: logging and dashboard design plus behavioral scenarios. R4: career journey and design principles.
Not statedComputer Scientist 1, rejected after 2 roundsR1: C++ theory, House Robber, string-to-integer conversion. R2: count of smaller numbers after self, then a second problem where the interviewer wanted a stack.

The Codinzhub Next-Round Playbook

The reports point to two habits: preparing the role's stack and defending your own projects.

To get past the OA

  • Practise timed mediums, since 2026 hackathon posts reported 1-minute MCQ timers and unusual simulation or game problems.
  • Read the constraints first. In one 2025 OA, coordinates up to 10^9 broke a plain shortest-path approach.
  • Sort with a custom comparator when the statement asks for the best order of strings.

To get past the DSA rounds

  • Say the brute force, then the optimal approach, then code it. Interviewers in two reports expected the optimal solution directly.
  • Write complete code and a few edge-case tests. Some interviewers ran code against 6 to 8 of their own test cases.
  • Ask what the question expects when it is vague. In two reports the interviewers were unclear about the requirements and the candidates lost time.

To get past the language and design rounds

  • Prepare the role's stack: smart pointers and virtual destructors for C++, locks and concurrent collections for Java, closures and React for frontend.
  • In LLD, name the entities, the patterns and the extension point before coding. One candidate was asked how to add WhatsApp to a notification service three months later.
  • In AI-assisted rounds, use the AI early and check its output. One 2026 candidate was judged on how effectively they used it.

To get past the hiring manager and director rounds

  • Prepare to be questioned on every bullet. One 2026 round used most of 1.5 hours on resume bullets.
  • Pick your hardest problem, not your latest project. One senior candidate was rejected for choosing the recent project.
  • Expect "why this choice" and "what if it fails" follow-ups on RabbitMQ, caches and databases you listed.

To get through the decision

  • Ask the recruiter when you will hear back; one candidate waited 20 days without a reply.
  • If told to reapply, ask whether the cooldown applies to a different team; reports differ.

How the loop differs by level

The building blocks stay similar, but the rounds, the stack depth and the design expectations change with level.

LevelWhat candidates describe
Campus and new gradBased on 2 campus reports plus 14 hackathon OA posts. A campus OA or the hackathon, then 2 to 3 interviews of DSA, projects and CS basics; one fresher had a simple design question and a hash-map internals question. No system design round is reported.
MTS-220 reports. 4 rounds was the most common count (10 of 20): DSA, LLD or a language round, a hiring manager round and a director round; two frontend loops ran 5. Design is mostly LLD, with one URL shortener and two frontend designs. One candidate with just under 3 years of experience cleared a CS-1 loop and was offered MTS-2.
CS-112 reports. 4 to 5 rounds, with several reports describing two design rounds (LLD and HLD) and project-heavy manager rounds; the 2026 AI-assisted LLD round appeared here. One report says CS-1 requires a minimum of 4 years.
CS-2, SDE-4 and senior3 reports (CS-2, SDE-4 and a senior backend role). 4 to 5 rounds, with HLD, LLD, a hiring manager round and a director round. The senior backend loop also had Gen AI and data modelling rounds.

Most-asked topics

Across 55 reports that described technical rounds, questions concentrated in a few clusters. Class design and low-level design ranked second, ahead of trees and graphs.

TopicWhat it meansSeen inReported examples
Arrays, strings, hashing, intervals and sliding windowsWorking with lists and text: lookups, ranges, merging and windows.41 of 55 reportsMerge overlapping intervals; Minimum window substring; Count pairs with absolute difference k
Class design and low-level designModelling classes, patterns and the C++ or Java object model.29 of 55 reportsRate limiter; Notification service; Smart pointers
Trees, graphs and triesHierarchies, networks and prefix trees.25 of 55 reportsDepartments that minimise the reporting chain; Word ladder; Autocomplete with top-K
Linked lists, stacks, heaps and cachesPointer structures and structures that keep a best or latest item.18 of 55 reportsLRU cache; Median of a stream; Reverse nodes in k-group
Dynamic programming and backtrackingBuilding answers from smaller answers, or trying and undoing choices.16 of 55 reportsHouse Robber; Palindrome partitioning; N-Queens
System designDesigning services, schemas and scale (HLD).13 of 55 reportsURL shortener; YouTube; Document question answering
ConcurrencyThreads, locks and queues shared between them.12 of 55 reportsThread-safe producer-consumer queue; Thread-safe singleton; Mutex output ordering

The question patterns that keep coming back

Most questions fell into a handful of patterns. Learn to recognise the pattern under the story.

1. Arrays, strings, hashing, intervals and sliding windows

This was the largest cluster, appearing in 41 of 55 technical reports. If a question asks for ranges, sort first and sweep; for the longest or shortest substring, use a sliding window with counts; for repeated lookups, use a hash map. The most repeated question touching this cluster was the LRU cache with a pluggable eviction policy (3 reports).

Reported examples. Merge overlapping intervals; Insert a new interval; Minimum window substring; Longest substring with at most k distinct characters; Count pairs with absolute difference k; Occurrences of x with hand-written lower and upper bound.

2. Class design and low-level design

Class design is the style that stands out at Adobe in these reports: 29 of 55 reports, spanning LLD rounds, C++ and Java object models and framework questions. If the question asks for an extensible service, name the entities, put the varying behaviour behind an interface (strategy), and say how a new variant is added.

Reported examples. Rate limiter, then scale to millions; Notification service for SMS, WhatsApp and push; In-memory file system; Autocomplete with top-K suggestions; Smart pointers and a simplified shared_ptr; Elevator system.

3. Trees, graphs and tries

25 of 55 reports. If the question asks for the fewest steps, use BFS; for reachability or paths, use DFS; for merging groups, use union-find; for prefix lookups, use a trie. Hierarchy stories (departments, employees, organisations) were common disguises.

Reported examples. Departments that minimise the longest reporting chain; Minimum time for a message to reach every employee; Word ladder; Most stones removed with the same row or column; Count unreachable pairs of nodes; Lowest common ancestor in an N-ary tree.

4. Linked lists, stacks, heaps and caches

18 of 55 reports. If the question asks for the best item so far, use a heap; for the latest or most recent item, use a stack or queue; for constant-time lookup plus ordering, combine a hash map and a linked list.

Reported examples. LRU cache then LFU cache; Median of a stream of integers; Reverse nodes in k-group; Intersection of two linked lists, then group lists by shared tail; Asteroid collision; Minimise array sum after K halving operations.

5. Dynamic programming and backtracking

16 of 55 reports. It appeared less often than the other patterns and was often a follow-up or verbal question. If the answer is built from smaller answers, define the state first and the recurrence second; if you must try and undo choices, backtrack.

Reported examples. House Robber, then House Robber II; Best time to buy and sell stock and its variations; Coin change; Minimum cuts for palindrome partitioning; Count subsets that sum to k; N-Queens.

6. System design

13 of 55 reports, most from CS-1 and above. If the question asks for scale, clarify requirements first, then entities and schema, then caching and bottlenecks.

Reported examples. URL shortener; YouTube; BookMyShow schema; Monthly statements for millions of users; Meeting scheduler; Document question answering.

7. Concurrency

12 of 55 reports, concentrated in C++ and Java roles. If the question shares a structure between threads, decide what is guarded by what, and what happens at shutdown.

Reported examples. Thread-safe producer-consumer queue; Thread-safe singleton; Mutex to print in a fixed order; Thread-safe message queue; Java class lock versus object lock.

Preparing for the hiring manager and director rounds

These rounds are scored like the coding rounds (see Stage 4), and the interviewer digs into one theme at a time.

Build your story bank. Prepare real stories, each under two minutes, each ending in a result. Cover the themes candidates were asked about:

ThemeReported prompt (paraphrased)Follow-up to expect
MotivationWhy Adobe, and why leave your current jobNot reported
ConflictA disagreement with upper management or a senior engineerWho made the decision
OwnershipThe hardest technical problem you have solvedThe interviewer wanted the hardest, not the latest
ArchitectureWhy a microservice and not the monolithWho took the decision
PressureA tight timeline with a stakeholder asking to halve development timeNot reported
IncidentsA production issue or on-call incident you handledNot reported
AIHow you use AI at work and where it fits your projectHow models work and how to make them efficient

Structure each story. State the situation in one line, what you did (say "I"), the result with a number, and what you would change.

Expect depth. In the reports, directors followed up repeatedly: for one candidate, each answer on RabbitMQ led to "what if this also fails". Use only real experiences.

A six-week plan

The plan follows the patterns above, most common first, and ends with timed mocks that feel like the real round. Plan on two to three focused hours a day.

  1. Week 1: Arrays, strings, hashing, intervals and sliding windows. Merge intervals, sliding window with counts, hash-map lookups. Habit: write the complexity and two edge cases for every solution.
  2. Week 2: Class design and low-level design. Rate limiter, notification service, file system, autocomplete; for C++ roles add smart pointers, virtual destructors and the Rule of Five. Habit: name the extension point before coding.
  3. Week 3: Trees, graphs and tries. BFS for fewest steps, DFS for paths, union-find for groups, trie for prefixes. Habit: draw the structure before writing code.
  4. Week 4: Linked lists, stacks, heaps and caches. LRU and LFU, two heaps, pointer reversal. Habit: dry-run on a small example.
  5. Week 5: Dynamic programming, system design and concurrency. House Robber and interval DP, a URL shortener and a video-platform design, a producer-consumer queue. Habit: state requirements first.
  6. Week 6: Mocks. Four timed 60-minute mocks on HackerRank-style editors with runnable code and your own tests, each with at least two follow-ups. Rehearse project and behavioral stories out loud.

Campus candidates can spend less on system design and concurrency; CS-1 and above should add system design from week 2.

Only two weeks? Spend 4 days on arrays, strings, hashing and intervals, 3 days on class design and LLD, 3 days on trees and graphs, 2 days on linked lists, heaps and caches, and 2 days on timed mocks and project stories. That is 14 days.

Practice problems that match these experiences

These are well-known practice problems that match the patterns above. They are not claims about Adobe's question bank unless a row says the problem was asked as-is.

#Practice problemPatternSeen in these experiences as
1Minimum Height TreesTrees and graphs: tree centres by leaf peelingDepartments that minimise the reporting chain. Asked as-is in one report
2Time Needed to Inform All EmployeesTree DFS over a hierarchyMinimum time for a message to reach every employee (parallel version)
3Word LadderBFS on an implicit graphWord ladder, asked as-is in one report
4Merge IntervalsSorting and interval sweepAsked as-is in two reports
5Minimum Window SubstringSliding window with countsAsked as-is in one report
6Top K Frequent ElementsHeap or bucket countingK most frequently viewed product IDs. Asked as-is in one report
7LRU CacheHash map plus linked listLRU cache with a pluggable eviction policy. Asked as-is in three reports
8Find Median from Data StreamTwo heapsMedian of a stream, asked as-is in one report
9Reverse Nodes in k-GroupLinked-list pointer workAsked as-is in one report
10House RobberAdjacent-exclusion DPAsked as-is in three reports
11Palindrome Partitioning IIInterval DPAsked as-is in one report
12Implement Trie (Prefix Tree)Trie with prefix searchAutocomplete with top-K suggestions (similar technique, not asked as-is)

System design and concurrency questions have no single practice problem; use the reported designs above as prompts.

How to handle a question you have never seen

Most rounds are one or two problems plus follow-ups, so a repeatable method matters more than memorised solutions.

  1. Repeat the problem and one example. If the statement is vague, ask what the method must return before you start.
  2. Say the brute force and its complexity. It sets a baseline and gets the interviewer talking; one report said the interviewer only wanted the most optimal solution, so move on quickly.
  3. Name the bottleneck. Repeated lookups suggest a hash map; ranges suggest sorting or prefix sums; repeatedly finding the best item suggests a heap; trees and hierarchies suggest DFS or BFS.
  4. Say when you are stuck. Two reports describe hints that got a candidate to a working solution (a multithreaded singleton and an LFU follow-up), and one candidate who said honestly they were not prepared was given a 15 to 20 minute walkthrough.
  5. Code in small pieces while talking. On HackerRank, write helper functions first and run the sample case before the hidden ones.
  6. Dry-run one case and fix the wrong line. Trace your example, then try an empty input or a single element. Leave five minutes for it.

Why candidates were rejected

Across 18 rejected reports, the reasons were rarely a missing algorithm; most are the candidate's own reading of what happened.

  • Design rounds that went badly. Five reports describe LLD or HLD rounds that did not go well: a warehouse design, a file-system design with one function finished, a first-ever LLD round, a video-platform design that froze one candidate, and an AI-assisted round. These are self-reflection, not recruiter feedback.
  • Hiring manager and director rounds. Five candidates were rejected at the manager or director round, and two of them said the earlier rounds went well; one chose a recent project when the manager wanted the hardest problem.
  • Optimal solution expectations. Recruiter feedback to one candidate said they wanted candidates with better optimisation, and another report described an elimination round that expected the optimal, runnable code.
  • Stack mismatch. Two candidates felt their C++ or Java depth did not match the role.
  • Hiring decisions outside the interview. Two candidates with positive feedback met a freeze or an internal candidate, and a third heard that hiring was on hold.

Selected vs. rejected: do this, not that

No successful candidate described a perfect interview; the rejected reports show what a few missing habits cost.

Do thisNot thatWhat the reports show
Defend your project: know why each choice was madeRecite the latest projectOne senior candidate was rejected after choosing the recent project when the manager asked for the hardest problem.
Reach the optimal, runnable solutionStop at brute force or partial codeOne candidate had only one function finished in an LLD round; another faced an elimination DSA round that expected optimal code.
State assumptions when the question is vagueGuess silentlyIn 2 reports, interviewers were vague on the requirements and candidates lost time.
Prepare the role's stackPrepare generic DSA onlyTwo candidates felt a C++ or Java mismatch hurt them.
Use AI deliberately in AI-assisted roundsTreat them as normal roundsOne 2026 candidate said the round judged how effectively they used AI.

If you remember only five things

  1. The process in one line. Experienced candidates usually go straight to about 4 rounds of DSA, design, hiring manager and director; students may start with a hackathon OA.
  2. The round format. Rounds are about an hour, on HackerRank or a shared document, and some interviewers expect runnable code.
  3. The core habit. Know your projects well enough to defend every design choice.
  4. The core topics. Arrays and strings, class design, and trees and graphs are the core.
  5. The practice surface. Practise runnable code with your own tests and be ready for C++ or Java depth if the role asks for it.

FAQ

Is there an online assessment?

No. Not in most experienced reports, which went from a recruiter call to interviews; one 2026 SDE 2 candidate did report an OA, and students and campus candidates took one through the hackathon or campus drives.

Is system design asked?

Yes, mostly at CS-1 and above in the reports. MTS-2 reports were mostly LLD with one URL shortener and two frontend designs, and campus reports had no HLD.

How long does it take?

From about 1 week to about 2 months in the reports. The slowest step was waiting after the last round: one candidate heard nothing for 20 days.

Will the interviewer help?

It varied. Some candidates described helpful interviewers and hints, and others described interviewers who joined late, were not prepared or kept changing the constraints.

Is there a cooldown after rejection?

Reports differ. A 2026 candidate was told 6 months for the same position; another said there was no cooldown and applied to a new role; a recruiter told a third to apply to other teams.

Are puzzles asked?

Yes, in three reports, such as a poisoned-bottle puzzle and an eight-ball weighing puzzle in one C++ loop.

Other company and role guides


About this guide

The Codinzhub team researched and wrote this guide from 63 Adobe software engineer interview experiences, mostly from 2025 and 2026, including experiences shared on Codinzhub. We kept only what candidates described. The questions are our own short summaries, and the practice links are similar problems, not the exact interview questions. If you interviewed recently, share your experience on Codinzhub and we will update this guide.

Disclaimer. Adobe's process changes by role, year and office. Use this guide to build a foundation, and confirm the current format with your recruiter.

Search the question bank

The questions from each round above, with practice links for similar problems. Log in to search every question we collected for this role, including questions shared on Codinzhub.

Showing 20 of 106 questions

  • Maximum Value on Tree Paths

    A Adobe online assessment question shared on Codinzhub (Hackathon 2026).

    On CodinzhubHackathon 2026Tree pathsCodingOnline assessment
  • Pair Sum (Easy Version)

    A Adobe online assessment question shared on Codinzhub (Hackathon 2026).

    On CodinzhubHackathon 2026HashingCodingOnline assessment
  • Exactly K Distinct Contaminants

    A Adobe online assessment question shared on Codinzhub (Hackathon 2026).

    On CodinzhubHackathon 2026Counting, sliding windowCodingOnline assessment
  • Closest Numbers

    A Adobe online assessment question shared on Codinzhub (ACS Applied AI Engineer, off-campus).

    On CodinzhubACS Applied AI Engineer, off-campusSorting, two pointersCodingOnline assessment
  • Frequency Calculator

    A Adobe online assessment question shared on Codinzhub (ACS Applied AI Engineer, off-campus).

    On CodinzhubACS Applied AI Engineer, off-campusHashingCodingOnline assessment
  • Beautiful String (Regex)

    A Adobe online assessment question shared on Codinzhub (IIT Roorkee).

    On CodinzhubIIT RoorkeeStrings, regexCodingOnline assessment
  • Maximum Score 2

    A Adobe online assessment question shared on Codinzhub (2025 PYQ, IIT-preferred).

    On Codinzhub2025 PYQ, IIT-preferredDPCodingOnline assessment
  • Good Binary Strings

    A Adobe online assessment question shared on Codinzhub (2025 PYQ, IIT-preferred).

    On Codinzhub2025 PYQ, IIT-preferredStrings, DPCodingOnline assessment
  • Count tree nodes whose value plus child values equals k

    Level: Hackathon (students).

    Tree building and recursionCodingOnline assessment
  • Largest binary number from concatenating binary strings in the best order

    Level: Hackathon (students).

    Custom sort comparatorCodingOnline assessment
  • Fewest changed values to compress an array into a byte limit

    Level: Hackathon (students).

    Sorting, counting and a sliding rangeCodingOnline assessment
  • Total time for an orb on flipping-arrow tiles, from every starting tile

    Level: Hackathon (students).

    Simulation with reuse across startsCodingOnline assessment
  • Two-player game on an array with optimal play, answered per query

    Level: Hackathon (students).

    Game theory with range queriesCodingOnline assessment
  • Drone energy model with inheritance and virtual functions in C++

    Level: Hackathon (students).

    C++ object model and virtual dispatchCodingOnline assessment
  • Maximum revenue selling candies when a preferred candy sold first changes the price

    Level: Hackathon (students).

    Graph structure with a choice of orderCodingOnline assessment
  • Minimum travel time on a grid where only every P-th road is a fast road

    Level: Hackathon (students).

    Shortest path with a closed-form insightCodingOnline assessment
  • House Robber, then House Robber II

    Level: CS-1.

    Circular arrangementCodingRound not stated
  • LRU cache in O(1), then a pluggable eviction policy such as LFU

    Level: MTS-2.

    Make the eviction algorithm selectableCodingRound not stated
  • Merge overlapping intervals

    Level: MTS-2.

    Not reportedCodingRound not stated
  • Intersection of two linked lists, then group millions of lists by shared tail

    Level: MTS-2.

    Millions of lists with millions of nodesCodingRound not stated
Page 1 of 6

Keep preparing on Codinzhub

Ready for the next topic?

Keep track of what you’ve learned.