Confluent · Phone screen → Onsite
In processConfluent Concurrency Interviews: 28 Experiences (Part 1 of 2)
Confluent concurrency interviews, 2023–2026: thread-safe queues, caches and windowed maps, with locking follow-ups after a working implementation.
At a glance
- Process: a qualifier or phone screen mixing DSA with concurrency, then onsite coding rounds where at least one is about concurrency, plus design and behavioral rounds; coding rounds ran about an hour (entries 02, 08).
- Asked recently: a random-access queue made safe for many threads (2 of 10, entries 01, 03); a windowed key-value map with concurrent puts or reads (2 of 10, entries 06, 09); locking follow-ups in 3 of 10.
- Difficulty: one candidate called the underlying DSA mostly medium, with the concurrency rules making it harder in the time (entry 02); a campus candidate could not finish a pool from scratch (entry 10).
- Practise first: Random-Access FIFO Queue, Windowed Key-Value Map and LFU Cache with Thread-Safety Follow-Up.
Coverage: Software engineering interviews from campus hiring through Senior and Staff. This part holds 10 current reports (October 2023–Q1 2026; India or remote India where stated) and 6 reports from 2022 in History. Part 2 holds 12 earlier reports.
In this Confluent collection
- Question collection: 33 coding, system design and OOD questions from 2018–2026.
- File manipulation round: 19 reports on
tail -n, file APIs and memory limits. - OA, coding and design supplement: 19 reports on assessments, search, design and behavioral rounds.
- Concurrency Part 1 (current): the 10 current concurrency reports and 6 from 2022.
- Concurrency Part 2: 12 earlier reports, including scheduler and cache details.
What came up
The recent reports moved away from the delayed-task scheduler that dominated 2021–2022 (see History) toward queues, caches and maps with a thread-safety follow-up. In most of them the candidate first wrote a working single-threaded version, and the concurrency talk came after.
| Topic | Reports | Last seen |
|---|---|---|
| Cache or windowed-map concurrency follow-ups | 3 of 10 | Dec 2024 (report date) |
| Locking questions (synchronized, read-write, optimistic) | 3 of 10 | Oct 2024 |
| Concurrent queue and queue comparison | 2 of 10 | Q1 2026 |
| Concurrency inside a system design | 2 of 10 | Q3 2025 |
| Dedicated LLD round with multithreading | 1 of 10 | Jan 2026 |
| Round label that did not match the task | 1 of 10 | Q2 2024 |
| Parallel file processing | 1 of 10 | Q4 2023 |
| Pool implementation | 1 of 10 | Oct 2023 |
Questions we found
Concurrency coding and LLD
| Question | Reports | Last seen |
|---|---|---|
| Random-Access FIFO Queue | 2 | Q1 2026 |
| Implement a pool from scratch (pool type not stated) | 1 | Oct 2023 |
Algorithms / Data Structures
| Question | Reports | Last seen |
|---|---|---|
| Windowed Key-Value Map | 2 | Oct 2024 |
| LFU Cache with Thread-Safety Follow-Up | 1 | Dec 2024 (report date) |
| Doc ID exercise in three parts | 1 | Q2 2024 |
| Implement tail -n, with a parallelization follow-up | 1 | Q4 2023 |
System Design
| Question | Reports | Last seen |
|---|---|---|
| Temporary email service: concurrency and schema | 1 | Q3 2025 |
| URL shortener: same long URL, same short code | 1 | Nov 2024 |
10 detailed candidate timelines
01: a random queue, concurrent comparison and compressed runs
Interview date: Q1 2026 (report date April 3, 2026) · Role: Senior SDE2 · Result: Not stated
Second coding round
- A queue that can return a random element. The report does not say whether the random operation removes the item.
- Follow-ups: compare two queues, handle multithreaded access, and compare queues stored with variable run-length encoding.
02: a dedicated LLD round with multithreading
Interview date: January 2026 (report date April 9, 2026) · Role: Senior Software Engineer · Location: India · Result: Withdrew before team matching (preferred other offers)
- A qualifier that combined coding with concurrency.
- Later, a dedicated LLD round on concurrency and multithreading; the exact task was not recalled. The candidate felt intermediate concurrency knowledge was expected.
- Coding rounds lasted about an hour including introductions and questions. The DSA was mostly medium; the concurrency requirements made it harder to finish in time.
03: a queue, then comparison while other threads act
Report date: July 20, 2025 · Role: Senior Software Engineer 2 · Experience: 7.5 years · Location: remote, India · Result: Rejected (feedback pointed at system design)
Second onsite coding round
- A queue with enqueue, dequeue and random inspection.
- What happens when several threads use it, and how to support them.
- A method to compare two queues, then concurrent access during the comparison.
- Unit tests for enqueue, dequeue and
getRandom. Code had to run in the phone screen and first onsite, but not in this round.
04: concurrency inside a temporary-email design
Interview date: Q3 2025 (report date July 11, 2025) · Result: Not stated
System design
- A temporary email service. The candidate first treated it like TinyURL, then realized the interviewer wanted a different focus. Concurrency and the database schema came up; the round ended with about 15 minutes left.
05: an LFU-like cache with an optional thread-safety step
Report date: December 17, 2024 · Role: Senior Software Engineer · Experience: 5 years · Result: Pending
Fourth round
- An LFU-like cache; make it thread-safe if time remains. The interface, tie-break and locking approach were not described.
06: concurrent puts, then duplicate short URLs
Interview date: October 21 and November 5–7, 2024 (report date November 21, 2024) · Result: Not stated
Phone screen
- A windowed map, then several threads calling
putat once. The candidate discussed JavasynchronizedandReadWriteLock.
System design
- A URL shortener where concurrent requests for the same long URL must not create different short codes; duplicate codes and coordination came up. The candidate's preparation tip mentioned distributed locking.
07: a "concurrency" round that was a Doc ID exercise
Interview date: Q2 2024 (report date June 11, 2024) · Result: Not stated
Second coding round
- The recruiter called it a concurrency round, but the candidate got the familiar three-part Doc ID exercise. Neither the parts nor any threading requirement were described.
08: locking questions after a runnable qualifier
Report date: May 16, 2024 · Role: Senior Software Engineer · Result: Offer
Qualifier (CoderPad)
- A combined DSA and LLD task (not named) that had to be implemented and run, then follow-ups on time complexity and concurrency, especially locking.
- All rounds were on CoderPad; the candidate used Java. Testing meant calling the code with expected outputs and assertions, and every round had follow-ups on approach, testing and tradeoffs.
09: read-heavy locking and a parallel-file follow-up
Interview date: Q4 2023 (report date November 15, 2023) · Result: Not stated
Phone screen
- A timed-window map. To make
getfaster, the candidate moved cleanup intoputandgetAvg. - Follow-up: concurrent access with 100 reads per write, which led to optimistic locking. The code itself did not need to be concurrent.
Onsite
- tail -n on a static file, then performance, edge cases and parallelization: a huge file with small output, huge output, and a last line with or without a newline.
10: a campus round asking for a pool from scratch
Interview date: October 2023 · Role: Software Engineer, full-time, campus hiring · Result: Not stated
Concurrency round
- Implement a pool from scratch, explain the reasoning and work through hints. The report says only "pool", not which kind. The candidate proposed a solution but did not reach the complete, optimal version the interviewer wanted.
Patterns across the reports
- Working code first, threads second. In entries 03, 05, 06 and 09 the concurrency question came as a follow-up to a working single-threaded solution; entry 09 says the code itself never had to be concurrent.
- Round names are unreliable. Entry 07's "concurrency" round was a Doc ID exercise, while entry 02 got a separate LLD round on multithreading.
Common questions
What is the Confluent concurrency round?
In the current reports, a coding task such as a queue, cache or windowed map, followed by questions on making it thread-safe: locks, read-write locks or optimistic locking (entries 01, 03, 05, 06, 09).
Does Confluent still ask the delayed task scheduler?
It was the most common concurrency task in 2021–2022 (History, H12–H16), but none of the ten reports since October 2023 names it.
Do you have to run your code in Confluent interviews?
Usually yes: code ran on CoderPad with assertions (entry 08) and in the phone screen and first onsite (entry 03), though entry 03's queue round did not require it.
How long is a Confluent coding round?
About an hour including introductions and questions (entry 02).
History (before 2023)
Six 2022 reports, mostly the thread-safe delayed scheduler. They stay out of the counts and tables above.
H11: a Python concurrency round built around a job scheduler
Report date: November 14, 2022 · Role: SDE-2 · Result: Not stated
- Qualifier, then concurrency programming, DSA and high-level design, then behavioral. The concurrency round: program a job scheduler and handle concurrency, with requirements clarified through questions; a working implementation was expected. The interface was not given.
H12: replacing polling with a timed condition wait
Interview date: Q3 2022 · Language: Python · Result: Not stated
- The delayed scheduler with
threading.Condition, timed waits and a priority queue: adding a job notifies the scheduler; a due job goes to a pool, otherwise it waits until the earliest job's time. The interviewer asked the candidate to replace their first polling version with this wait.
H13: locks and a priority queue were part of the ask
Interview date: Q3 2022 · Result: Not stated
- A third onsite called concurrency coding: a delay scheduler built from locks and a priority queue.
H14: a Staff loop with a concurrent cache and a timed scheduler
Interview date: May 2022 · Role: Staff · Experience: 11 years · Result: Offered a Senior downlevel after failing the API-design round; declined
- An LRU-like cache with concurrent reads and writes, focused on locking.
- An in-process scheduler that runs tasks at their scheduled times, with race-condition and timing follow-ups.
H15: two onsite rounds with multithreading
Report date: April 3, 2022 · Role: L5 · Experience: 7.5 years · Result: Rejected (attributed to the API/networking design round)
- Two screens and five onsites; one onsite on problem solving and multithreading, another on concurrency and job scheduling, both needing an implementation. The tasks were not given.
H16: thread-safe scheduling with Python tests
Interview date: Q1 2022 · Language: Python · Result: Not stated
- A thread-safe JobScheduler with test cases; time went to explaining Python to an interviewer who did not use it. The API was not given.
Keep practicing
- Current concurrency tasks: Random-Access FIFO Queue (entries 01, 03), Windowed Key-Value Map (entries 06, 09), LFU Cache with Thread-Safety Follow-Up (entry 05), Implement tail -n (entry 09).
- Designs: temporary email service (entry 04) and idempotent URL shortener (entry 06).
- From History: Thread-Safe Delayed Task Runner (H12–H14) and LRU Cache with Concurrency Follow-Up (H14).
- Confluent question banks: algorithms and system design (sign-in needed).
- Everything Confluent in one place: the Confluent interview page and Confluent hiring insights.
- More firsthand reports: the Experience feed.
In this Confluent collection
- Question collection
- File manipulation round
- OA, coding and design supplement
- Concurrency Part 1 (current)
- Concurrency Part 2
Sources: Anywhere useful interview info can be found.
Comments
0No comments yet — be the first to share what you know.