Zeta SDE-1 Backend: 2025 Three-Round Account

The 3-round Zeta SDE-1 backend loop, as reported

This breakdown is based on a single GeeksforGeeks contributor's account last updated in July 2025. The candidate applied through a referral. The source does not identify the interview date, team, compensation, or a company-wide hiring policy, so its evidence must stay attached to this loop.

The candidate reported no online test in this process. The first talent-acquisition call came after almost one week, and the interviews began after almost another week. The source offers no valid comparison with other companies and no promise that another candidate will receive the same timeline.

Round 1 was a DSA and problem-solving round. The interviewer explicitly asked the candidate to start with a brute-force approach and state time and space complexity before optimising. Two questions were asked. The first was counting ways to partition a set into k subsets, which the candidate described as hard and solved with backtracking optimisation. The second was finding a sorted subsequence of size three in linear time; the candidate reportedly began at quadratic time, improved it with a prefix array, and then removed the extra space. The source records this progression but does not publish the scoring rule behind it.

Round 2 was conducted by an interviewer identified in the source as an SDE 2. It opened with a project discussion, then covered multithreading and JavaScript topics from the candidate's projects: Node concurrency, the event loop, and async and await versus promises. The design task was an LFU cache, beginning with get and put logic and continuing to the complete class. Other questions covered CAP, TCP/IP and UDP, ACID, race conditions, and thread synchronisation.

Round 3 was a fitment round. It mixed Java OOP questions including overloading versus overriding, functional interfaces, access specifiers, abstract classes versus interfaces, the super, static, and final keywords, and constructor rules, with SQL versus NoSQL tradeoffs and behavioral questions on conflict resolution, motivation for joining Zeta, and notice period. The candidate received an offer for SDE-1 Backend after these three rounds. CTC was not stated in the post, as noted on GeeksforGeeks.

Round by round breakdown and prep focus

Here is a consolidated view of what each round tested, candidate-reported, so you can map your own prep weeks.

The first interviewer explicitly requested a brute-force approach and its complexity before optimisation. That supports practising a clear progression rather than claiming all Zeta interviewers use the same rule. Round 2 spans the widest topic range in this account, but the source does not publish conversion data or say where most candidates are filtered. The fitment round also contained technical Java and database questions, so it should not be described as behavioural only.

For LFU preparation, define capacity behaviour, get and put semantics, frequency updates, the eviction tie-break, data structures, and complexity before coding. A frequency-bucket design is one possible implementation, but the source does not state the candidate's exact design or an allowed completion time.

Preparation derived from the reported skills

Use the current role description to set the language and depth. The following sequence turns the source's topics into practice without inventing a calendar or problem quota.

DSA from simple to improved. Rework the two linked tasks from the source. State the contract, a direct approach, its complexity, the limitation that motivates improvement, the revised approach, edge cases, and tests. Expand to other topics only according to the current role and your demonstrated gaps.

Low-level design. Implement an LFU cache with explicit semantics and tests. Discuss tie-breaking, update rules, invalid capacity, complexity, and concurrency only where the prompt requires it. Do not attribute other design prompts to this interview.

Project language and concurrency. Because the source ties JavaScript questions to the candidate's projects, prepare the runtime and concurrency claims on your own resume. Explain the event loop and asynchronous control flow accurately, and distinguish language behaviour from host-runtime implementation. Do not add an unreported libuv question to the source account.

CS fundamentals. Review the exact concepts named in the account: CAP, TCP/IP and UDP, ACID, race conditions, and thread synchronisation. Prepare definitions, assumptions, examples, and limitations rather than a slogan.

Java depth. Rehearse the reported concepts with small compiling examples: overloading and overriding, functional interfaces, access specifiers, abstraction, abstract classes and interfaces, super, static, final, and constructor rules. Answer from the Java version relevant to the current role.

Database and fitment. Compare SQL and NoSQL only after stating workload, consistency, query, schema, and operational requirements. Prepare truthful examples about conflict resolution and motivation, and answer notice-period questions from your real situation.

Common mistakes and red flags to avoid

• Jumping straight to the optimal solution. This candidate's Round 1 interviewer explicitly asked for brute force first. State the direct approach and its complexity before improving it, without inventing an internal marking rule.
• Listing Node.js without supporting depth. Round 2 connected Node and event-loop questions to the candidate's projects. Keep only resume claims whose behaviour and use you can explain.
• Treating the fitment round as behavioural only. Round 3 also contained Java OOP and database questions, including functional interfaces and constructor rules.
• Treating LFU as memorised code. The source says the interviewer asked for logic before the complete class. Explain semantics and trade-offs before implementation.
• Not knowing your past project deeply. Round 2 opened with a past-project discussion. Prepare the architecture decisions, trade-offs, limitations, and your specific contribution for each project you list.
• Vague SQL versus NoSQL answers. Compare the options only after stating workload, consistency, query, schema, and operational requirements. The source does not publish a minimum answer or scoring bar.

Real-world data points

• 3 rounds reported from application to offer, as posted on GeeksforGeeks
• 0 online coding tests in this candidate's loop, candidate-reported
• Roughly 1 week from application to first recruiter call, candidate-reported
• Roughly 1 more week before interviews began, candidate-reported
• 2 DSA questions in Round 1: set partition into k subsets and sorted subsequence of size 3
• 1 LLD problem in Round 2: LFU cache implementation
• Round 2 interviewer level: SDE-2, as reported by the candidate
• CTC for the SDE-1 Backend offer: not stated in the source post

Sources & credits

• https://www.geeksforgeeks.org/interview-experiences/zeta-directi-interview-experience-for-sde-1/