Freshworks Interviews

I recently interviewed for a Senior Software Engineer position at Freshworks, a role I applied for via a referral. My interview process consisted of three main rounds.

The first round was a DSA round where I was given two LeetCode problems: Find Peak Element and Search in Rotated Sorted Array. I successfully solved both problems. After a slight delay due to headcount calculations, I received positive feedback and moved to the next stage.

The second round, surprisingly, wasn't a pure LLD as expected. It began with a detailed resume deep-dive where the interviewer questioned my technology choices, system design decisions, and complex projects. Towards the end, I was given another coding question, Word Search, which I solved efficiently. The feedback was very positive, leading directly to the hiring manager round, skipping HLD.

Finally, the third round was a brief Hiring Manager (Director) discussion. It was a casual conversation about my interests and their expectations, lasting only about 15 minutes. Within minutes of this call, I received confirmation of an offer.

I had a comprehensive interview experience at Freshworks for an IC2 - SSE role, spanning four rounds.

Round 1: DSA
The first round focused on Data Structures and Algorithms. I was asked to solve two problems:

1. Finding the nearest smaller element to the left. I discussed both brute-force O(N^2) and stack-based O(N) approaches.
2. Reversing the first K elements of an array. I solved this using a two-pointer approach with in-place swaps in O(K) time.

Round 1: Data Structures & Algorithms

This round focused on Data Structures and Algorithms. I was asked to find the nearest smaller element to the left, which I solved by discussing both a brute-force O(N²) approach and an optimized O(N) solution using stacks. The second problem involved reversing the first K elements of an array, which I efficiently solved using a two-pointer approach with in-place swaps, achieving O(K) complexity. Throughout the round, I made sure to think out loud, consider all base cases and constraints, and perform dry runs.

Round 2: Design + Data Structures & Algorithms

The second round began with my introduction and questions about my current project's architecture. For the DSA part, I tackled the LeetCode problem 'Minimum number of days to disconnect island'. This was a very tough question, and the interviewer was helpful in guiding me through the approach. We then transitioned into a design discussion on Rate Limiting, a topic I had experience with, having implemented it using Redis and Lua. There were also several general questions on technologies like Spring, Java, Kafka, API servlets, and web servers.

Round 3: High-Level Design (HLD) / Low-Level Design (LLD)

This round also started with an introduction and questions about my project architecture. I elaborated on my three major contributions, including how I incorporated AI. Specific technical questions included how I managed latency to a PostgreSQL database (I explained connection pooling) and how I achieved stickiness and high availability (discussing consistent hashing). The main design challenge was to design and implement an application for URL scrapping, where a client provides a source URL and a depth, and the system needs to return a list of URLs up to that depth, with a potential max depth of 100K. I focused on taking proper functional and non-functional requirements and designing the APIs. Initially, I started thinking of a backtracking approach, mistaking it for a DSA problem, but the interviewer was very friendly and helped me with all the questions I had for the design.

Round 4: Hiring Manager

The final round was with the Hiring Manager, focusing on my previous experience and general behavioral questions.

Round 1: Data Structures & Algorithms

This round was taken by a lead software engineer and focused mainly on DSA. I was asked about my current work and to provide an example for meta-information of a report, as my team deals with reporting.

• Given a set of intervals representing meeting start and end times, I had to determine if a person could attend all meetings. I was then asked to refactor my code, specifically to decrease the number of lines by moving my custom comparator into lambda expressions.
• I was asked to find the maximum subarray sum.

Round 2: System Design

A week later, I had the System Design round with another lead software engineer. This round included some questions based on my current team and how I spend a day at my company.

• I was asked to explain how Authentication and Authorization work.
• The interviewer asked about the difference between PATCH and PUT HTTP methods.
• We discussed sharding: what it is, its usefulness, the 'celebrity problem,' and how to handle changes in the number of servers.
• I had to differentiate between partitioning and sharding.
• The discussion moved to indexing: how it helps in query optimization and its internal workings.
• I was asked if I review PRs and how I provide review comments to colleagues.
• The interviewer presented a scenario of facing a 504 gateway timeout and asked about potential causes, troubleshooting steps, and solutions.
• I was asked to design a high-level architecture for a WhatsApp-like chat system. I wasn't thoroughly prepared for system design, but I talked about websockets and message queues for notifications. He then asked me to look deeper into how websockets work.

Round 3: Managerial Round

Another week later, I had the managerial round with a staff engineer. We discussed query optimizations, why Redshift was chosen over PostgreSQL in my current team's architecture, and a shard migration tool I had worked on.

• The core question was to design a web scraper given a start URL and a level 'n' until which URLs need to be scraped, returning a list of all scraped URLs. I initially proposed a simple HLD where requests are processed synchronously by hitting URLs, downloading data, and processing recursively. However, the interviewer was not satisfied, pointing out its limitations for very large depths (e.g., billions). I then suggested using a Message Queue with client requests as producers and worker threads as subscribers to process results asynchronously. For responses, I thought of using a storage like Amazon S3, providing pre-signed URLs to the client's email. When asked about status updates without email, I suggested a UI logs page to show 'Queued / IN_PROGRESS / SUCCESS / FAILED' statuses. He then presented a follow-up: what if a worker thread processing 1 million requests crashes after processing 0.5 million? I explained that we could run NFRs to determine a threshold level for crashes, use that threshold to set breakpoints or checkpoints to store partial results, and maintain meta-information about the request. If a failure occurs, we would resume processing from the last successful checkpoint.

I had applied in April, and the recruiter reached out to me in July when there was a vacancy. I wasn't very prepared but wanted to interview, so I went ahead. The interview process took place in August 2025.

Round 1 was conducted by an SSE with over 7 years of experience. It started with a basic introduction and then moved on to tree-related problems like maxDepth, leftView, and topView. I wrote the code on an online compiler, and the interviewer asked me to open and run it on LeetCode, which was a funny moment when I saw the solution cached and had to quickly erase it.

Round 2 was with an SSE having over 6 years of experience. It included an introduction, general questions about my current product, and follow-up queries on its workings. The main technical question was designing an LRU cache, which I discussed in detail, starting from the brute force approach and optimizing it. The interviewer was very friendly and helped me correct my mistakes during the coding process.

Round 3 was with a staff member having over 10 years of experience and lasted about 90 minutes. It started with a self-introduction and moved to explaining the high-level architecture of my current product. There were follow-up questions on my resume, including my experience with monitoring tools like Grafana, rate limiting, multithreading issues, and Redis. I also discussed my contribution to migrating to JDK17 and my work with Jenkins. However, the interview took a turn for the worse when I struggled with an SQL inner join query and had doubts about the database design for a feed and notification system in an application like Quora or Medium.

The interview ended with the recruiter providing feedback that the third round wasn't good, pointing out the issues the interviewer mentioned. The candidate felt that having thorough knowledge of the current project is crucial, and that chasing hard problems isn't necessary for FreshWorks. Preparation for common medium-level problems, good system design knowledge, and understanding the product/tech stack are more important.

Sharing my freshworks interview experience for the LC family that helped me to get this offer.

YOE: 3Years
Curr Org: Service Based
Curr CTC: 7+
Loc: Chennai

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Round 1: Rapid Fire Questions on backend dev + DSA
This round went for around one hour where the interviewer drilled the projects that I worked and the capstone project that I made from College days to now. Interviewer was very techy and he knows what he is asking.

after 40 mins of drilling down each and every work, he moved for a DSA question. I could able to solve it in given 15 mins of time.

Similar to this Q: https://leetcode.com/problems/longest-substring-without-repeating-characters/description/
FEEDBACK: Strong Hire

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Round 2: Project Work + DSA + System Design
This round was supposed to have LLD but interviewer went with two DSA quest in the start and then later moved to asking question on project that I am currently working on.

Q1: https://leetcode.com/problems/longest-increasing-subsequence/description/

Q2: https://leetcode.com/problems/merge-two-sorted-lists/description/

Later he asked a common question on LLD 'To Design a LRU CACHE'

FEEDBACK: Strong Hire

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Round 3: Project Work + DSA + HLD
This round started with asking basic Java and backend related question and went in depth of asking architecture of working project.
He later drilled on the HLD components. Later then interviewer asked a common leetcode question. Post to which he seemed happy and this was the best of all rounds.
Q: Container with Most Water

FEEDBACK: Strong Hire
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

VERDICT: SELECTED

Interview Context

I appeared for a Data Scientist role at Freshworks in January 2025. I had 3.5 years of industry experience as a Data Scientist in a mid sized company. The first round was a technical round consisting of two coding questions and a set of ML + NLP theoretical questions.

Below are the questions I was asked:

🔹 Q1: Simulate a Two-Die Casino Game

Problem Statement: You are working for a casino and need to simulate a two dice game. Write a function that simulates the sum of rolling two six-sided dice, but you are only allowed to use one random function.

Constraints: • Use only one call to a uniform random function like random.randint(1, 6). • Return values should range from 2 to 12, with correct probability distribution.

Follow up: Avoid multiple calls to random function

🔹 Q2: Maximum Minimum Thickness of Slab

Problem Statement: You’re given an m x n matrix, where each cell holds the thickness of a slab. You need to move from the top-left cell (0, 0) to the bottom-right cell (m-1, n-1), moving only right or down.

The goal is to maximize the minimum thickness encountered along the path.

Input:
[
  [5, 1, 7],
  [4, 8, 5],
  [2, 3, 9]
]

Output: 4
Explanation: Path = [5 → 4 → 8 → 5 → 9], minimum along path = 4

🔹 Recommended Practice (as per HR):

• Number of Islands (Graph traversal / DFS-BFS problem): https://leetcode.com/problems/number-of-islands/description/

🔹 ML / NLP Theory Questions:

1. What is a reranker?
2. Difference between Bi-Encoder and Cross-Encoder?
3. How is BERT different from GPT?
4. What are activation functions used for?
5. What is regularization and why is it important?

Update:

Second Coding question was not very easy, I could discuss the approach only.

Round 1 DSA

1. 3 Sum like problem, without using maps.
2. diameter of a tree

Round 2 Design

Quick intro and questions from the resume.

API's for Government site where admins can create forms and citizens can fill and submit forms.

1. API for form creation.
2. API and ways to dynamically process the forms.
3. API to filter fields and give response to the admins
4. DB schemas i.e., tables and columns to store above data.

I answered majority of the points discussed. Wish me luck for the outcome.

Waiting on response.

First Round

Got 2 DSA questions. You should be able to solve them if you are comfortable with the Blind 75 problems.

Second Round

Asked me to design a Low-Level Design (LLD) for a file parsing and storage service. The system should dynamically handle any type of file and store it in different storage services. We were expected to use the Strategy Design Pattern for this.

Given a Logger class with methods start(requestId, startTime), end(requestId, endTime), and log(). The requirement was to log the requestId only after it has ended, and the logging should happen in the order of their startTime.

Given an array, find all possible combinations of numbers that sum up to a given total.

Asked to write code for LFU (Least Frequently Used) cache.

Third Round

I was asked to design an Audit Log System. The discussion went well, and I initially thought I would be selected. However, after following up with the HR, I was informed that I received negative feedback. The HR mentioned that I did not perform well in requirement gathering.

Before the interview, another HR had advised me to drive the interview by asking questions and gathering requirements. I realize now that I should have asked more clarifying questions and taken more ownership of the discussion. This was a learning for me.

I am currently looking for a new opportunity as my current company asked me to resign. If you know of any openings or could offer a referral, it would be greatly appreciated. Thank you for your support!

Application :

No referral.

I had initially applied for the role through LinkedIn using the "Easy Apply" option, filling in the necessary details. The following week, a recruiter reached out to me to confirm my availability for face to face interviews.

Interview Mode :

Face to Face 4 Rounds in total.

Interview :

Round 1 : [Technical]

• Basic introduction.
• Basic discussion on my current job role & responsibilities.
• Data structure and algorithms. 169 - Majority Element and 545 - Boundary Of Binary Tree (Easy-Medium). Expected solution needed to be time and space optimized.

Verdict : Selected for the next round.

Round 2 : [Technical]

• Basic Introduction.
• Basic discussion on my current job role & responsibilities.
• Basic questions on Java.
• Basic questions on OOPS concept.
• Basic questions on multi-threading.
• Basic design pattern and architecture questions.
• Intermediate questions regarding databases (Indexing, sharding & partitioning).

Verdict : Selected for the next round.

Round 3 : [Bar Raiser]

• Basic Introduction.
• Intermediate questions regarding databases (Indexing, sharding & partitioning).
• Low level discussion on databses and its use cases on real world systems.

Verdict : Selected for the next round.

Round 4 : [Hiring Manager Round]

• Basic Introduction.
• Deep dive into my current job role & responsibilities.
• Tons of behavioral questions.

Verdict : Selected (HR informed me within 2 day).

Compensation Details :

• PayPal & Freshworks.

My interview journey at Freshworks for a Lead Software Engineer- BackEnd position was thorough, consisting of five distinct rounds.

Round 1: Technical Interview

The first interviewer was very friendly. We started with a discussion about my previous experience and projects. Following this, we touched upon a few system design concepts. For the Data Structures and Algorithms part, two questions were asked. One was a relatively easy problem, and the other was a classic LRU cache design and implementation.

Round 2: System Design

This round again began with a deep dive into my past experiences and project discussions. The core task was to design a social media platform similar to Facebook. We had an extensive discussion covering Functional Requirements (FR), Non-Functional Requirements (NFR), database design choices, and API creations. The interviewer thoroughly explored various concepts and we discussed the trade-offs for each proposed approach.

Round 3: Bar Raiser Round

The interviewer in this round was also friendly. They inquired about my existing projects and their High-Level Design (HLD), prompting discussions on potential improvements. I was then given a specific scenario for which I had to design a database, discuss the trade-offs of my design choices, and write the necessary SQL queries. Another DSA question followed, which was a variation of the famous 'Buy and Sell Stocks' problem from LeetCode. Additionally, I faced questions related to multi-threading and Spring Boot.

Round 4: Hiring Manager Round

This was a relatively casual discussion, with not much focus on deep technical aspects.

Round 5: Cultural Fit Round

The final round focused on cultural fit. I was advised to be well-prepared for this round, as many candidates are reportedly rejected at this stage. Overall, the interview process went well for me, and I was fortunate enough to receive an offer from Freshworks.

My interview journey for the Lead role at Freshworks comprised five distinct rounds. The first round was a coding assessment where I tackled two questions, one involving array manipulation and another focused on implementing a rate limiter. Following this, I progressed to a Low-Level Design (LLD) round. The third round was a 'Bar Raiser' discussion, which centered around designing a Cache System. After that, I participated in a High-Level Design (HLD) round, and my final interaction was with the Hiring Manager.

Background

I applied for an SSE position at FreshWorks in Bangalore. I currently work at a product-based fintech company and have 4.9 years of experience, having graduated from a Tier-3 college.

Round 1: Technical (1 hour)

This was a coding round that began with my brief introduction and a discussion about the projects I had worked on. I was asked two coding questions:

1. A rephrased version of Two Sum: Given prices of N items and X amount of money, I needed to find if I could buy exactly two items that fully utilize the given money.
2. A variation of the Coin Change problem (specifically Coin Change 2): Given an unlimited supply of coins with values 1, 2, and 3, and a target sum, I had to find the number of ways to make the sum, focusing on permutations. For example, for sum = 4, the output should be 7, with ways like [1,1,1,1], [1,1,2], [1,2,1], [2,1,1], [2,2],[3,1],[1,3].

I was able to successfully solve both questions, and the feedback from this round was positive.

Round 2: System Design (1 hour 30 minutes)

This round focused on system design, but also included some general technical questions. It started with a discussion about my roles and responsibilities at my current company. I was also asked to explain three complex technical issues I had worked on. The system design questions included:

1. Designing a system similar to RedBus, specifically limiting the discussion to Search and Seat Booking functionality. We discussed high-level design, API design, database design, and handling race conditions during seat booking.
2. Designing the trending page of a video platform like YouTube.
3. How to prevent DDoS attacks.
4. Steps to take if all requests to an endpoint are giving errors.
5. How to identify the root cause when only some requests are intermittently erroring out.

I received positive feedback for this round as well.

Round 3: Bar Raiser Round (1 Hour 30 Minutes)

This round involved discussions on various technical aspects, mostly open-ended questions where the interviewer was interested in my thought process and problem-solving approach. Some of the questions I remember were:

1. Implementing connection pooling.
2. A detailed discussion on the TLS layer.
3. Discussion on Spring Boot's advantages and the internal implementation of some Spring annotations.
4. How metrics are sent from an application.

While I answered the questions, the interviewer was not entirely satisfied with some of my responses. I did not hear back from HR after this round, and based on the interviewer's feedback at the end, I understood that I would likely be rejected.