Confluent Interviews

Recruiter reached out on linkedin.

Phone:

• Given a list of doc and a query string, return which documents contain the query string in it.

Input:

[][]string{
{"this", "is", "world"}, 
{"world", "is", "great"}, 
{"leetcode", "is", "bad"} 
}

query("World") --> should return [0,1] (make sure your search is case insensitve)

follow up:

Search the document where given phrase is present

query("word is") --> should return [1] since it is only present in doc 1

Onsite 1:

• Sudoku validation
• Sudoku completion

Onsite 2:

• Design a queue that support enqueue, dequeue and getRandom() operations.
• Follow up included concurrency.
  What will happen if multiple threads are working together?
  What are the solutions available to support multiple threads?
• Write method to compare two given queues.
  Again, follow ups were about support concurrency in this method.
• Write UTs for the enqueue, dequeue and getRandom(). They just wanted to get idea about UT techniques.

I was asked to run the code (interviewer provided the test cases) in phone screen and 1st onsite. Wasn't asked to run code in 2nd DSA.

Onsite 3: System design

• Create an aggregator that allows podcasts to be registeres and users to subscribe/unsubscribe different podacasts.
• I was asked to write APIs required for it and different HTTP status code that our API can support.
• Make sure you know when to return what http status codes.
  http://en.wikipedia.org/wiki/List_of_HTTP_status_codes

Just go through all the status codes.

• Discussion included what kind of DB should be used. SQL vs NoSQL etc.

Onsite 4: System design

• Create a temp email service with TTL of 5 hours per email
• How to generate unique emails that are not too long.
  My suggestion is to use a redis counter that starts from 1 Billion and then increment it by 1 when a new email is created. The number is not a appropriate email-id so it should be base62 encoded which will convert it into alpha-numeric string. To make it more secure and unpredictable, the service can pick a random adjective from a huge list (5k english words) and append the counter string to it.
• What kind of DB to store the create the emails?
• How will access be denied once the email id expires?
• Discuss Data archival once the emails are expired.

Verdict: Reject. System design feedback was not great.

Interviewers were good and helpful.

My friend referred me at Confluent, and I received a callback from the recruiter within two hours. The interview was scheduled three days later and consisted of three technical rounds followed by one Engineering Value round. The technical rounds were scheduled upfront, and based on their outcome, the engineering value round was set up. After clearing all these, I would move to a team matching round and then receive an offer.

Round 1:
This round started very casually with a discussion about my experience before moving straight to the question. I was asked to design an LRU cache with time-to-live (TTL) functionality. The expected operations included adding new key-value pairs with a timestamp, getting key-value pairs, and efficiently calculating the average of all actively stored values. I clarified constraints and expectations initially, asking questions like whether key-value pairs would be given in strictly increasing timestamps. I began with a simple approach and then optimized it based on various considerations such as memory usage, collision handling, performance (read-heavy vs. write-heavy scenarios), and more.

Round 2:
Again, this round began with a brief introduction and a discussion of my experience before moving to a DSA question. I was tasked with implementing my own logging system. Given a log file, I needed to print the last N lines using file methods of my preferred language (I used Python). The interviewer then asked about optimizing this for scenarios with many lines that need continuous printing to the console. I suggested returning the data line by line, and then byte by byte, to conserve program space. Additionally, I had to print the last N lines in their original file order, not reversed, without storing the entire file in memory.

Round 3:
There was no introduction in this round; we immediately delved into a DSA question. I was given the task of implementing a word search functionality within an array of documents. Specifically, I would receive an array where each item was a document with a unique number and complete data. Given a word, I had to find all document numbers where that word was present. The next step was to optimize this by initializing and creating a processed data store format for efficient searching. To improve it further, I was asked to implement phrase search. After asking some clarifying questions, I proposed a solution. The interviewer specifically requested using a single data store created during the preprocessing step that could serve both word and phrase searches. I proposed an approach for this, but due to time constraints, I couldn't fully implement it.

After one week, I received a call informing me that I had cleared the technical rounds and was moving to the Engineering Value round.

Engineering Value Round:
This round focused on my experience, projects, challenges faced, volunteering efforts, mentorships, and team interactions. There was a lot of grilling, which is expected in such rounds.

Approximately 1.5 weeks later, I got a call confirming that I had cleared all rounds and was moving to team matching.

Team Matching Round:
In this round, the manager asked about my experience and then elaborated on the team's work and culture. I asked many questions about these aspects, and the call went well. Three days later, I received a call indicating they were moving forward with an offer. However, two days after that, I was informed that due to a global hiring freeze, the offer letter would be released once the freeze is lifted.

Sharing my experience going through Confluent’s interview loop for an SDE role. The rounds were a good mix of algorithmic depth, API-level design, and real-world engineering conversations. Here's the full breakdown:

Round 1: Phone Screen (DSA)

Problem:
Given a list of function signatures and a list of input arguments, return all matching functions based on parameter compatibility.

Follow-up:
Extend the solution to handle variadic arguments like Integer... args.
Focus was on type matching and signature parsing.

Round 2: DSA

Problem 1: Check if a given Sudoku board is valid (partial board).
Problem 2: Solve a complete Sudoku puzzle.

Emphasis was on clean recursion, backtracking, and pruning optimization.

Round 3: High-Level Design (Podcast Service)

Topic: Design a Podcast Service with:

• Feed view
• Subscribe/Unsubscribe to podcasts
• Add podcasts and episodes

Note:
No architecture diagram was expected. Focus was on:

• API design (verbs, response codes, headers) - This is key, if you do any mistake they highlight it as if the world has ended.
• SQL queries
• Data modeling

Round 4: High-Level Design (TempMail Service)

Topic:
Design a TempMail generation service where generated emails are valid for 5 hours.

Discussion focused on:

• Expiry mechanism
• Storage strategies
• Access control and validation
• Building sensible mail names

Round 5: DSA / Code Debugging

Problem:
Given an implementation of Quicksort, identify and fix bugs.
Then optimize performance by discussing and applying pivot strategies to reduce the chance of hitting O(n²).

Strategies covered:

• Randomized pivot
• Dual pivot
• Median-of-three approximation

Round 6: Culture & Value Fit

Topics Discussed:

• Going above and beyond to exceed customer expectations
• Taking initiative in challenging situations
• Pushing back on legacy decisions and suggesting improvements
• Mentoring and enabling peers to succeed
• Handling ambiguity and overcoming complexity in large-scale systems

Final Thoughts

Overall it takes more than 2 months. Be patient.

Confluent’s loop is a good blend of:

• Deep technical discussions
• For SSE2, one strong hire is mandatory in design rounds.
• Behavioral rounds that go beyond standard LPs and into actual engineering stories

If you're preparing, focus on clean APIs, SQL/data modeling, and be ready to defend trade-offs.

Verdict: Overall Lean No Hire. I got all strong hires in coding rounds but no strong hire in design round. Though, personally I felt it went well. Apparently a few negatives outweighed a lot of positives. But it is what it is.

YoE: 10.7 Years

My interview process for the Senior Software Engineer (SSE 2) position at Confluent was quite thorough, conducted entirely remotely.

It kicked off with a Phone Screen, where I was tasked with designing a key-value store. This store needed to support put(key, value), get(key), and a unique get_average() function that returned the average of all non-expired values. A key detail was that data would be streamed in order of increasing timestamps, which influenced the expiration logic.

Following that, I had two Coding Rounds. The first focused on searching words and phrases within a list of documents, requiring efficient text processing and search algorithms. The second coding challenge was a classic: validating and solving a Sudoku puzzle, which tested my backtracking and matrix manipulation skills.

The interview then moved into System Design with two dedicated rounds. In the first design round, I was asked to architect a URL shortener. The discussion emphasized scalability, system reliability, strategies for database and cache sharding, and performing resource calculations for metrics like Requests Per Second (RPS), memory usage, and the number of servers required. We also explored the pros and cons of different architectural approaches. The second design round involved a more complex task: designing a system similar to Feedly. Here, the focus was on API design and data modeling, specifically addressing how to handle user subscriptions, unsubscriptions, and the efficient generation of personalized newsfeeds.

Beyond technical skills, there was a Values Round dedicated to behavioral questions. These questions were specifically aligned with Confluent's core values, aiming to understand my fit within the company culture.

Finally, I had a Hiring Manager Round, which felt akin to Google's team match process. We discussed various aspects of teamwork, my personal interests, and my motivations for seeking a role at Confluent.

The overall experience was challenging but engaging, covering a broad spectrum of engineering skills.