Interview experience
Nykaa Interview Questions and Answers (2026)
Overview
Section titled “Overview”Nykaa’s engineering interviews run a distinct 3-stage loop where a dedicated Low-Level Design round - not just DSA - is a seriously evaluated stage on its own.
Nykaa interview process at a glance
Section titled “Nykaa interview process at a glance”| Round | Duration | What they test |
|---|---|---|
| DSA/Coding Round | 45-60 min | 2 medium DSA problems |
| Low-Level Design (LLD) Round | 45-60 min | DB schema design, OOP class design, design patterns |
| Manager/HR Round | 30-45 min | Project depth, work experience, culture fit, sometimes HLD |
DSA/Coding Round
Section titled “DSA/Coding Round”A 45-60 minute round with typically 2 medium-difficulty problems at LeetCode-medium level.
Common questions
- Container With Most Water
- Group Anagrams
- General array, sliding-window, stack, tree, and DP problems
Low-Level Design (LLD) Round
Section titled “Low-Level Design (LLD) Round”The most distinctive stage - a genuine class-design and schema exercise, not just algorithmic coding. You’re expected to define clean OOP structure and apply the right design patterns for a functional system.
Common questions
- Design a McDonald’s-style outlet ordering system (menu, order state, inventory) - class design and schema
- Justify your choice of design patterns (e.g. strategy, factory, observer) for a given scenario
- Design a small e-commerce-style system - cart, inventory, or order flow - with clean interfaces
Manager / HLD / HR Round
Section titled “Manager / HLD / HR Round”Often blends a High-Level Design discussion (scoped closer to Nykaa’s own domain, like a targeted-campaigns engine) with project depth and culture-fit questions - there’s frequently no separate HR-only round.
Common questions
- Design a targeted-campaigns or recommendation engine at a high level
- Walk through your most complex project - architecture and specific contribution
- Nykaa operates at e-commerce scale with heavy catalog/order volume - how would you design a system to handle that kind of growth?
- Tell me about a project where you had to make a design trade-off under time pressure
Round-by-round narratives are on the Nykaa interview experience page.
Sample answer frameworks are on the Nykaa HR interview questions page.
Common technical interview questions and answers
Section titled “Common technical interview questions and answers”Q: Container With Most Water - how do you solve it in O(n)?
Use two pointers, one at each end of the height array. The area is min(height[left], height[right]) multiplied by the distance between them, so record it and then move whichever pointer sits at the shorter line inward. Moving the taller line can never increase the area because the width always shrinks and the height stays capped by the shorter side, so it is safe to discard it. This runs in O(n) time and O(1) space, versus O(n^2) for checking every pair.
Q: How would you implement Group Anagrams efficiently?
Iterate the words once and compute a canonical key for each: either the sorted characters of the word, or a 26-length count array of letter frequencies rendered as a string. Insert each word into a hash map keyed by that canonical form, then return the map’s values as the grouped lists. Sorting keys costs O(n * k log k) for n words of length k; the counting key drops that to O(n * k). Space is O(n * k) for the map.
Q: Which design patterns would you use for a food-outlet ordering system, and why?
A Factory (or Abstract Factory) creates the different MenuItem types so the ordering code never hardcodes concrete classes. The State pattern models the order lifecycle - PLACED, PREPARING, READY, DELIVERED, CANCELLED - so each state object controls which transitions are legal instead of a sprawling switch statement. Strategy handles interchangeable pricing or discount rules, and Observer notifies the kitchen display, inventory service, and customer notification service when an order changes state. Naming the pattern is not enough - Nykaa’s LLD round expects you to justify why that pattern beats the simpler alternative.
Q: Design the database schema for a cart and order flow. What tables and keys do you need?
At minimum: users(user_id PK), products(product_id PK, name, brand_id), product_variants(variant_id PK, product_id FK, sku, mrp, selling_price), inventory(variant_id FK, warehouse_id FK, available_qty), carts(cart_id PK, user_id FK, status), cart_items(cart_id FK, variant_id FK, qty), orders(order_id PK, user_id FK, status, total_amount, created_at), and order_items(order_id FK, variant_id FK, qty, unit_price_at_purchase). The key design point is that order_items snapshots the price at purchase time - you must never join back to the live price table, because prices change and old invoices must stay correct. Index orders on (user_id, created_at) for order history and cart_items on cart_id.
Q: What is the difference between composition and inheritance, and which do you prefer in LLD?
Inheritance models an is-a relationship and binds the subclass to the parent’s implementation at compile time, so a change in the base class ripples into every subclass. Composition models a has-a relationship: the class holds a reference to a collaborator behind an interface, and behaviour can be swapped at runtime. Prefer composition for varying behaviour - a PricingStrategy field injected into Order beats a DiscountedOrder subclass, because you would otherwise need a new subclass for every combination of behaviours. Inheritance is still right for genuine type hierarchies with a stable contract.
Q: How would you find the maximum-sum subarray, and what changes if all numbers are negative?
Kadane’s algorithm scans once, keeping current_sum = max(num, current_sum + num) and best = max(best, current_sum). It runs in O(n) time and O(1) space. If every element is negative, initialising best to zero wrongly returns 0, so initialise best to the first element (or to negative infinity) and let the max operation pick the least-negative single element. To also return the indices, record the start position whenever current_sum resets to num.
Q: How would you design a targeted-campaigns or product recommendation engine at a high level?
Split it into offline and online paths. Offline, a batch job over clickstream, order history, and catalog data computes candidate sets - collaborative filtering on user-item interactions plus content-based similarity on brand, category, and skin-type attributes - and writes precomputed recommendations into a fast key-value store such as Redis, keyed by user_id. Online, the API reads that store in a few milliseconds, filters out out-of-stock or already-purchased items, and applies business rules like margin or campaign boosts before ranking. Use Kafka to stream fresh events into the feature store so the offline model retrains regularly, and always keep a fallback of trending or bestselling items for cold-start users with no history.
Q: How do you detect a cycle in a linked list, and where does that come up in practice?
Use Floyd’s tortoise-and-hare: advance a slow pointer one node and a fast pointer two nodes per step; if they ever meet, a cycle exists. To find the cycle’s entry point, reset one pointer to the head and advance both one step at a time - they meet at the start of the loop. This is O(n) time and O(1) space, better than a hash set of visited nodes which costs O(n) space. The same idea detects cycles in any next-pointer structure, such as a chain of order-state transitions that must be acyclic.
Frequently asked questions about Nykaa interviews
Section titled “Frequently asked questions about Nykaa interviews”What is the Nykaa interview process for freshers?
Nykaa typically runs 3 rounds for engineering hires: 1. DSA/Coding Round (45-60 minutes) - usually 2 medium-difficulty problems, occasionally harder for senior or competitive drives. 2. Low-Level Design (LLD) Round - a DB design plus object-oriented design exercise where you define classes, interfaces, database schemas, and apply relevant design patterns for a system (often something close to Nykaa’s own catalog, cart, or order-management domain). 3. Manager/HR Round - a detailed discussion of past projects and work experience, plus culture fit. The full process usually takes 2-4 weeks.
What questions are asked in Nykaa interviews?
Coding rounds lean on arrays, sliding windows, stacks, trees, and dynamic programming at LeetCode-medium difficulty - candidate reports mention problems like Container With Most Water and Group Anagrams. The LLD round asks you to design a functional e-commerce-style system (candidates have reported a McDonald’s-outlet-style ordering system) with clean class design and appropriate design patterns. A separate HLD round covers something closer to Nykaa’s own domain (e.g. a targeted-campaigns/recommendation engine), often blended with a managerial conversation.
How many rounds are there in the Nykaa interview?
Most Nykaa engineering interviews run 3 rounds: a DSA/coding round, a low-level design round, and a manager/HR round (sometimes blended with a high-level design discussion). There’s no separate large HR-only round in many cases - cultural fit is assessed as part of the manager conversation.
What is Nykaa’s LLD round like?
The Low-Level Design round is a distinct, seriously-evaluated stage - you define classes, interfaces, and database schemas for a functional system and justify your design-pattern choices. A reported example asked candidates to design a McDonald’s-style outlet ordering system (menu items, order state, inventory), testing clean OOP structure rather than raw algorithmic speed.
How should I prepare for Nykaa interviews?
Practice medium-level DSA (arrays, sliding window, stacks, trees, DP) and get comfortable designing a small object-oriented system end-to-end, including database schema and design patterns, since Nykaa’s LLD round is a distinct evaluated stage separate from DSA. Be ready to discuss your projects in detail and connect your interest to Nykaa’s e-commerce/beauty business and its scale challenges.
Is Nykaa’s interview process the same for freshers and experienced hires?
The public write-ups available for Nykaa skew toward experienced SDE hiring (SDE-2 and above), where the DSA-LLD-HLD structure is well documented. Fresher/campus loops likely lean lighter on the HLD stage and heavier on DSA fundamentals and the LLD round, but treat the process as a prep map rather than an exact script for your specific drive.