Freshworks Coding Interview Questions: OA, LLD & Technical Interview
Freshworks is a Chennai headquartered SaaS company (NASDAQ: FRSH) building customer engagement and IT service products such as Freshdesk, Freshsales, and Freshservice. Its hiring process for fresher and early career Software Engineer roles leans heavily on clean object oriented design in addition to standard DSA, since most of what you will build on the job is application level SaaS product code rather than low level systems.
This guide is organized by interview stage, online assessment, low level design, and technical interview, based on questions actually reported by candidates. Every algorithmic problem includes the exact question, a worked example, the right approach, and time or space complexity, while the design questions are presented as the requirement briefs candidates actually received.
Freshworks Hiring Process for Fresher Roles
1. Application and Eligibility
- B.E./B.Tech, hired mainly through campus placement drives at target colleges, plus an off campus careers page pipeline for open roles.
- CGPA cutoffs are typically applied at the shortlisting stage before the online assessment.
2. Online Assessment (HackerRank) 60 to 90 minutes
- Usually 2 coding problems plus a set of MCQs covering OS, DBMS, OOP concepts, and aptitude or logical reasoning.
- Partial scoring applies, so submitting a correct brute force before attempting to optimize is worth more than leaving a problem blank.
3. Technical Interview 1 (DSA Focus) 45 to 60 minutes
- 1 to 2 DSA problems solved live, combined with questions about your resume, projects, and CS fundamentals such as OOP pillars and DBMS normalization.
4. Technical Interview 2 (Low Level Design Focus) 45 to 60 minutes
- A object oriented design problem, design a system such as a parking lot, library management system, or vending machine, where you define classes, relationships, and key methods, sometimes followed by a small coding task to implement one piece of the design.
5. Technical Interview 3 / Hiring Manager Round (for some roles)
- A deeper project discussion, system level thinking for a small SaaS feature, and questions about how you would prioritize and communicate trade offs.
6. HR Round
- Motivation, culture fit, and logistics such as location and notice period.
Preparation Resources
Part 1 Freshworks Online Assessment (OA) Questions
The OA runs on HackerRank, 60 to 90 minutes, typically 2 coding problems plus MCQs on OS, DBMS, OOP, and aptitude.
1. Group Anagrams by Ticket Category Easy
Given a list of support ticket tag strings, group together every pair of tags that are anagrams of each other, and return the groups.
Input: tags = ["eat", "tea", "tan", "ate", "nat", "bat"]
Output: [["eat","tea","ate"], ["tan","nat"], ["bat"]]
Approach: For each tag, compute a canonical key by sorting its characters or by building a fixed size character frequency signature, then group tags that share the same key using a hash map.
Complexity: Time O(n * k log k) where k is the max tag length · Space O(n * k)
Follow-up: How would you make the grouping key computation faster if tags can be very long?
2. Longest Streak of Active Agent Days Medium
Given an unsorted array of integers representing the days an agent was active, find the length of the longest consecutive run of days, not necessarily contiguous in the array.
Input: days = [100, 4, 200, 1, 3, 2]
Output: 4
Why: the longest consecutive run is 1, 2, 3, 4
Approach: Insert every day into a hash set, then for each day that is the start of a run, meaning day - 1 is not in the set, walk forward counting consecutive days present in the set, tracking the maximum length found.
Complexity: Time O(n) · Space O(n)
Follow-up: How would you return the actual longest streak, not just its length?
3. Minimum Meeting Rooms for Support Calls Medium
Given the start and end times of a set of scheduled support calls, find the minimum number of call lines needed so that no two overlapping calls share the same line.
Input: intervals = [[0,30],[5,10],[15,20]]
Output: 2
Approach: Sort start times and end times separately. Walk through the sorted start times with a pointer into the sorted end times, incrementing a room counter whenever a call starts before the earliest currently active call ends, and decrementing it as calls end.
Complexity: Time O(n log n) · Space O(n)
Follow-up: How would you also report which specific line each call should be assigned to?
4. Ticket Priority Queue Simulation Easy
Given a stream of support tickets arriving with a priority level, process them so that the highest priority ticket, and among equal priorities the earliest arrived, is always resolved next. Return the order in which tickets are resolved.
Input: tickets = [(1,"low"),(2,"high"),(3,"high"),(4,"medium")]
Output: [2, 3, 4, 1]
Approach: Use a max heap keyed on priority, with arrival order as a tiebreaker, pushing each ticket as it arrives and popping the highest priority ticket whenever a resolution slot is free.
Complexity: Time O(n log n) · Space O(n)
Follow-up: How would you support a ticket's priority being upgraded while it is still waiting in the queue?
5. Shortest Path Through a Knowledge Base Graph Medium
Given a set of help articles as nodes and links between related articles as edges, find the minimum number of link hops needed to get from a starting article to a target article.
Input: edges = [["A","B"],["B","C"],["A","D"],["D","C"]], start = "A", target = "C"
Output: 2
Approach: Build an adjacency list from the edges, then run a breadth first search from the start node, tracking the hop count at which each article is first visited, and return the hop count recorded for the target.
Complexity: Time O(V + E) · Space O(V + E)
Follow-up: How would you adapt this if each link had a different traversal cost instead of being a uniform single hop?
6. Balanced Parentheses in a Macro Template Easy
Given a string representing an email macro template containing {{ }}, [ ], and ( ) placeholder brackets, determine whether every bracket is properly opened and closed in the correct order.
Input: s = "{{name}} ([support])"
Output: true
Input: s = "{{name}] ({support})"
Output: false
Approach: Push every opening bracket onto a stack as you scan left to right. On a closing bracket, check that the stack is non empty and that its top matches the corresponding opening bracket, popping it if so, otherwise the template is invalid.
Complexity: Time O(n) · Space O(n)
Follow-up: How would you extend this to also report the index of the first mismatched bracket for a helpful error message?
7. Ticket Pairs Matching an SLA Budget Easy
Given an array of resolution times for open tickets and a target SLA budget, determine whether any two distinct tickets have resolution times that sum exactly to the target.
Input: times = [30, 45, 15, 60], target = 75
Output: true
Why: 30 + 45 = 75
Approach: Walk the array once, and for each time, check whether target minus that time already exists in a hash set of previously seen times. If it does, a matching pair exists. Otherwise add the current time to the set and continue.
Complexity: Time O(n) · Space O(n)
Follow-up: How would you return all such pairs instead of just a boolean, while avoiding duplicate pairs?
8. Merge Overlapping Maintenance Windows Medium
Given a list of scheduled maintenance windows as start and end times, merge every pair of windows that overlap or touch, and return the minimal set of non overlapping windows.
Input: windows = [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Approach: Sort the windows by start time, then walk through them keeping a running merged window. If the next window's start is less than or equal to the current merged window's end, extend the end to the maximum of the two, otherwise close the current merged window and start a new one.
Complexity: Time O(n log n) · Space O(n)
Follow-up: How would you handle windows arriving as a live stream, where you must answer overlap queries before the whole set is known?
9. Design a Recently Viewed Articles Cache Hard
Design a cache of fixed capacity N that tracks the help articles a customer most recently viewed, supporting get(articleId) and view(articleId) in O(1) time, evicting the least recently viewed article when the cache is full.
Input: capacity = 2
view(1) -> view(2) -> get(1) -> view(3) (evicts 2, since 1 was just accessed)
get(2) -> -1 (evicted)
Approach: Combine a hash map from article id to node with a doubly linked list ordered by recency. On get or view, move the accessed node to the front of the list. When the cache exceeds capacity, evict the node at the back of the list and remove it from the map.
Complexity: Time O(1) per operation · Space O(N)
Follow-up: How would you make this cache thread safe for concurrent reads and writes from multiple request handlers?
Part 2 Freshworks Low Level Design Round
The second technical interview at Freshworks commonly shifts from pure DSA to object oriented low level design, reflecting the fact that day to day engineering work is building and extending SaaS product features. You are expected to identify entities, define classes with clear responsibilities, and model relationships, then often implement one core method live.
10. Design a Support Ticket Assignment System Hard
Design a system that assigns incoming support tickets to available agents, where each agent has a skill set and a maximum concurrent ticket capacity, and each ticket requires a specific skill to be resolved.
Discussion points: how agents advertise skills and capacity, how a ticket is matched
to an eligible agent, and what happens when no agent is currently available
Approach: Model Agent with a skill set, current load, and capacity, and Ticket with a required skill and status. An AssignmentService maintains a pool of agents indexed by skill, and on a new ticket, filters agents who have the required skill and spare capacity, then picks one using a strategy such as least loaded first, updating both the ticket and the agent's load.
Complexity: Time O(k) per assignment where k is the number of agents with the required skill · Space O(n + m) for n tickets and m agents
Follow-up: How would you extend the design to support ticket escalation to a senior agent if it is not resolved within an SLA window?
11. Design a Parking Lot System Medium
Design a multi level parking lot that supports different vehicle sizes, such as motorcycle, car, and truck, assigns the nearest available suitable spot on entry, and computes a fee based on duration on exit.
Discussion points: how spots of different sizes are tracked per level, how the
nearest available spot is found efficiently, and how the fee calculation is kept
independent of the spot allocation logic
Approach: Model Spot with a size and status, grouped per Level, and a Vehicle hierarchy or type field indicating the smallest spot size it needs. A ParkingLot class exposes parkVehicle and unparkVehicle, delegating spot search to each level in order and delegating fee computation to a separate FeeStrategy so pricing rules can change independently of allocation.
Complexity: Time O(L) per park/unpark where L is the number of levels, using a free-spot index per size per level · Space O(total spots)
Follow-up: How would you support a vehicle that can fit in a spot meant for a larger size when no exact size spot is free?
12. Design a Rate Limiter for the Freshworks API Medium
Design a per customer API rate limiter that allows at most N requests in any rolling W second window, and rejects requests beyond that limit.
Input: limit = 3 requests per 10 seconds, requests arrive at t = 1, 2, 3, 4
Output: first 3 requests allowed, the 4th at t = 4 rejected since 3 requests
already occurred within the last 10 seconds
Approach: Maintain a per customer deque or sliding window counter of recent request timestamps. On a new request, evict timestamps older than W seconds from the front, then allow the request only if fewer than N timestamps remain, appending the new timestamp if allowed.
Complexity: Time O(1) amortized per request · Space O(N) per customer
Follow-up: How would you make this rate limiter work correctly across multiple server instances instead of a single process?
13. Design a Webhook Delivery System With Retries Hard
Design a system that delivers webhook events, such as "ticket created" or "ticket resolved", to customer configured URLs, retrying with exponential backoff on failure and giving up after a maximum number of attempts.
Discussion points: how a failed delivery is scheduled for retry without blocking
new events, how backoff delay is computed per attempt, and how a permanently
failing endpoint is surfaced to the customer
Approach: Model an Event and a per customer WebhookSubscription holding the target URL. On dispatch, enqueue a DeliveryAttempt onto a worker pool. On failure, compute the next delay as a function of the attempt count, for example doubling each time up to a cap, and re-enqueue onto a delayed queue rather than retrying inline, so one slow endpoint cannot block delivery to others.
Complexity: Time O(1) to schedule a delivery, independent of other subscriptions · Space O(pending deliveries)
Follow-up: How would you prevent a single misbehaving customer endpoint from starving delivery workers needed by every other customer?
14. Design an SLA Escalation Timer System Medium
Design a system where every ticket has an SLA deadline, and when a ticket crosses its deadline without being resolved, it is automatically escalated to a senior agent and relevant observers, such as a dashboard or a notification service, are informed.
Discussion points: how deadlines are tracked without polling every ticket
constantly, how multiple observer types are notified without coupling the timer
logic to each observer's implementation, and what happens if a ticket is resolved
just before its deadline fires
Approach: Track pending deadlines in a min-heap keyed by deadline time, so the soonest deadline is always at the top. A background scheduler pops and processes any deadline that has passed, checking the ticket's current status before escalating, since it may have been resolved since being scheduled. Notification uses the observer pattern, an EscalationEvent is published, and each subscriber, dashboard, notification service, handles it independently.
Complexity: Time O(log n) per deadline insert or removal · Space O(n) for n pending tickets
Follow-up: How would you handle a ticket's SLA deadline changing after it was already scheduled, for example if its priority was upgraded?
Part 3 Freshworks Technical & HR Interview Questions
Beyond DSA and design, Freshworks interviewers consistently probe CS fundamentals and product sense, since the role is building a live SaaS product used by real customers.
Systems and CS Fundamentals Focus Areas
Real questions reported by candidates in the technical interview rounds:
- Explain the four pillars of OOP with an example from a project you built.
- What is database normalization, and walk through 1NF, 2NF, and 3NF with an example schema.
- What is the difference between a process and a thread.
- What happens internally when you type a URL into a browser and press enter.
- How would you design a database schema for a support ticketing system with agents, tickets, and customers.
- What is the difference between SQL joins, inner, left, right, and full outer, with examples.
- How does indexing improve database query performance, and what is the trade off.
- What is REST, and what makes an API RESTful.
- How would you handle a situation where two team members are editing the same ticket at the same time.
- Walk through a bug you found in production, how you diagnosed it, and how you fixed it.
HR Interview Tips
The HR round checks motivation, culture fit, and logistics. Common questions include:
- Tell me about yourself.
- What do you know about Freshworks and which of its products have you used or explored.
- Why do you want to work at a SaaS company specifically.
- Where do you see yourself in five years.
- What are your strengths and weaknesses.
- Describe a time you had to learn a new technology quickly for a project.
- Are you comfortable with the notice period and location requirements for this role.
Preparation Tips
- Do not stop at DSA. Freshworks interviews weigh object oriented low level design, designing classes for a parking lot, ticketing system, or rate limiter, just as heavily as algorithmic problem solving in the later rounds, so practice sketching class diagrams under time pressure.
- Revisit OOP and DBMS fundamentals. Normalization, joins, indexing, and the four pillars of OOP come up consistently, even for fresher roles, since the day to day work is building SaaS product features on top of a relational database.
- Practice explaining trade offs out loud. Design rounds reward reasoning about alternatives, such as least loaded versus round robin agent assignment, not just arriving at one working answer.
- Know the product. Freshworks interviewers often ask what you know about the company's products such as Freshdesk or Freshservice, so spend real time exploring the product before your interview.
Join our Telegram group to discuss more Freshworks interview questions and prep strategies!