Interesting Duolingo Interview Experiences

A practical roundup of three firsthand Duolingo software-engineering interview reports. The reports cover a 2026 full-time phone screen, a 2025 new-grad process, and a 2022 intern Karat interview.

Online assessment and Karat

The 2025 new-grad report started with a standard general-coding CodeSignal assessment. The candidate did not preserve the exact OA questions. They described the environment as relaxed, but that is only one candidate's report and not a rule for future assessments.

The same candidate then completed a Karat interview with three short oral questions and one coding problem. The coding problem was a Mahjong-style partition problem.

The 2022 intern report also described a Karat interview. It lasted about one hour:

1. About one minute of introduction.
2. About ten minutes for three short oral questions.
3. The remaining time for coding, optimization, and time/space analysis.

Phone screen

The 2026 full-time report had two technical phone rounds. The first was an encrypt/decrypt problem. The second was a debugging round in which the interviewer shared and controlled the screen.

Virtual onsite

The 2025 new-grad virtual onsite lasted about four to five hours. The report described three technical formats:

• Pair programming in VS Code Live Share.
• Code review without writing new code.
• A whiteboard algorithm problem with two follow-ups.

The exact order of these rounds was not clearly preserved. Future loops may also change.

Reported question bank

1. Encrypt and decrypt strings, but return every match

Practice: Decrypt All Matching Strings

The full-time candidate said the question was close to LeetCode 2227, Encrypt and Decrypt Strings. The important change was the decrypt operation:

• The usual version returns the number of dictionary words that match an encrypted string.
• This interview version asked for all matching dictionary strings.

The source did not restate the full input format, class API, constraints, or duplicate-handling rules. Those details should not be guessed from the report alone. The preparation lesson is to understand the forward mapping, build a useful reverse lookup, and be ready to change a count result into a collection result.

2. Screen-shared debugging and a boolean-function bug

The second full-time round was not a normal blank-editor coding problem. The interviewer displayed existing code and controlled the screen. The candidate had to inspect the code and identify bugs while communicating what they saw.

The report preserves these facts:

• The interviewer controlled the shared screen.
• The candidate spent a lot of time explaining and communicating.
• The interviewer gave hints.
• The last issue involved a function that returned true or false and was implemented or called incorrectly.
• The candidate completed the round but was later rejected.

Important evidence limit: the original program, function names, signatures, expected boolean meaning, failing input, and final corrected code were not included. This is why there is no honest full coding prompt to reproduce. Any exact code here would be invented.

The candidate's own advice was practical: focus on the part the interviewer asks about. Communication is useful, but do not turn every observation into a long side discussion.

3. Valid Mahjong hand partition

Practice: Valid Mahjong Hand Partition

The new-grad Karat coding question used digits from 1 through 9 as Mahjong-like tiles. Determine whether the entire hand can be divided into:

• Exactly one pair of equal digits.
• Zero or more triples of equal digits.
• Zero or more triples of consecutive digits.

Every tile must be used exactly once. A reported example was:

[removed] → 11 + 123 + 456

The candidate used backtracking. A clean approach is to choose the smallest remaining digit and try every legal group that contains it. Track whether the one allowed pair has already been used. Backtrack when a group choice cannot lead to a complete partition.

The report said the interview showed 15 tests and no separate hidden tests. Treat that as a detail of this one interview, not a promise about the platform.

4. Rank Spanish translation hints

Practice: Rank Translation Hints

This was the new-grad pair-programming problem in VS Code Live Share.

The candidate received:

• An English sentence.
• Several Spanish translation hints for each word.

The task developed in two steps:

1. Sort the hints in lexicographic order.
2. Use the best translation of the whole sentence, together with alternative translations, to assign priorities and sort the hints.

The report explicitly warned that punctuation mattered. This suggests careful parsing and normalization were part of the work.

Important evidence limit: the report did not preserve the exact data schema, priority formula, tie-breaking rule, or punctuation contract. The linked FastPrep problem is a practice reconstruction, not a claim that those missing details appeared word for word in the interview.

5. Review two course-filter functions

The new-grad code-review round did not require the candidate to write a new solution. They reviewed two existing functions that filtered the courses a user had taken during a time range.

The candidate was asked to:

• Add review comments.
• Find bugs.
• Suggest high-level refactoring ideas.
• Explain why the changes would make the code safer or clearer.

Useful areas to check in a task like this include boundary dates, duplicated logic, naming, null or missing values, data ownership, unnecessary work, and whether two functions should share one helper. These are preparation ideas, not claims about the hidden code.

Important evidence limit: the source did not include either function, the course data model, the time-range semantics, the signatures, or any failing case. The exact task cannot be reconstructed without fabricating code.

6. Longest decreasing path with two follow-ups

Practice: Longest Decreasing Path with Relaxations

The base whiteboard problem was a variation of Longest Increasing Path in a Matrix, but the candidate needed the longest decreasing path.

The candidate used DFS with memoization.

Then the interviewer added two follow-ups:

1. Return the actual path, not only its length.
2. Allow up to k moves that ignore the decreasing-height rule.

For the first follow-up, memoized states can also store the next cell or the best path choice. For the second, the memoization state needs another dimension for the number of rule-breaking moves still available.

The report did not preserve the exact movement directions, tie-breaking rule between equal-length paths, or output format. The stable signal is the progression: solve the length problem, reconstruct a path, and then expand the state.

7. Find any valid directional-tile path

Practice: Directional Tile Reconfiguration Path

This is the coding problem the 2022 intern-report author explicitly said they personally received.

A one-dimensional board contains:

• R for a red tile.
• B for a black tile.
• _ for an empty position.

Movement rules:

• A red tile moves only to the right.
• A black tile moves only to the left.
• A tile may move one step into an adjacent empty position.
• A tile may jump over exactly one tile of the opposite color and land in an empty position.

Given a start board and an end board, return any valid sequence of board states from start to end. The sequence does not need to be shortest, but it must include both the start and end states. Return None when no valid sequence exists.

Reported example 1:

• [R, _, B, B]
• [_, R, B, B]
• [B, R, _, B]
• [B, R, B, _]
• [B, _, B, R]

Reported example 2:

• [R, R, _]
• [R, _, R]
• [_, R, R]

This can be modeled as graph search. Each board is a state, and every legal move creates a neighboring state. Store parent pointers so the final sequence can be reconstructed.

8. Three oral code-analysis questions

The intern-report author explicitly identified the last three oral questions as the ones they personally received:

1. In-place array reversal: A program swaps every item with its mirror item. Is the program correct? The key is to notice whether it keeps swapping after the middle and therefore reverses the array twice.
2. Top-N mutual-like probabilities: There are P people, one target person, and an O(1) function that returns the mutual-like probability for any pair. Return the top N people for the target in descending probability. Explain the data structure, algorithm, time complexity, and space complexity. A size-N min-heap is a natural option.
3. Binary-tree preorder traversal: Analyze the time and space complexity of a simple preorder traversal. State both total work and recursion-stack space, including the difference between a balanced and highly skewed tree.

The same source post also compiled other coding and oral questions from forum posts and friends. Those items are not presented here as this candidate's own interview experience. That distinction matters: a useful community list is not the same as firsthand evidence.

Candidate report 1: Full-time SWE phone screen

Report date: April 29, 2026 · Role: Software Engineer · Level: Full-time · Stage: Phone screen · Result: Rejected · Location: Not reported

The candidate completed two technical phone rounds.

In round one, they solved the encrypt/decrypt variation that returned all matching strings. In round two, they inspected code controlled on the interviewer's screen and looked for bugs. The candidate said they finished both rounds but needed interviewer hints.

Their strongest reflection was about focus. Because the interviewer controlled the screen, the candidate spent a lot of time communicating. In hindsight, they recommended staying close to the exact area the interviewer asks about. The final bug was connected to an incorrectly implemented or incorrectly called boolean-returning function, but the actual code was not shared.

Candidate report 2: New Grad full process

Report date: November 5, 2025 · Role: Software Engineer, New Grad · Level: New Grad · Stages: CodeSignal OA, Karat, virtual onsite · Result: Rejected · Location: Not reported

The process started with a general CodeSignal coding assessment. The report did not preserve its exact questions.

The Karat round had three short oral questions and one coding question. The coding question was the Mahjong partition problem. The candidate used backtracking and reported 15 visible tests.

The virtual onsite lasted about four to five hours. It included:

• Pair programming on the translation-hint ranking task.
• Code review of two course-filter functions.
• A whiteboard longest-decreasing-path problem with path-reconstruction and k-relaxation follow-ups.

This report is the clearest example of why Duolingo preparation should include more than writing a fresh algorithm from scratch. The candidate had to move between implementation, collaborative editing, code criticism, and whiteboard reasoning.

Candidate report 3: SWE Intern Karat

Report date: October 3, 2022 · Role: Software Engineer Intern · Level: Internship · Stage: Karat / phone screen · Result: Not disclosed · Location: Not reported

The round lasted about one hour. It started with a very short introduction, followed by three oral questions, then a longer coding problem with optimization and complexity discussion.

The candidate personally received the directional-tile path problem. They also personally received the oral questions about mirror-swap array reversal, top-N mutual-like probabilities, and preorder-traversal complexity.

The candidate described the interview experience positively. The report did not disclose an offer or rejection result.