Adobe Software Engineer
Interview Guide

• Solve the reported array problems timed, from a blank editor: rotate an array in place with three reversals (O(n) time, O(1) space), trapping rainwater with two pointers, and the longest subarray whose sum is divisible by k using first-seen prefix remainders.
• For divisible-by-k, write the edge cases before coding: negative numbers (normalise each remainder into 0..k-1), a prefix remainder of 0 (seed the map with remainder 0 at index -1), and an answer spanning the whole array.
• Before each submission, run a harness with the given examples plus empty and single-element inputs.
• Do one timed run that starts with a block of OS, DBMS and networking multiple-choice questions, then the coding problems, and note where the time went.

Deliverable: Three reported array problems solved from memory with a test harness, plus a note on how much time the multiple-choice block cost you.

• Word Ladder: BFS from the start word, generating neighbours by substituting each position with each letter and checking a set of dictionary words. When a word is first enqueued, mark it visited and record its parent in a map. State the cost as roughly N x L x 26 candidates, each O(L) to build and hash.
• Once the end word is reached, walk the parent map back to the start word and reverse it to return the shortest transformation sequence, or an empty result if the end word is unreachable. Returning only the sequence length (the BFS level count) is the common variant.
• Binary tree maximum path sum: a post-order pass that returns the best downward gain, max(0, child gain), and updates a global best with node + left + right. Test an all-negative tree.
• Work the tree and graph topics in PracHub's question bank: BST validation with bounds, level-order traversal, lowest common ancestor when both nodes may be missing, and task ordering with prerequisites via topological sort that reports a cycle.

Deliverable: Word Ladder returning the shortest sequence via a parent map, maximum path sum with stated complexity, and one topological sort that detects a cycle.

• OS: explain virtual memory, paging, TLB hits and misses, and LRU versus MRU page replacement, then walk through a page fault step by step aloud.
• Threads: list the four deadlock conditions and how lock ordering breaks one; implement a bounded producer-consumer queue with a mutex and two condition variables, waiting in a loop.
• Databases: B-tree versus hash indexes and which queries each serves; then work the guide's worked SQL exercise on keyset pagination and the SQL topics in PracHub's question bank (average grade per subject with NULL-safe aggregation, filtering students by grade).
• Networking: TCP versus UDP, and how HTTP/2 multiplexes streams over one connection.

Deliverable: One page of fundamentals notes you can explain without references, and a working bounded queue.

• Implement the reported shared pointer: a control block with an atomic count, increment on copy, fetch_sub with acquire-release ordering on release and delete when the previous count was 1, plus copy and move assignment handling self-assignment.
• Explain delete versus delete[]: a hand-written shared pointer with no array specialisation, or a std::shared_ptr<T> built from new T[n], must be given a custom deleter that calls delete[]; since C++17, std::shared_ptr<T[]> calls delete[] by default.
• Build the reported client-side cache with key expiration and a size limit: a hash map plus a doubly linked list for LRU order, expiry checked on read with a periodic sweep, and a stated rule for which entry goes first when both limits apply.
• Sketch a fixed-size pool allocator: a free list threaded through unused blocks so allocate and release are O(1) and system calls happen only when the pool grows.

Deliverable: A compiling shared pointer and a TTL-plus-LRU cache, each with tests for self-assignment, expiry and eviction order.

• Serverless thumbnail service: upload to object storage, one event per upload, function workers producing each size, output keyed by asset id and size so a retried job overwrites rather than duplicates. Use the guide's worked design exercise on idempotent retries for the same reasoning.
• Real-time collaborative canvas: requirements first, then the trade-off between operational transformation and CRDTs, presence, persistence, and two users editing the same object.
• Q&A assistant on an enterprise platform (a design topic in PracHub's question bank): retrieval over customer content, per-tenant scoping, and where latency goes.
• Open every design with functional and non-functional requirements, APIs and the data model before scale, caching or fault tolerance.

Deliverable: Two designs taken to API and data-model depth, each with a named failure mode and its recovery path.

• For two resume projects, write the constraint, the rejected alternative, the measurement before and after, and what broke; rehearse each until you can take an unplanned follow-up.
• Do a live coding session over screen share with autocomplete off and no search, narrating as you go; the guide's worked coding exercise on parsing a signed webhook header is a good single-pass parsing drill.
• If your target team is web-facing, add the reported frontend set: a React counter hook with pause, resume and reset that clears its interval on pause and unmount, event loop ordering of microtasks and macrotasks, and a request handler with client-side throttling and retry with backoff.

Deliverable: Two project write-ups that survive follow-ups, and one recorded live-coding session you have reviewed.

• Write STAR stories for the reported prompts: a complex project you led and its trade-offs, conflicting priorities from leadership or other teams, critical feedback or a production failure, and your strengths and weaknesses.
• Map one specific story to each value named in the reported values prompt (Creating the Future, Owning the Outcome, Raising the Bar, Be Genuine).
• Run a mock with one coding problem, one design prompt and one behavioral question, and ask the interviewer to change a requirement partway through the design.

Deliverable: A story bank covering every reported behavioral prompt, and mock notes recording what changed under the new requirement.