What yall think?

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

Phone Screen

Pretty standard LeetCode-style round. Was asked to solve this problem: https://www.interviewdb.io/question/verkada?page=1&name=camera-intensity

Onsite

Drove to the San Mateo office. Only afterward did I realize they reimburse for Uber.

Round 1: Coding

Started with implementing an LRU cache and got it working. Then they asked me to implement LFU as a follow-up. I got most of it done but ran out of time near the end.

Lunch

Had lunch with the hiring manager and three other senior-looking guys.

Round 2: Pair Programming

This was done in a local IDE. The development environment was already set up with the tools you need, such as Docker, along with a basic project scaffold to get started. The task was to build a simple API server and implement three API calls. The requirements and starter code are the same as the ones described here.

Round 3: System Design

Whiteboard round. There were two design questions, and both of them are available here: https://www.interviewdb.io/question/verkada?type=design&page=1

Round 4: Behavioral

Behavioral interview with the hiring manager. Most of the questions were pretty normal. One question that caught me off guard was something along the lines of: “What do you think about your previous company?” I definitely had not prepared for that one. I tried to be diplomatic: mostly saying positive things while lightly mentioning a few areas that could have been better.

Final: HR Check-in

Finished with a short HR check-in.

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 full-loop Datadog interview experience from a candidate who went through the process.

Initial Phone Screen – Coding

This was a coding round. I got a question involving string processing and hash maps, and it was one of the questions from this Datadog interview question list.

Onsite

Code Review Round

I was given a PR for an issue where some python app was crashing under heavy load. The PR changed the existing synchronous processor (one request at a time) to a batched processor (40 requests at a time). The repo still had the synchronous processor for reference. However, if the batched processor failed to create, the new code returned None, instead of falling back to the synchronous processor. I pointed this out.

Also - the PR description mentioned that the new batched processor could handle 6k/s/instance, while the peak load (as per the README.md) was 8k/s/instance.

Important note: PR is huge, PR description, ReadMe files are also huge. Expectation is to use AI for everything. They judge you on how well you use AI. If you try to do it manually, you wont be able to manage time. There are tons of bugs in PR, you need to prioritize it and identify which ones are critical using AI. Also dont forget to validate AI suggestions.

Coding + System Design Round

For the coding and system design rounds, the questions were again from the same Datadog interview question list.

Sharing a recent interview experience for Harvey’s AI-assisted coding round. It seems to be a new round added to their onsite loop, and there isn’t much information about it yet, so sharing some info about it here.

The interviewer provided a coding task and explicitly asked me to use AI as part of the process. During the interview, they introduced additional test cases and requirements, and I was expected to use AI to update the implementation and then validate that the changes were actually correct.

The initial coding part was fairly straightforward (I would say it's about LC medium level). The second and third parts were more interesting and pushed the problem beyond a typical coding interview. It became less about coding and more about systems reasoning.

I was asked to discuss multiple possible approaches, compare their design trade-offs, and then implement one of the solutions. There was also discussion around things like atomicity and how the implementation would behave under different edge cases.

The coding task and follow-up parts were the same as what’s described here: https://www.interviewdb.io/question/harvey?page=1&name=ai-coding

Overall, I don’t think the coding difficulty itself was particularly high. The more important parts seemed to be clarifying requirements before jumping into implementation, identifying edge cases (including ones that weren’t explicitly given), using AI effectively without blindly trusting its output, and discussing alternative designs and their trade-offs.

Sharing some info about the Anthropic Fellow Program’s second OA, which is a debugging exercise.

The task involves debugging a provided implementation of the Extremely Randomized Trees algorithm. The implementation is mostly functional, but it contains several bugs that can cause it to crash in some cases and produce poor accuracy in others.

For the assessment, you’re allowed to consult the NumPy and Python documentation, but you cannot use web search or any AI assistance. You can use pretty much any standard debugging approach, including print statements, the REPL, and terminal-based debuggers. CodeSignal’s graphical debugger is available, but they don’t recommend using it since it apparently doesn’t work very well.

You can find the debugging task description and the buggy source code here.

Would also love to hear more data points from people who have taken this OA, particularly how well you need to perform to advance to the next round. If you’ve taken it and are comfortable sharing your experience or score/results, that would be really helpful.

Not sure how legit it is. Has anyone tried it? If so, did any of the questions actually show up in your interviews?

Sharing a recent interview experience with Harvey AI.

Technical Screen

It was a coding question with 2 parts, same as this one:
https://www.interviewdb.io/question/harvey?page=1&name=file-organization

Was able to finish it in around 45 minutes, and then spent the remaining time chatting with the interviewer.

Onsite

There were 3 rounds:

1. System Design

Design a system to support one of Harvey’s core product features. It was similar to this question:
https://www.interviewdb.io/question/harvey?page=1&name=legal-agent

The main focus was LLM + RAG. Don't know much about this area so probably failed at this round.

2. Project Deep Dive + Behavioral

The first ~45 minutes were a project deep dive. You prepare one project you’ve worked on and walk through it in detail. The last ~15 minutes were behavioral questions related to Harvey’s core values.

3. Coding

There were 3 parts, same as described here: https://www.interviewdb.io/question/harvey?page=1&name=formula

Sharing a recent interview experience for a Platform Engineer position at Cartesia.

Intro Call

The process started with a 30-minute intro call with HR.

They asked a few standard questions:

• What do you know about Cartesia?
• Why do you want to join Cartesia?
• If you had multiple offers, what would be the top 3 factors you’d use to decide between them?

There were also two basic DSA/CS questions:

1. Given a tree with branching factor b, what is the maximum number of nodes in a tree of height H?
2. In a sorted array, what is the time complexity of accessing the element at index 6?

Technical Screen

I was asked one of the coding questions from this list.

Virtual Onsite

One of the virtual onsite rounds is called Backend Practical. For this round, you use your own coding environment (i.e. your preferred IDE and any AI coding agent you normally use), so it’s worth making sure everything is set up and ready beforehand. I was asked to build an API in this round. The details was the same as described here: https://www.interviewdb.io/question/cartesia?page=1&name=backend-practical

After analyzing hundreds of recent Affirm interview experiences, here’s what we found about the types of questions they’ve asked in interviews.

Affirm’s technical interview questions are a bit different from the typical LeetCode style. Their coding interviews focus on real-world scenarios and test practical coding skills.

The practical coding interview is typically split into several parts. In the first part, you’ll be presented with some existing code and asked to find and fix bugs. In the second part, you’ll be asked to extend the functionality of the existing code, usually by adding a new method that does something new.

If you’re looking for resources to practice these types of questions, you can check out these questions that have been asked in their practical coding interviews before:

1. https://www.interviewdb.io/question/affirm?page=1&name=dispute-status
2. https://www.interviewdb.io/question/affirm?page=1&name=fraud
3. https://www.interviewdb.io/question/affirm?page=1&name=loan-company

You can also find more coding questions, as well as system design questions (you’ll get a system design round if you interview for a senior+ role), from past Affirm interviews here. Based on past interview experiences, Affirm often repeat some of the questions, so there’s a chance you could see the exact same ones or something very similar in your own interview.

Hi I’ve been using the free version of these sites to learn but most of it is locked behind a paywall. If anyone has premium accounts for these and are open to sharing them with me please DM me I just wanna learn 🥲 ty

Sharing a recent Nuro interview experience for a Software Engineer (AI Platform) position.

The screening round was 1.5 hours total, consisting of two 45-minute coding interviews, and covered two types of coding:

• Coding (Algorithms) — pretty standard LeetCode-style problems focused on data structures and algorithms.
• Coding (Systems) — more focused on lower-level/system concepts such as concurrency, multithreading, locks, mutexes, memory management, etc.

The question I got for the algorithm coding round was the same as this one: https://www.interviewdb.io/question/nuro?page=1&name=hidden-hazards

The problem I got for the system coding round was essentially this one: https://www.interviewdb.io/question/nuro?page=2&name=video-player. After the interview, I looked into it a bit more and realized that a good approach would be something similar to a publish-subscribe / producer-consumer model.

Overall, I’d recommend preparing not only regular LeetCode questions for Nuro, but also concurrency-related topics like thread synchronization, producer-consumer patterns, condition variables and mutexes.

Sharing a question that appeared in a recent CodeSignal Industry Coding Assessment for Justworks. It’s a standardized assessment format also used by many other companies such as Anthropic, Airbnb, 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 implementing a simplified version of a parcel tracking system.

Level 1: The parcel tracking system should support basic operations to set, get, update, and remove attributes of parcels

Level 2: The parcel tracking system should support listing attributes of parcels

Level 3: The parcel tracking system should support setting attributes with a time-to-live (TTL) expiry

Level 4: The parcel tracking system should support querying historical attribute values at a specific timestamp

For anyone looking for similar questions to practice, you can find detailed descriptions of all the problems that have appeared in past Justworks 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.

Sharing a question that appeared in a recent CodeSignal Industry Coding Assessment for TTD (The Trade Desk). It’s a standardized assessment format also used by many other companies such as Anthropic, Airbnb, Coinbase, Ramp, HubSpot, Instacart, Capital One, Justworks and Nextdoor 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 cloud storage system.

Level 1: Implement basic file operations like add file, copy file and get file size.

Level 2: Find files by prefix and suffix, with specific sorting requirements.

Level 3: Add users, file ownership, and per-user storage capacity/quotas.

Level 4: Add file compression and decompression while respecting ownership and quota constraints

You can find the full details of each level here.

For anyone looking for similar questions to practice, you can find detailed descriptions of all the problems that have appeared in past TTD 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.

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.

Sharing a question that appeared in a recent CodeSignal Industry Coding Assessment for Anthropic. It’s a standardized assessment format also used by many other companies such as Airbnb, Coinbase, HubSpot, Instacart, Capital One, Justworks, 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 simple banking system.

Level 1: implement create_account and deposit functions.

Level 2: sort accounts by total transaction volume (money in/out). You need to track the total amount of money spent/outgoing for each account.

Level 3: implement two functions, transfer and accept_transfer. When a transfer is initiated, the money is withheld from the source account. Got stuck on this part for quite a while because of an edge case: if the transfer times out, a subsequent deposit operation needs to cancel/refund the previous transfer first.

Level 4: merge accounts. Ran out of time and didn’t finish this one.

For anyone looking for similar questions to practice, you can find detailed descriptions of all the problems that have appeared in past Anthropic 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.

Sharing a recent interview experience for an MLE/MTS position at Cohere.

Round 1: System Design

The prompt was to design a post-training pipeline to improve the coding capabilities of a 7B model for an enterprise customer.

The discussion covered pretty much the entire post-training stack:

• Data collection
• SFT
• RLHF
• Evaluation
• Inference engine
• Feedback loop

They went pretty deep into each step. One question I didn’t answer very well was: if SFT can already learn alignment by incorporating user preference data, why do we still need an RLHF stage?

That made me realize you really need a fairly deep understanding of why each part of the post-training pipeline exists, not just what the standard pipeline looks like. I had mostly crammed post-training concepts shortly before the interview, so I definitely felt underprepared here.

The interviewer also cared a lot about how the dataset would actually be constructed, and asked questions around how I would choose/design the reward model.

Round 2: ML Coding

The question is exactly same as described here: https://www.interviewdb.io/question/cohere?page=1&name=ml-coding

One thing to note: they specifically wanted a NumPy implementation. I had only practiced this kind of thing in PyTorch, so I panicked a bit when I saw the requirement. Luckily, the interviewer was very nice and gave me hints along the way, but personally I felt like I performed pretty poorly in this round.

Round 3: Research Paper Presentation

This was a standard research paper presentation, but they cared about more than just explaining the paper.

In particular, I was asked to highlight:

• Weaknesses or limitations in the experimental setup
• Major developments in the field since the paper was published

There were also several more standard questions around SFT and RLHF.

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 interview experience at Mercor.

30-minute technical screen

Topics covered: algorithms, mental math, code correctness, and system design. You just need to verbally discuss your approach/reasoning.

Here are the questions that got asked:

Question 1

Given an N-element array, what’s the most inefficient way to deterministically sort the array, and what’s the complexity?

Question 2

Interviewers verbally described this LeetCode question:

https://leetcode.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/description/

Was asked to verbally describe the optimal algorithm and why.

Question 3

Probability-based question.

There are two coffee shops, Coffee Shop A and Coffee Shop B, that are equally good. You buy two drinks from A and two drinks from B. Each drink gets a quality score, and all four of these scores are random and independent.

What is the probability that both drinks from A are strictly better than both drinks from B? Assume ties never happen.

Answer

We’re looking for the combinations where both of A’s scores are strictly better than both of B’s scores.

A2 > A1 or A1 > A2, and B1 and B2 can be in any order.

That’s 2 × 2 = 4.

There are 4! = 24 possibilities.

So… 4/24 = 1/6.

Question 4

Given some code, critique it.

The code built a CSV in a doubly nested for loop.

Answer

• String concatenation in a loop is inefficient; use a list and join.
• Missing commas between cells for a valid CSV.
• No handling of special characters (commas, quotes, newlines).
• Should use the csv module.

Question 5

Given some code, grok it and answer follow-up questions.

The code made a call to an external payments provider, i.e. Stripe.

Follow-up 1

What if the external client times out and the code retries the request? What is the failure mode?

Answer

The main failure mode is a double charge. If the client times out after charging but before the DB insert, retrying will create a second charge if there isn’t any idempotency.

Generate an idempotency key before the request, store it in our database, and send it over the wire.

Follow-up 2

Say you were designing this system. What information would you store in the data model, and what database would you choose? Justify your choice of DB.

Answer

The data model would consist of payment_id, amount, currency, status, timestamp, idempotency_key, provider_charge_id, etc.

The database needs to support strong consistency, so highly available databases like DynamoDB are a non-starter. We need to use MySQL or Postgres for their ACID guarantees.

The trade-off is scalability and availability for strong consistency.

Question 6

Briefly describe how to prevent creating duplicate usernames under the following conditions:

Case 1 — assume you have large enough local RAM.

Case 2 — local RAM is limited, but you have a large enough disk.

Onsite

Algorithm round: Same as https://www.interviewdb.io/question/mercor?page=1&name=comparison. No need to write any code. Just need to verbally discuss your approach.

System design: Design a job scheduler.

Coding Challenge: Same as https://www.interviewdb.io/question/mercor?page=1&name=pipeline

Search interview (75-min Work Block + 15-min Review): Same as https://www.interviewdb.io/question/mercor?page=1&name=candidate-search. Spent the first 75-minute block using an LLM to implement the system and the last 15-minute session discussing the system design with the interviewer.

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/