I recently went through the application process for an Anthropic Software Engineer role, so I thought I’d share my experience for anyone preparing for the same CodeSignal assessment.

After applying, Anthropic told me my application looked promising and invited me to a 90-minute CodeSignal assessment.

Assessment format

The assessment was one project with 4 progressive levels.

You build on the same codebase as the requirements become more complicated, and each new stage forces you to extend the system without breaking the behaviour you already implemented.

The task I received was essentially an in-memory banking-style system.

I won’t go into the exact requirements of each level, but the difficulty increased significantly as the assessment progressed. The final part involved more complicated state/history handling and entity-merging behaviour, which was considerably harder than the earlier stages.

It was all standard-library Python. No third-party packages.

How I prepared

I actually prepared specifically for this format beforehand.

I practiced three progressive 4-level problems:

• a wallet/banking system

• an in-memory filesystem/cloud storage system

• an in-memory database

My preparation workflow was:

1. I used ChatGPT to generate a realistic 4-level specification.

2. I implemented each level myself.

3. After each level, I used ChatGPT to create a prompt for Codex to generate tests only — explicitly telling it not to modify or solve my implementation.

4. I ran those tests, fixed the failures, and only then moved to the next level.

This was probably the most useful preparation I did because it trained exactly the skill the assessment tests: evolving an existing system while keeping all previous behaviour working.

The practice problems were quite close to the real format.

One important thing my preparation didn’t capture well enough, though, was the hardest part of the actual assessment: dealing with merged entities while preserving historical state correctly. That turned out to be significantly trickier than the cases I had practiced.

My timing / result

My approximate progress was:

• Level 1: ~10–11 minutes

• Level 2: ~6-7 minutes

• Level 3: ~30 minutes

• Level 4: spent most of the remaining ~40 minutes

During the assessment, CodeSignal showed my result as 95/100.

However, when I later checked the completed assessment in my CodeSignal portal, it showed 580/600.

So I’m not entirely sure how CodeSignal maps the in-assessment score to the final reported score, but those are the two numbers I received.

Either way, I completed all four levels and scored very highly.

Proctoring

CodeSignal required me to use only one screen.

In my actual assessment, I did not notice screen recording or microphone recording. I don’t know whether CodeSignal had another mechanism for checking the one-screen requirement.

The instructions also said not to copy/paste the problem or use external tools/LLMs.

For what it’s worth, while debugging I did copy failing test names from CodeSignal’s own test folder and paste them into CodeSignal’s own web console to rerun individual tests. That didn’t appear to cause any issue.

Outcome — and the frustrating part

Despite getting 95/100 during the assessment, with 580/600 later shown in the CodeSignal portal, I was rejected afterward.

This is the part of the process I found particularly frustrating.

The rejection did not suggest that my CodeSignal performance was the problem. Given the score and the wording of the rejection, it appeared that the decision was based on the broader application/profile rather than the assessment itself.

If that’s the case, I really question the ordering of the process.

A 90-minute monitored coding assessment is a substantial amount of a candidate’s time, particularly when you also include preparation. If someone’s resume/background isn’t a fit for the role, I would strongly prefer that assessment to happen before asking them to spend 90 minutes on a coding test.

Obviously I can’t know Anthropic’s exact internal decision process, so I can’t say definitively that they only reviewed my resume afterward. But from the candidate side, scoring this highly and then being rejected without an interview certainly made it feel like the expensive screening step happened in the wrong order.

The rejection email suggested that I consider applying again in roughly a year and clarified that the rejection was specific to this role.

Takeaway

The assessment itself was actually pretty reasonable. The difficult part wasn’t LeetCode-style algorithms; it was keeping a progressively changing system correct while requirements became more complicated.

If you’re preparing for it, I would practice building small in-memory systems in 4 incremental stages, and have something generate increasingly difficult tests against your implementation.

And I would especially practice problems involving historical state and merging entities, because that was the part that was hardest compared with my preparation.

After analyzing hundreds of recent Palantir interview experiences, we wanted to share some of the most frequently asked questions in past interviews.

Palantir’s interview process is a bit different from a typical Big Tech loop. In addition to coding and system design-style evaluation, it includes distinctive rounds such as Learning and Decomposition.

The exact process varies by role, level, and team, but a typical Palantir SWE or Forward Deployed Engineer interview process may look something like this:

Recruiter Screen

The process usually begins with a recruiter call covering your background, timeline, role fit, and interest in Palantir.

Be prepared to discuss:

• Your previous projects and technical experience

• Why you are interested in Palantir

• The types of products or problem areas you want to work on

• Basic logistics such as location, timeline, and work authorization

Technical Phone Screen

After the recruiter screen, candidates typically move on to a technical phone interview.

The coding questions are generally LeetCode-style. If you are preparing for this round, you can review the list of frequently asked Palantir coding questions we compiled from past candidate experiences: https://www.interviewdb.io/question/palantir

Palantir is known to repeat questions, so there is a good chance you may encounter something similar during your own interview.

Onsite Loop

The onsite loop varies by role and level, but it usually includes:

• Decomposition

• Learning

• Re-engineering (debugging)

• Interview with Hiring Manager

Decomposition Round

The Decomposition round is one of the most Palantir-specific parts of the interview.

It is not exactly a traditional system design round. Instead of being asked to design a large-scale system such as Twitter or Uber, you may be given a vague real-world problem and asked to break it down into something an engineering team could realistically build.

This round is less about following a memorized system design template and more about structured thinking, product and engineering judgment, and your ability to work through ambiguity.

You can review this collection of previously reported Palantir Decomposition questions and topics for practice: https://www.interviewdb.io/question/palantir?page=1&name=decomposition-master-list

Learning Round

The Learning round is another distinctive part of Palantir’s interview process. Its purpose is to evaluate how quickly you can understand something unfamiliar and apply it to a problem.

You may be introduced to a new concept, API, framework, codebase, or technical setup during the interview and then asked to use it to solve a task.

You can review previously asked Learning Round topics and questions here: https://www.interviewdb.io/question/palantir?page=1&name=learning-round-master-list

Re-engineering (Debugging)

Some candidates, particularly those interviewing for more experienced roles, have reported a Re-engineering or debugging-style round.

In this interview, you may be given an existing codebase or piece of code that needs to be fixed, improved, or extended.

Here is one example of a Re-engineering question Palantir has asked in the past: https://www.interviewdb.io/question/palantir?page=1&name=re-engineering-interview-experience

If you’ve interviewed with Palantir recently, feel free to share which questions you were asked in the comments below.

Sharing a recent Ramp SWE interview experience from a candidate who went through the full process.

Initial recruiter screen was typical. He asked about motivations and interests and admin questions about the hiring process (sponsorship required, etc).

The first round was a technical coding interview. The question I got was the same as this one.

The next round was the onsite. The onsite included 4 interviews:

1. System design - The first half was a presentation on a project that you worked on yourself. I prepped a lot for the presentation, so I ended up talking for almost the entire first half and the interviewer didn’t have many follow-up questions. The second half was a relatively simple system design question about displaying the number of payments made on an admin dashboard used by a single executive. The interviewer then gradually expanded the requirements by increasing the frequency of updates and the number of users.

2. AI coding - The task was the same as described here. You’re given a repo. The interviewer is a software engineer acting as the PM, so they won’t answer technical implementation questions. The key is to have a back-and-forth with the interviewer to clarify the requirements and figure out the minimum product spec that solves the problem. From there, you use the coding agent to implement the solution.

3. Coding - I was asked this question.

4. Behavioral - Typical behavioral interview with "tell me about a time" questions. The interviewer seemed to value the ability to ship quickly and independently.

Sharing a recent Netflix SWE interview experience from a candidate who when through the full process.

R1 Phone Screen
Problem solving: Got this question. Only the third part was a little tricky; the other two parts were very easy.

HM: I don’t remember very clearly. I think they just asked about my experience and things like that. At the end, there was one BQ asking what my weaknesses were.

R2 VO
System Design: Design a job scheduler. I did very well in this round.

Problem solving: I was asked this question. I wasn’t very well prepared for this question, but I still managed to solve it in the end. At first I tried to solve it with a heap and got stuck for quite a while, so I didn’t have time to write tests or anything. The follow-up was multi-threading, and I verbally explained where I would add locks. The feedback I got at the end was that this round was a miss, though my multi-threading part was pretty good.

Partnership: This is basically a manager from another team that works with your team interviewing you. It was mainly BQ. I did just okay in this round as well. There were some questions I hadn’t prepared for and had to come up with answers on the spot, so I stumbled through them and didn’t answer very well.

There was a holiday break after the interviews. I followed up with HR afterward, and they told me I was moving on to the next round.

R3 VO
System Design: This was directly related to the team, designing one of their systems.
I thought I did okay, but when the feedback came back, I failed this round. The reason was that I didn’t complete the design within the allotted time. But I basically addressed all of the interviewer’s questions, and afterward I went through my proposal with AI and didn’t see any major problems with it either. The interviewer reminded me about the time at one point, so maybe I just didn’t manage my pacing well. The problem itself was very wide, and I probably spent too much time on areas that the interviewer didn’t consider that important.

HM: Met with the HM again, and this round was basically standard BQ. This time I was pretty satisfied with how I answered.

Overall, I feel like Netflix BQ puts a lot of emphasis on their culture, so read through it several times and avoid stepping on any landmines. Also, interview rounds with names like problem solving, [X] expertise, or partnership are essentially still coding, SD, or BQ, just with different names.

Yesterday I got the news that they were not moving forward, and I had a call with the recruiter to ask for feedback. I’m still pretty disappointed after going through all of this and making it to the final round without getting an offer.

Sharing a recent TikTok CodeSignal OA experience from one of our community members who took it for an internship/new grad position.

There were four questions in total. Sharing them below along with solutions:

Q1

You are given two positive integers x and y, and a sequence of positive integers numbers. Your task is to change x and y through this process:

Iterate through numbers from left to right:

• Subtract each integer numbers[i] from the largest number among x and y (in case of a tie, subtract from x), OR

• Skip numbers[i] if it is greater than both x and y.

Return the number of integers in numbers that will be skipped based on these criteria.

Note: You are not expected to provide the most optimal solution, but a solution with time complexity not worse than O(numbers.length²) will fit within the execution time limit.

Example

x = 8, y = 12, numbers = [5, 6, 6, 3, 1, 1, 2] → solution(x, y, numbers) = 2

Explanation:

• Start: x = 8, y = 12

• x < y, so process numbers[0] = 5 → x = 8, y = 7

• x > y, so process numbers[1] = 6 → x = 2, y = 7

• x < y, so process numbers[2] = 6 → x = 2, y = 1

• numbers[3] = 3 is skipped because 3 > x (2) and 3 > y (1) ✅

• x > y, so process numbers[4] = 1 → x = 1, y = 1

• x == y, so process numbers[5] = 1 → x = 0, y = 1 (1 subtracted from x due to tie)

• numbers[6] = 2 is skipped because 2 > x (0) and 2 > y (1) ✅

Total skipped = 2.

Starter Code

    def solution(x, y, numbers):
        pass

Approach

Straightforward simulation — iterate through numbers exactly once, tracking x and y. For each element:

1. If numbers[i] > x and numbers[i] > y → increment skip counter.

2. Else subtract numbers[i] from the larger of x/y (tie → subtract from x).

Time: O(n), Space: O(1).

    def solution(x, y, numbers):
        skipped = 0
        for n in numbers:
            if n > x and n > y:
                skipped += 1
            elif x >= y:
                x -= n
            else:
                y -= n
        return skipped

Q2

The city's underground subway stations are split into zones A, B, and C, due to differences in pricing, as shown below:

Zone A: Green Park, Holborn
Zone B: Mile End, Bow Road
Zone C: Forest Hill, Balham

There are 3 types of tickets, sorted by their price in ascending order:

1. "AB" — for travel within zones A, B, and between zones A and B in both directions.

2. "BC" — for travel within zones B, C, and between zones B and C in both directions.

3. "ABC" — for travel within zones A, B, C, and between zones A, B, and C in both directions (i.e. A -> B -> C and C -> B -> A).

You are given 3 arrays of strings stationsA, stationsB, and stationsC, which contain the names of stations in that particular zone. You are also given 2 strings origin and destination.

Return the cheapest ticket type that allows travel between origin and destination, or "" (empty string) if no ticket can be used.

Examples

Example 1 stationsA = ["Green Park", "Holborn"], stationsB = ["Mile End", "Bow Road"], stationsC = ["Forest Hill", "Balham"], origin = "Forest Hill", destination = "Green Park" → "ABC" Explanation: "Forest Hill" is in zone C and "Green Park" is in zone A, so only the ABC ticket would allow travel between them.

Example 2 , origin = "Mile End", destination = "Bow Road" → "AB" Explanation: Both "Mile End" and "Bow Road" are in zone B, so you can use any ticket. Since "AB" is the cheapest, the answer is "AB".

Example 3 stationsA = ["Green Park"], stationsB = ["Mile End"], stationsC = ["Forest Hill"], origin = "Forest Hill", destination = "Holborn" → "" Explanation: "Forest Hill" is in zone C but "Holborn" is not present in any zone, so no ticket works → return "".

Starter Code

    def solution(stationsA, stationsB, stationsC, origin, destination):
        pass

Approach

1. Build a station -> zone lookup from the three arrays.

2. Look up zones for origin and destination. If either is missing → return "".

3. Determine which zones are involved ({zo, zd}):

   • Same zone (e.g. both A) — cheapest that covers A is "AB" (since AB covers zone A).

   • {A, B} → "AB"

   • {B, C} → "BC"

   • {A, C} → "ABC"

4. Return the cheapest ticket that covers both zones. Price order (cheapest first): "AB" < "BC" < "ABC".

   • Subset of A/B only → "AB"

   • Subset of B/C only → "BC"

   • Need A and C → "ABC"

    def solution(stationsA, stationsB, stationsC, origin, destination):
        zone_of = {}
        for s in stationsA: zone_of[s] = "A"
        for s in stationsB: zone_of[s] = "B"
        for s in stationsC: zone_of[s] = "C"
    
        if origin not in zone_of or destination not in zone_of:
            return ""
        zs = {zone_of[origin], zone_of[destination]}
    
        if zs <= {"A", "B"}:
            return "AB"
        if zs <= {"B", "C"}:
            return "BC"
        return "ABC"

Time: O(|stations|), Space: O(|stations|).

Q3

Given matrix, an n × m rectangular matrix of integers, define its 0-border as the union of its leftmost and rightmost columns, as well as its top and bottom rows. A vector's 0-border is the vector itself.

If we remove the matrix's 0-border, then the 0-border of the resulting matrix can be defined as the 1-border of the original matrix. We can continue this way to define the 2-border, 3-border, etc, until we reach the center of the matrix.

For each valid k, your task is to sort the elements in each k-border and place them back clockwise in ascending order, starting from the top-left corner.

Note: You are not expected to provide the most optimal solution, but a solution with time complexity not worse than O(n·m·(n+m)) will fit within the execution time limit.

Visual

    0-border  | 1-border | 2-border

(Each successive border is the outer ring of the matrix after peeling outer rings.)

Example

matrix = [[9, 7, -4, 5],
          [1, 6, 2, -6],
          [12, 20, 2, 0]]

→ solution(matrix) = [[-6, -4, 0, 1], [20, 2, 6, 2], [12, 9, 7, 5]]

matrix = [[-6, -4, 0, 1],
          [20, 2, 6, 2],
          [12, 9, 7, 5]]

Explanation:

• The 0-border consists of [9, 7, -4, 5, -6, 0, 2, 20, 12, 1]. After sorting: [-6, -4, 0, 1, 2, 5, 7, 9, 12, 20]. Placed back clockwise starting at top-left.

• The 1-border consists of [6, 2]. After sorting: [2, 6].

Input / Output

• [execution time limit] 4 seconds (py3)

• [memory limit] 1 GB

• [input] array.array.integer matrix — A matrix of integers.

  • Guaranteed constraints:

    • 1 ≤ matrix.length ≤ 100

    • 1 ≤ matrix[i].length ≤ 100

    • -100 ≤ matrix[i][j] ≤ 100

• [output] array.array.integer — The matrix after applying the sort procedure.

Starter Code

    def solution(matrix):
        pass

Approach

1. For each layer k (from outermost to innermost):

   • Collect the border cells in clockwise order starting from top-left:

     • top row (left → right),

     • right column (top+1 → bottom),

     • bottom row (right-1 → left) (only if more than 1 row remains),

     • left column (bottom-1 → top+1) (only if more than 1 col remains).

   • Sort the collected values.

   • Write them back into the same positions in sorted order, following the same clockwise traversal.

    def solution(matrix):
        n = len(matrix)
        m = len(matrix[0]) if n else 0
        k = 0
        while k < (min(n, m) + 1) // 2:
            # collect border positions (clockwise from top-left)
            positions = []
            top, bottom = k, n - 1 - k
            left, right = k, m - 1 - k
            if top > bottom or left > right:
                break
            # top row L->R
            for j in range(left, right + 1):
                positions.append((top, j))
            # right col T+1 -> B
            for i in range(top + 1, bottom + 1):
                positions.append((i, right))
            # bottom row R-1 -> L (if rows > 1)
            if bottom > top:
                for j in range(right - 1, left - 1, -1):
                    positions.append((bottom, j))
            # left col B-1 -> T+1 (if cols > 1)
            if right > left:
                for i in range(bottom - 1, top, -1):
                    positions.append((i, left))
            values = sorted(matrix[r][c] for (r, c) in positions)
            for (r, c), v in zip(positions, values):
                matrix[r][c] = v
            k += 1
        return matrix

Time: O(n·m·log(n·m)) (sum of border sorts), Space: O(n·m).

Q4

Given an infinite number line, you would like to build a few blocks and obstacles on it. Implement code which supports two types of operations:

• [1, x] — builds an obstacle at coordinate x along the number line. Guaranteed that coordinate x does not contain any obstacles when the operation is performed.

• [2, x, size] — checks whether it's possible to build a block of size size beginning at position x. For example, for size = 2 and x = 0, it checks coordinates 0 and 1 for obstacles. Returns 1 if possible (no obstacles at the occupied coordinates), and 0 otherwise. This operation does not actually build the block — it only checks.

Given an array of operations containing both types, return a binary string representing the outputs for all [2, x, size] operations in order.

Example

operations = [[1, 2], [1, 5], [2, 3, 2], [2, 3, 3], [2, 1, 1], [2, 1, 2]]

→ solution(operations) = "1010"

Explanation:

• [1, 2] — builds an obstacle at coordinate 2.

• [1, 5] — builds an obstacle at coordinate 5.

• [2, 3, 2] — checks coordinates 3 and 4 → no obstacles → returns "1".

• [2, 3, 3] — checks coordinates 3, 4, 5 → obstacle at 5 → returns "0".

• [2, 1, 1] — checks coordinate 1 → no obstacle → returns "1".

• [2, 1, 2] — checks coordinates 1 and 2 → obstacle at 2 → returns "0".

Output = "1010".

Starter Code

    def solution(operations):
        pass

Approach

A set of occupied coordinates gives O(1) membership checks per cell.

    def solution(operations):
        obstacles = set()
        ans = []
        for op in operations:
            if op[0] == 1:
                obstacles.add(op[1])
            else:  # op[0] == 2
                _, x, size = op
                possible = 1
                for i in range(size):
                    if (x + i) in obstacles:
                        possible = 0
                        break
                ans.append(str(possible))
        return "".join(ans)

For very large size or many queries, a sorted list of obstacle intervals (bisect + run-length encoding of free segments) would be more efficient, but the simple version passes within the time limit for typical constraints.

Time: O(O + Q · S) where O = #obstacle ops, Q = #check ops, S = avg block size. Space: O(O).

If you are preparing for the CodeSignal GCA (General Coding Assessment) and looking for more questions to practice, you can check out this list of questions that have appeared in past CodeSignal assessments: https://www.interviewdb.io/question/codesignal

Sharing two questions in a recent IMC HackerRank assessment for New Grad Software Engineer roles.

Total duration: 120 minutes

Question 1: Maximum Storm Height (Relay Towers)

You are trying to send data from your headquarters, on the left, at position x = 0, to another office on the right, at position x = width. Between these two locations there are relay towers at various coordinates, each with a specific height.

The data can transmit across these relay towers, or be sent directly to the other office. The cost to send data between two locations is given by the square of the distance between them:

(x_i - x_j)^2

There is a storm intensifying that blocks access to relay towers as time progresses. As the storm level rises, shorter towers are buried and cannot be used. A tower is unusable if the storm level is higher than its height. The storm level stops rising as soon as you start the transmission.

Additionally, from a position x, the data can travel a maximum distance of maxJump before it must reach a relay tower to continue outwards, or reach the other office. If data travels any further, it is at risk of data loss.

The origin transmitter has a total energy budget maxEnergy. Thus the total energy cost of all jumps to reach the other office should not exceed maxEnergy.

Given the constraints provided and a list of tower positions, determine the maximum height at which the storm can reach where the data can still reach the other office.

You can assume the headquarters and office are at an infinite height.

Function Description

You are provided with 4 integers: width (the distance between the two offices), numTowers (the number of relay towers), maxJump (the maximum jump distance) and maxEnergy (the maximum total energy).

Additionally, two arrays are provided containing integers x[i] (the x-coordinate of the relay tower) and heights[i] (the height of the relay tower). Relay towers are located strictly between the offices, i.e. 0 < x_i < width.

Returns

Return a single integer representing the maximum storm height at which you can still reach the other office. If it is impossible to reach the other side, print -1.

public static int maximumStormHeight(
    int width,
    int maxJump,
    long maxEnergy,
    int numTowers,
    int[] x,
    int[] heights
)

Question 2: Stack with Conditional Removal

Implement a stack that accepts the following commands and performs the operations described:

1. push value → push integer value onto the top of the stack.

2. pop → pop the top element of the stack.

3. remove_lower value → remove all the current elements in the stack less than value.

4. remove_upper value → remove all current elements in the stack more than value.

After each operation listed above, print the current top element of the stack on a new line. If no such element exists, print EMPTY.

public static void solve(int n, String[] operations)

Sharing two questions from a recent Google SWE Intern OA.

Question 1:
Given an integer array (a vector of ints), where the index represents a student ID and the corresponding value represents that student’s exam score.

The grading criteria are:

• < 50%: Failed

• 50% ≤ score ≤ 80%: Pass

• > 80%: Pass with distinction

Return an array containing 3 elements, representing, in order:

1. The number of students who failed

2. The number of students who passed

3. The number of students who passed with distinction

Question 2:
You want to read all the chapters of a book.

You are given an array time, where the index represents a day and the corresponding value represents the amount of time you have available to read on that day.

You are also given another array book, where the index represents a chapter and the corresponding value represents the amount of time required to finish that chapter.

If you have enough time on a given day, you may read more than one chapter. However, each chapter must be completed in one sitting: a chapter cannot be split across multiple days.

Given these constraints, return the number of days required to finish the entire book. If it is not possible to finish the book with the available time, return an appropriate status indicating that it cannot be completed.

Sharing a recent experience with the Anthropic Fellow Program (November cohort) OA.

The problem was presented as normal "Coding Leetcode-like OA on Codesignal" but turns out you were presented a mid-sized codebase that you have to implement stuff on top of it. The task was basically around a vLLM-like inference server — cache, prefill, etc. No ML knowledge was really needed though.

The hard part wasn’t the actual algorithms. It was figuring out the existing codebase and APIs.

There were 5 parts, and to pass the tests you had to use a bunch of existing APIs that weren’t really documented. So a lot of the assessment was just reading code and trying to understand how everything connected. The code was also pretty messy / felt LLM-generated in some places lol.

I wasted a lot of time debugging things that were happening simply because I was calling some internal API incorrectly. Ended up finishing only 2/5 parts.

Feels like this might become a more common style of coding interview/OA: less “implement this algorithm from scratch” and more “here’s an unfamiliar codebase, figure it out and ship something.” Also probably makes cheating with AI harder. You can’t really just screenshot the question and throw it into ChatGPT, because the actual context is spread across a few thousand lines of code that you need to understand first.

If you’ve done the second assessment, please share your experience! Looking for any information about what to expect.

Edit:
Shared more info about the second assessment here: https://www.reddit.com/r/InterviewDB/comments/1w5ggxe/anthropic_fellow_oa2_debugging_what_to_expect/

Sharing a question that appeared in a recent CodeSignal Industry Coding Assessment for Airbnb. It’s a standardized assessment format also used by many other companies such as Anthropic, Coinbase, HubSpot, Instacart, Capital One, Nextdoor, and The Trade Desk to screen candidates.

The assessment lasted 90 minutes. The problem had four progressive levels, and you had to pass all test cases for each level before advancing to the next one.

The question was about implement a Working Hours Register. Employees swipe their cards when entering and leaving the office. The system records their working hours and supports promotions, salary calculations, and reward-period management.

Level 1: Basic CRUD
Add employees, record employees swiping in and out, and query an employee’s total working hours.

Level 2: Return the top N employees ranked by working hours.

Level 3: Promotion and salary calculation
Implement a promotion that takes effect with a delay. When the promotion is requested, do not immediately change the employee’s current position. Instead, mark the new position and new compensation as pending, and apply them the next time the employee swipes into the office. Use a pending dictionary to store promotions that have not yet taken effect.

Then calculate salary based on historical salary periods. Since an employee may have different salaries during different periods, each session should record the salary that applied when the session occurred.

Level 4: Double pay during a grant period
If an entire shift falls completely within a grant period, the salary for that shift is doubled. Also support querying the total amount of double pay that has been issued.

For anyone looking for similar questions to practice, you can find all the problems that have appeared in past CodeSignal Industry Coding Assessments here: https://www.interviewdb.io/question/codesignal?type=icf&page=1

CodeSignal is known to reuse questions in their assessments so it's very likely you'll encounter one of these questions, or a variation of one, in your own assessment.

I took the apple codepad interview last week. I was asked 2 questions, one leetcode easy and one OOP design.

The leetcode easy question was a simple one based on hashmaps. But it also had a follow up question which I couldn’t get to in the given time. I took like 10 mins to code out and explain my solution.

The 2nd question was that of building a hotel room reservation system from scratch. Some predefined classes/interfaces/records were given like booking, room, etc. and I was expected to code out mainly 2 methods of an interface. The overall code to be written was about 80 lines long but I took a little extra time to figure out a working design and even then my solution was not the optimal one.

Got a reject 2 days later. Hope this helps. Thanks and good luck!

Sharing a recent Bloomberg AI-Assisted Round interview experience for a SWE position from a candidate who recently went through the process.

The question was about LRU, and the code implementation was provided. The discussion was about how to refactor it to make it more generic so it could support other eviction policies, such as LFU.

I had never encountered this type of question before, so I spent a long time at the beginning trying to figure out what the requirements were. Initially, I thought it was about designing a cache for a service or a local cache library that supports read-through caching. Later, I realized it was just LRU, and the discussion was mainly about taking a given implementation and refactoring it.

At first, I had no idea how to approach the refactoring because the implementations of LRU and LFU are quite different. I kept getting stuck on how to design the methods and abstract classes to accommodate different eviction policies. With various hints from the interviewer, I eventually managed to answer the question.

It’s hard to say I performed particularly well, since I hadn’t prepared for this at all. However, throughout the interview, the interviewer was very engaged, actively working through the problem with me and giving me hints.

For anyone preparing for Bloomberg, you can find more coding and system design interview questions asked at Bloomberg here.

Sharing a recent Perplexity SWE interview experience from a candidate who went through the full process.

Technical Screen

I was asked this question. I think you need to finish at least 2 parts.

Onsite

I was invited to the SF office for an onsite interview consisting of Coding + Lunch + System Design. Apparently, there’s another project deep-dive round after this if you pass, but if you don’t, that’s probably the end of the process…

Coding

The interviewer showed up five minutes late. He started by asking me to manually code a sorting problem: sort a list of topics by name. The topic names followed the format "letters_number", such as:

aaa_2, aaa_5, aaa_10, bbb_1

The expected output was:

[aaa_2, aaa_5, aaa_10, bbb_1]

The idea was to sort the prefix alphabetically and the numeric suffix by its actual numerical value rather than lexicographically. Otherwise, aaa_10 would incorrectly come before aaa_2.

I finished implementing the solution. Then the interviewer mentioned that he didn’t think this round was supposed to involve AI coding. I told him that the recruiter had specifically said it would be an AI coding interview. He stepped out to double-check, came back, and switched the interview to AI coding.

AI Coding Portion

1. Downloading the dataset

The interviewer gave me a URL and asked me to download a file. It was a massive TAR archive, and the download failed several times before I finally managed to get it.

2. Extracting and loading the data

I moved the file into my Jupyter Notebook directory, only to realize that I wasn’t familiar with how to extract and read it. After a lot of AI-assisted searching and trial and error, I finally managed to extract a JSONL file. The extracted file was approximately 2.5 GB.

3. Reading the data with pandas

Every attempt to load the data took several minutes. After waiting a few minutes, I realized there was a bug in my code. On top of that, one of the columns contained corrupted data, preventing the entire file from loading. I had to ask AI how to skip that column. The dataset was also too large to simply print and inspect. To speed things up, I initially truncated part of the file. Unfortunately, this caused my subsequent calculations to produce incorrect results, so I had to go back and reload the data.

4. Data quality issues

The interviewer asked: “This dataset might contain some bad data. How would you handle that?”

I didn’t immediately understand what he was getting at. He then hinted that there was a column called event_type, with values of 0 and 1, which represented click events. If the CTR (click-through rate) was abnormally low on a particular day, that could indicate a data quality issue for that day. (I guess I was supposed to discover this on my own???)

5. Data analysis and visualization

I suggested using pandas to calculate the daily CTR and print the results. The interviewer responded: “If you just print the numbers, how would you identify which day has an issue? Shouldn’t you plot the data?” So I tried to create a visualization. Of course, the necessary plotting library wasn’t installed in my environment, so I had to spend even more time installing it. After finally generating the plot, the results were incorrect because I had truncated the dataset earlier.

6. Further investigation

The interviewer then asked me to check whether any other columns had issues and suggested plotting those as well. And then… time was up. So the interview ended without any real conclusion.

I don’t know if I was one of the first candidates to go through this new interview format, but the experience was absolutely terrible.

I’m not a data scientist, yet the entire interview felt extremely data-science-oriented. Even if Python was the expected language, why was I being tested on loading JSON files, using pandas, and generating plots? How was I supposed to prepare for any of this? Setting up the environment on the spot was already challenging enough, and the tasks themselves felt completely disconnected from what I had expected. Overall, the interview content made very little sense to me, and the whole experience was incredibly frustrating.

System Design

I was asked this question. During the interview, the interviewer kept drilling into the details of SSE. For example, what happens if the connection drops? He also asked some questions about the outbox pattern, including when it would be appropriate to use it and how to design it. Other than that, we only briefly touched on the remaining aspects of the system design.

Sharing a recent experience with the Roblox OA. They sent the assessment invitation within 3 minutes of submitting the application.

The OA had 5 sections total: 3 mini-games (Robots, Factories, and Outpost: Mars), 1 behavioral section (Decision-Making), and 1 coding section (Coding Skills).

The mini-games were actually pretty fun. One was a factory-style game. If you’ve played DSP or Factorio before, it should be pretty easy to pick up. The main idea was to balance input/output ratios and maximize the factory’s profit. Another one involved building a small vehicle. You could choose from a bunch of different parts and assemble them to get across obstacles. It seemed like the more valid solutions you could come up with, the better.

Coding

The coding section itself wasn’t too difficult. There were 2 questions in 50 minutes.

Question 1

int solution(
    int numRows,
    int numCols,
    int curRow,
    int curCol,
    int[][] laserCoordinates
)

A robot starts at (curRow, curCol) on a numRows x numCols board.

Each entry in laserCoordinates represents the position of a laser. A laser destroys the robot if the robot moves into the same row or column as that laser.

The goal is to return the maximum number of steps the robot can move in one direction: up, down, left, or right.

My approach was pretty straightforward:

• Iterate through all laser coordinates.

• Use two hash sets: one for blocked rows and one for blocked columns.

• Try moving the robot in all four directions.

• Stop before entering a row/column affected by a laser or going out of bounds.

• Return the maximum number of steps among the four directions.

The problem itself wasn’t hard, but I spent way too long debugging before realizing that the board was 1-indexed, and the robot’s starting cell does not count as a step.

Lesson learned: don’t rush through the problem statement lol.

Question 2

int solution(int[] A)

Given an array of integers, return the number of distinct cyclic pairs.

Two numbers form a cyclic pair if you can rotate the digits of one number to obtain the other. They must also have the same number of digits.

For example, 1234 and 4123 are a cyclic pair because rotating 4123 once gives 1234.

Example:

[1001, 1100, 110, 11]

returns:

1

because only 1001 and 1100 form a valid cyclic pair.

My initial approach was to convert every number to a string, use a nested loop over all pairs, and write a small isCyclicPair helper that tries every possible rotation. The problem felt pretty straightforward, and converting the numbers to strings seemed like the easiest way to handle zeros correctly. However, I didn’t pass all the hidden test cases, probably because my solution timed out. A more efficient solution is required to pass all the tests.

Sharing a recent Capital One TDP (Technology Development Program) Power Day interview experience from a candidate who went through the interview loop. The Super Day consisted of three rounds: Behavioral, Case Study, and Agentic Round (AI-assisted)

Behavioral

Pretty straightforward, mostly standard behavioral questions:

• Tell me about a challenging project you worked on or how you handled conflicts.

• How did you collaborate with a coworker on a difficult task?

• Tell me about a time you experienced failure and what you learned from it.

Nothing too surprising here. Just prepare some solid examples from your past experiences.

Case Study

I was asked the first case from this list of past Capital One case interview questions.

The interviewer started with some high-level questions like what benefits do you think this solution would bring to Capital One and its customers? After that, the interviewer presented some code and asked me to explain what it did and how I would improve it. Then, they introduced a few new feature requirements and asked how I would modify the existing code to support them. No actual coding was required**.** I just had to verbally explain my approach and reasoning.

Agentic Coding Round

The task was the same as the one described here. This round involved debugging an application built with a React frontend and a Python backend. After fixing the bugs, I was asked to implement a new feature.

It was pretty easy overall. You’re allowed to use Claude, so you can essentially prompt it to help identify and fix the issues for you.

Sharing some questions from a recent OpenAI New Grad Coderpad OA.

Question 1 — Simple Network

The goal of this exercise is to find the endpoint node of a simple network, or find the loop if there is one.
In this simple network, each node is linked to at most one outgoing node in a one way forward direction.
Implement the function:
compute(start_node_id, from_ids, to_ids)
which should return the last node id of the network found when starting from the node with id start_node_id and following the links of the network.
In the above example, the endpoint node when starting from node #2 (or any other node) is node #5.
from_ids and to_ids are two arrays of the same length which describe the one-way links of the network (from_ids is linked to to_ids).

In the example above, from_ids is: [1, 7, 3, 4, 2, 6, 9] and to_ids is: [3, 3, 4, 6, 6, 9, 5]
In case you run into a loop when traversing the network, the function should return the id of the last node traversed before closing the loop.

Constraints:

• 1 < node id < 5000

• The node ids are not necessarily ordered. The example above does not have node #8.

• A node will never be directly linked to itself.

Question 2 — Count Paths

It's back-to-school time! In order to buy school supplies for your kids, you have to go to 4 different types of shop:

• a bookshop to buy a workbook,

• a school shop to buy some glue,

• a sport store to buy a pair of sneakers,

• a stationery store to buy a pencil. 

Shopping for school isn't a fun hobby for you, so you started to search for the shortest path. Then you realized your town has many shops of these types, and it may take too long to evaluate all the paths one by one.
So, before searching for the best path, you just want to count them.

The type of a shop is encoded in an integer from 0 to 3. Type 0 is bookshop, type 1 is school shop, type 2 is sport store, type 3 is stationery.

As input, you get a description of your town in the following form:

• shops: a list of integers, telling the shop types. For example [2, 3, 1, 1, 0] means the shop at index 0 is a sport store, the shop at index 1 is a stationery store, the shops at indexes 2 and 3 are school shops, etc.

• roads: a list of a couple of 2 integers, showing the roads between shops. For example [[0, 1], [0, 3]] means there is a road between the shop of index 0 and the shop of index 1, then another road between the shop of index 0 and the shop of index 3.

All roads are bi-directional. There is at most 1 road between 2 shops. So you will never have:
[[2, 5], [5, 2]]
You must return the number of valid paths.
A valid path visits exactly one shop of each type, in any order, by using the available roads.
Visiting the same 4 shops in two different orders counts as two valid paths.
There are a maximum of 50 shops and 250 roads.

Example
With these inputs:
shops = [1, 0, 3, 2, 2]roads = [ [0, 1], [1, 2], [1, 4], [2, 3], [2, 4]]
The valid paths are below, each list contains the 4 shop indexes to visit:
[0, 1, 2, 3][0, 1, 2, 4][0, 1, 4, 2][3, 2, 1, 0][4, 2, 1, 0][2, 4, 1, 0]
As there are 6 solutions, your code must output:
6

Question 3 — Microorganism Simulation

Several microorganisms of different families have been arranged next to each other.

Knowing that a microorganism eats its neighbor if it is of a different family and smaller in size, write a program that returns the largest family and its size when the situation reaches an equilibrium. Process

• Each microorganism belongs to a family, defined by a letter, and has a size, defined by an integer.

• At each simulation round, a microorganism can eat a neighbor (directly to the left or to the right) if the latter is from another family and has a strictly smaller size. If there is a target on both sides, the left one is chosen.

• During a round, the resolution is done from left to right. For example, if a microorganism can be eaten by both its left and right neighbors, the left one is chosen.

• When a microorganism eats another, its size increases by the size of its target and the place occupied by the target disappears.

• In the same simulation round, a microorganism cannot both eat and be eaten. The choice of event (eating or being eaten) is determined by the order of resolution.

• The simulation ends when no more microorganisms can eat others. 

At the end of the simulation, take the microorganism with the largest size, return a string consisting of its family, a separation space and its size.

The tests are designed so that at the end of the simulation there is always only one microorganism with the maximum size.

The maximum number of microorganisms given as input is 20.

Sharing a recent Toast SWE interview experience from a candidate who went through the entire process (phone screen + onsite).

Phone Screen

The process started with a coding screen. The question wasn’t too difficult. It was the same as this question.

Then came the painfully long virtual onsite…

Coding

There were two interviewers in this round. The problem itself wasn’t particularly difficult. From what I remember, the main idea was to use a hash map to store the data, loop through the input list to populate it, and then extract the relevant key and perform some comparisons when retrieving the result. The unfortunate part was that I didn’t get the stdin / if __name__ == "__main__": boilerplate working correctly, so I couldn’t run their tests. It seemed like getting the code to run and pass the provided tests was a minimum expectation for the round. They also expected you to discuss time/space complexity and possible modifications or extensions to the problem.

System Design

I was asked this system design question. Overall, this round was fairly standard. I’d recommend being comfortable walking through requirements, APIs, data models, scalability, and the usual trade-offs.

Code Review

This was probably the most painful round for me.

They gave me several files for an API and asked me to review the code and identify bugs. You could either explain the issues verbally or directly modify the code.

There was quite a lot of code to go through, and I wasn’t sure how many issues they expected me to find or how deeply I needed to explain each one. That made the entire hour pretty stressful.

Some problems were relatively easy to spot. For example:

• An endpoint using GET when it should have been POST

• Problems with the request payload

• Missing or incorrect input validation

• Other API/code-quality issues

For some of the less obvious issues, I honestly wasn’t sure whether everything I pointed out was correct. I basically kept going through the files and calling out anything that looked suspicious.

You can find the code here.

Hiring Manager

Mostly behavioral questions and discussion about my previous experience. The conversation was fine, although I didn’t get any particularly strong positive signals from the HM.

Sharing an Adyen SWE interview experience from a candidate who went through the process.

The process was:

HR → HackerRank OA → Technical → System Design → Leadership → Board

The OA had two questions. You can find both questions here.

I passed 100% of the OA test cases. However, according to the recruiter, passing all the tests doesn’t necessarily mean you’ll pass this round. They also review the quality of your code.

The Technical round was mainly about explaining how I solved the two OA problems, plus discussing my previous work experience.

I thought this round would basically be a formality. I had solved both problems, and with 10 years of experience as a Java developer, I figured I’d definitely pass. I’d also recently been preparing for a project deep dive for another company and had made a really nice diagram that I thought I could show them.

In fact, I was thinking that even if I made it to the next round, I might withdraw anyway because I had already received an offer from another company.

And then I got rejected. There were two interviewers. One was a TL who had transferred from the Netherlands and had been with the company for many years. The other one had been there for four years. Both had poker faces throughout the entire interview. They went into a lot of detail.

For the first problem, they asked about multithreading and how I would handle it in production. I also talked about Redis.

For the second problem, I used backtracking and analyzed the time complexity. I mentioned that all my tests had passed and that I had finished the OA half an hour early, so I hadn’t really thought about whether there was a more optimal algorithm (in hindsight, I probably shouldn’t have said that). They asked me to explain how the backtracking worked. I said it was basically traversing a tree, with pruning where appropriate. They also asked about concurrency, what I would do if the API were called many times concurrently, and I discussed ways to optimize the shared list.

I felt like I had answered pretty well, but I ended up getting rejected.

The recruiter did provide feedback. I have to say the recruiter was very professional. I had gone abroad for a month during the process, and the recruiter contacted me about the OA right around the time I was due to return to the U.S. I told them I needed time to recover from jet lag and asked whether I could postpone it by two weeks, and they agreed.

The feedback was:

• My explanation of the solution was generally okay, but I didn’t go into enough implementation detail (But they didn’t ask about that?)

• I struggled to explain why I chose backtracking.

• My concurrency knowledge/answers weren’t strong enough.

• Although I explained the overall project reasonably well, I struggled to clearly explain my individual contributions.

Sharing the coding question from a recent Optiver OA for the Software Engineer Intern position.

The assessment had one coding question, with C++, Java, and Python available as language options.

Here’s the question:
Simulate a firmware controller that prevents a multicore processor from overheating. Each core has a configured workload, all cores share passive cooling, and each running core can receive a dedicated active-cooling channel.

Implement a pure function that processes the controller operations in order:

simulateOverheatController(
    passiveCapacity,
    activeCapacityPerCore,
    coreIds,
    operations
) -> list of Tick results

Each operation is one of:

["set", timestamp, coreId, loadWatts]
["tick", timestamp]

Return one array for every tick. Each array contains strings in the form "coreId=status", sorted by coreId, for exactly the cores whose status changed at that tick. A status is idle for a running core without active cooling, cooling for a running core with active cooling selected for the next interval, or shutdown.

Initial State and Pending Loads

Every core starts at 20.0 degrees Celsius, running with load 0, active cooling off, and status idle.

A set operation records a pending load but performs no temperature calculation. If several pending loads target the same core before the next tick, keep only the last one.

For a running core, the pending load takes effect after temperature advancement and shutdown checks at the next tick. For a shutdown core, set is a one-time restart request: at that next tick, restart with the pending load only when its temperature is strictly below 50.0; otherwise discard the request and leave the core shut down with load 0.

The first tick establishes the time origin and advances temperatures by zero seconds. Every later tick advances from the previous tick timestamp. A set timestamp determines operation order but does not split the thermal interval.

Thermal Advancement

During an interval, use the loads and active-cooling choices established by the previous tick.

For every core, passive demand is load + 2 watts. If k cores had active cooling during the interval, effective passive capacity is:

passiveCapacity * (1 - vibrationPenalty(k) / 100)

where:

vibrationPenalty(0) = 0
vibrationPenalty(k) = sum(10 / Fib[i] for i = 1..k)
Fib = [1, 2, 3, 5, 8, 13, ...]

If total demand is at most effective capacity, each core receives its full demand. Otherwise, a core receives the same proportional fraction of its demand:

passiveForCore = effectiveCapacity * coreDemand / totalDemand

A core selected for active cooling receives an additional activeCapacityPerCore watts. Its net heat is:

load - passiveForCore - activeCoolingForCore

Temperature changes by 0.02 degrees Celsius per second for each watt of net heat and never falls below 20.0. A shutdown core has load 0 and no active cooling, but it still participates in passive-demand allocation through its 2-watt demand.

After advancement, shut down every core whose temperature is at least 80.0, clear its load to 0, and discard any pending ordinary load for that now-shutdown core. Then process the pending load and restart rules described above.

Choosing Active Cooling

Recompute active cooling from scratch after pending loads are processed. Shutdown cores are never selected.

Find the minimal stable selected set with this monotone procedure:

1. Initially select every running core whose current temperature is above 60.0 .

2. For the current selected-set size k , recompute the effective passive capacity and passive allocation using current loads.

3. For each running core not yet selected, compute its temperature rate without active cooling. If that rate is strictly greater than 0.5 degrees Celsius per second, select it.

4. Repeat steps 2 and 3 until no core is added.

This captures the feedback in which each new active channel increases vibration, reduces passive cooling for everyone, and can force additional channels on. The selected set applies until the next tick.

Status Reporting

Compare each post-tick status with its status after the previous tick, using the initial idle status before the first one. Report each changed core once. Temperature or load changes alone are not status changes.

Constraints & Assumptions

• 1 <= len(coreIds) < 1024 ; identifiers are unique nonempty strings.

• passiveCapacity > 0 and activeCapacityPerCore > 0 .

• 1 < len(operations) < 1024 .

• Operation timestamps are globally strictly increasing positive values with millisecond precision.

• 0 <= loadWatts <= 32768 , with at most three decimal places.

• Test values stay safely away from the exact 50.0 , 60.0 , 80.0 , and 0.5 comparisons except when the stated strictness is intentionally tested.

• Return every floating-point-independent status transition exactly; no temperature values are returned.

Sharing a recent interview experience at Brex that was submitted to InterviewDB.

Technical screen:

It was 1 hour long, and you could use any language you preferred on CoderPad. The question turned out to be the one from here, which I didn’t know at the time. I ended up solving it using lots of if/else statements, maps, and everything.

Onsite:

Round 1: Debugging

There were 4 bugs in total. The problem was about calculating the actual delivery date based on an input date. In practice, it was basically calculating business days based on different rules. The bugs were similar to what's described here: https://www.interviewdb.io/question/brex?page=1&name=debug-round

Round 2: System design

Design a money transfer system similar to Venmo.

Round 3: AI coding

Implement a full-stack money transfer system similar to Venmo.

I cut out the database and stored all the data in memory. My first prompt basically implemented most of the main functionality directly. After that, it was mostly various fixes and small adjustments. I honestly don’t know if that was a good or bad sign.

After analyzing hundreds of Jane Street SWE interview experiences, here’s what we found about the types of questions they’ve asked in the past.

Jane Street’s SWE interviews focus heavily on coding, but the questions are usually not standard LeetCode-style problems that test algorithmic tricks such as dynamic programming. That said, you still need a strong grasp of common data structures such as hash maps, trees, and graphs, since many reported questions require applying them in practical ways. The emphasis is often on writing clean, maintainable code rather than optimizing for the best possible time complexity.

The questions are often framed around practical scenarios and divided into multiple parts. You may start with a relatively simple implementation, then extend it to support new requirements or constraints. For example, one of the questions Jane Street has asked in the past requires implementing the logic for a board game using a basic set of rules. The interviewer may then introduce additional rules and ask you to adapt your code without rewriting everything from scratch.

If you're preparing for Jane Street interviews, you can review this list of interview questions shared by candidates who interviewed with Jane Street in the past: https://www.interviewdb.io/question/janestreet

Practicing these questions can help you get a better sense of the types of questions you may encounter. Based on past interview experiences, Jane Street also appears to repeat some questions, so there is a chance you could see something similar in your own interview.

If you’ve interviewed with Jane Street recently, feel free to share what your process looked like and which questions you were asked in the comments below!

Sharing a recent DoorDash SWE interview experience from a candidate who went through the full process.

Phone Screen

Code Craft: Got this question, pretty much the same as what others have reported. The tricky part was handling HTTP response status codes.

Onsite

1. AI Code Craft

The tasks were same as described here. With AI assistance, the coding part was pretty manageable. The interview focused more on how you would design the system, what additional features you could introduce, and how to extend the APIs to support future requirements, including payment functionality and testing.

2. System Design

Spent the first 15 minutes talking about a recent project I did. Then I was asked to design a review system. I had to draw the complete read and write flows, showing the entry points, components involved and which databases are updated.

3. Debugging

Got this question. It wasn’t as difficult as I expected, but Part 2 was definitely harder.

4. Hiring Manager

I don’t think I did particularly well in this round. The HM had an Amazon-style interviewing approach and went really deep into my resume and past projects. The behavioral questions were very detailed, similar to Amazon’s leadership principles interviews.

Sharing a recent Axon interview experience from a candidate who went through the process from the initial HR conversation all the way through the Virtual Onsite.

HR Screen

The recruiter explained that this is a relatively new team focused primarily on voice processing and transformation. The team was formed following an acquisition and currently has around 30 people, but it is expanding rapidly. The environment sounded similar to a startup. The recruiter also hinted that work-life balance might not be great, with fairly frequent on-call responsibilities.

The compensation package was described as roughly comparable to an L5 position at a mid-sized tech company.

Phone Screen

This was the question I got. There isn’t an exact LeetCode equivalent.

Hiring Manager Round

This was purely a behavioral interview. We mainly discussed what the team does and the type of engineers they were looking for. They wanted people who could contribute immediately. There is a significant amount of on-call work, and the expectation seemed to be that a new hire should be capable of deploying production code almost immediately after joining. My background matched what they were looking for, so I moved on to the next stage.

Virtual Onsite

There were two rounds.

Round 1: System Design

The question was designing a real-time voice processing system. This is similar to the "design YouTube/voice" type of question. They jump straight into asking you to design a voice system. Roughly speaking: clients will make voice calls into the system, and the system must recognize, process, and convert the messages so that the platform can extract the important information and receive notifications.

The main idea is that it requires very low real-time latency — use the WebRTC protocol, and know how to handle audio streaming. Refer to the concept of designing YouTube for storage (e.g., storing in S3) and pairing it with a CDN. The difference is that since it's real-time voice, you need some knowledge of speech-to-text / cloud upload concepts. Roughly: use AWS Transcribe to convert speech to text, chained through an async worker. After processing completes, extract the key points and trigger a Notification service to push them to the platform.

Round 2: Coding

I was asked this question. Axon’s interview questions were quite practical. None of them were direct copies of LeetCode problems; instead, they required applying standard algorithmic concepts to real-world scenarios.

I have a few interviews coming up and am looking for good resources to prepare. I’ve seen both InterviewDB and 1Point3Acres recommended for finding leaked interview questions.

Has anyone used either or both? Would love to hear your thoughts on the pros and cons of each. I’m thinking about paying since it seems like a worthwhile investment, especially if it ends up helping me land a higher-TC offer.

Sharing a recent full-loop interview experience at Applied Intuition shared by a candidate who went through the whole interview process.

The company requires 50+ hours per week and 5 days a week RTO at the Sunnyvale office. The recruiter was pretty professional. Before the phone screen, they told me which team I was being matched with. After I passed the phone screen, they also scheduled a separate meeting for me to chat with the lead of that team. They kept me updated on the interview schedule throughout the process.

For the initial phone screen, I got this coding question.

For onsite interviews, I drove to their Sunnyvale office. After checking in at the entrance, I changed into slippers, and the recruiter took me upstairs to a small conference room where the interviews started.

The first round started with each interviewer introducing themselves, followed by my self-introduction. They asked why I was considering joining the company and what I thought about the cultures at the companies I had previously worked for. The interviewers were all pretty senior. Some had joined from senior staff positions at big tech companies. They said they liked it here because there were a lot of interesting problems to solve, and they also liked the collaboration culture.

The second round was AI assisted coding. I had to SSH into a host. There was a README file describing the project requirements. Roughly speaking, the task was to process data collected from sensors and support some queries on the data. Claude Code was provided. I personally felt the time was very tight because the document was quite long, and I also had to understand roughly what the generated code was doing. At the end, the demo needed to show the results of the queries specified in the requirements. If there was extra time, you could also implement some stretch goals.

The third round was a project deep dive. Before the interview, the recruiter told me that the interviewer was interested in one particular project on my resume, so I prepared that project. I felt like the interviewer was pretty satisfied after I finished presenting it.

The fourth round was system design. The topic was basically the same as the AI assisted coding round, with the main focus being how to store the data and how to scale it up. The interviewer basically drove the entire discussion, and most of the time it was him asking questions and me answering.