#React Native#React#JavaScript#Frontend System Design#Interview Experience
Zepto Software Engineer — II (React Native) Interview Experience
Anil Peddireddy
July 23, 2026
medium.com
Overview
Zepto is an Indian quick-commerce company known for its rapid grocery-delivery model. The Software Engineer II (React Native) interview process focused on mobile application development, JavaScript fundamentals, React component design, product engineering, and frontend system design.
The candidate entered the process with professional experience at the SDE 2 level and expected the interviews to evaluate React Native expertise at a comparable level. The process consisted of three rounds and included practical coding exercises, a machine-coding assignment, and a product-focused system design discussion.
Interview Process
The interview process followed this timeline:
Round 1 — React Native and coding fundamentals: Discussion of production React Native experience, memoization, and a custom AsyncStorage hook.
Round 2 — JavaScript and machine coding: Output-based JavaScript questions followed by a folder tree component implementation in React.
Round 3 — Hiring manager discussion and system design: Experience deep dive, product engineering questions, and API and frontend optimisation for an e-commerce listing page.
Post-interview discussion: The recruiter communicated a proposed Software Engineer I position rather than the expected Software Engineer II level. After the candidate requested consideration at the appropriate level, communication reportedly stopped without a formal acceptance or rejection.
Technical Rounds
Round 1: React Native Experience and Coding
The first round was conducted by a senior mobile engineer and began with a discussion of the candidate's React Native experience. Topics included production performance optimisation, bundle-size management, native-module integration, and debugging communication issues between JavaScript and native code.
The interviewer then presented two coding exercises.
Memoization Function
The candidate was asked to implement a memoization function that returned a memoized function and cached results for repeated arguments.
function memoize(fn) {
const cache = new Map();
return function memoizedFn(...args) {
const key = JSON.stringify(args);
if (cache.has(key)) {
return cache.get(key);
}
const result = fn.apply(this, args);
cache.set(key, result);
return result;
};
}
The follow-up discussion covered several production considerations:
JSON.stringify can be unreliable for complex objects and cannot handle circular references.
Original Source
This experience was originally published on medium.com. Support the author by visiting the original post.
An unbounded cache can cause excessive memory usage.
Cache-size limits, eviction policies, or WeakMap may be more appropriate for certain object-key scenarios.
The implementation should account for function context and argument identity where necessary.
Custom useAsyncStorage Hook
The second exercise required a custom React Native hook for reading, updating, and removing values from AsyncStorage. The hook was expected to expose the stored value, setter and removal functions, loading state, and error state.
The interviewer also asked how multiple components using the same storage key could remain synchronised. The candidate suggested using shared state management or a context provider that centralised storage access and notified all consumers when a value changed.
Round 2: JavaScript Fundamentals and Machine Coding
The second round began with JavaScript output-based questions covering closures and variable scoping.
For example, the interviewer tested the behaviour of var inside a loop with asynchronous callbacks:
for (var i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 100);
}
The output is 3, 3, 3 because var is function-scoped and all callbacks reference the same final value. The discussion also covered independent closures created by separate invocations of a function:
function outer() {
let x = 10;
return function inner() {
console.log(x);
x++;
};
}
const first = outer();
const second = outer();
first();
first();
second();
The first closure prints 10 and then 11, while the second closure maintains a separate x value and prints 10.
Folder Tree Component
The main machine-coding task required a recursive React folder tree component. The component needed to display nested folders and files and allow users to expand and collapse folders.
The follow-up discussion focused on scaling the component for production use. Potential improvements included:
Virtualisation for very large trees.
Lazy loading folder contents only when a folder is expanded.
Search and filtering support.
Focus management and keyboard navigation.
Arrow-key navigation and Enter-key expansion or collapse.
Accessibility attributes such as role="tree" and aria-expanded.
Round 3: Hiring Manager Discussion and System Design
The final round combined behavioural questions with a frontend system design exercise. The hiring manager asked about the candidate's current React Native projects, team responsibilities, production incident handling, and difficult technical decisions.
The system design exercise presented a product listing page similar to a large e-commerce website. The candidate was asked to design the API response structure and explain how the frontend could be implemented efficiently.
Example API Response
The proposed response separated product information, pricing, media, ratings, availability, metadata, pagination, and filter data.
The frontend optimisation strategy covered several areas:
Virtualisation and lazy rendering: Render only the products visible in the viewport.
Image optimisation: Use responsive image sizes, progressive loading, and modern formats such as WebP.
Caching: Cache API responses and use a stale-while-revalidate approach where appropriate.
Debounced interactions: Debounce search and filter requests to avoid unnecessary API calls.
Perceived performance: Use skeleton states while product data is loading.
Prefetching: Fetch the next page when the user approaches the end of the current result set.
Real-time inventory: Use WebSockets for stock updates, with polling as a fallback.
Large-scale search: Use a search engine such as Elasticsearch, combined with debounced autocomplete and relevance analytics.
The round tested more than implementation ability. It evaluated API design, performance trade-offs, scalability, real-time data handling, and the ability to reason about an e-commerce product experience.
Role-Level Outcome
After the three rounds, the recruiter communicated that the team had been impressed by the candidate's technical performance but intended to offer a Software Engineer I position. The candidate explained that the expected level was Software Engineer II, matching the candidate's existing SDE 2 experience, and stated that only a comparable or higher level would be considered.
The recruiter indicated that the level could be discussed with the team. According to the experience, no further update arrived, leaving the process without a clearly documented acceptance or rejection.
Key Takeaways
Prepare for Practical React Native Questions
Senior React Native interviews can cover production concerns rather than only framework syntax. Candidates should be prepared to discuss performance profiling, bundle size, native modules, storage, bridge behaviour, offline support, and debugging strategies.
Understand JavaScript Fundamentals Deeply
Closures, scoping, asynchronous execution, memoization, and function identity remain important for frontend and React Native roles. Output-based questions often reveal whether a candidate understands how JavaScript behaves at runtime.
Design Components for Scale
A recursive folder tree is simple at small scale but introduces performance and accessibility concerns as the data grows. Strong solutions consider virtualisation, lazy loading, keyboard navigation, search, and semantic accessibility from the beginning.
Treat System Design as Product Engineering
Frontend system design involves more than creating an API shape. A complete answer should address pagination, caching, image delivery, loading states, debouncing, prefetching, real-time updates, error handling, and the scale of the underlying data.
Clarify Role and Level Expectations Early
Candidates should confirm the expected level, responsibilities, reporting structure, and compensation range before investing heavily in an interview process. A technically successful process can still end unsuccessfully if the candidate's level and the company's evaluation are not aligned.
Evaluate Title Trade-offs Carefully
Accepting a lower title may be reasonable when it provides exceptional mentorship, a significant domain transition, meaningful equity, stronger long-term opportunities, or a clearly defined path to promotion. However, candidates should be cautious when the role carries the same responsibilities as a higher-level position without equivalent recognition or progression.
Conclusion
The Zepto Software Engineer II (React Native) interview experience demonstrated a technically relevant process covering React Native, JavaScript, React machine coding, and frontend system design. The candidate completed three rounds and showed strong alignment with the technical subject matter, but the proposed Software Engineer I level created a fundamental mismatch.
The experience highlights the importance of preparing for practical engineering discussions while also protecting long-term career progression. Technical performance and company interest are valuable, but role-level alignment should remain an explicit part of the final decision.