Swiggy Interview Questions & Placement Prep (2026)
Swiggy hires freshers through three distinct tracks. SDE-1 is a product-company DSA process with coding, technical problem solving and product-oriented design discussion. SDET combines DSA with automation, API, mobile and quality engineering. Product Analyst focuses on SQL, statistics, experimentation, product metrics and business cases. Use the role-wise structure and question banks below.
SDE-1: 2–3 problems in 60–90 min (DSA + SQL/API) · SDET: ~2 hr Java, automation & SQL · Product Analyst: SQL, aptitude, product case
Last updated:
Exam Pattern
SDE-1: 2–3 problems in 60–90 min (DSA + SQL/API) · SDET: ~2 hr Java, automation & SQL · Product Analyst: SQL, aptitude, product case
| Section | Questions | Time | Type | Difficulty |
|---|---|---|---|---|
| SDE-1 · Online assessment | 2–3 problems | 60–90 min | DSA + SQL / API processing | Medium–Hard |
| SDE-1 · DSA interview | 1–2 problems | 45–60 min | Live coding | Medium–Hard |
| SDE-1 · Technical / design round | Varies | 60 min | LLD, DBMS, APIs, project | Hard |
| SDE-1 · Hiring manager / bar raiser | Varies | 45 min | Product thinking & ownership | Medium |
| SDET · Online assessment | Mixed | ~120 min | Java/programming, automation scenarios, SQL | Medium |
| SDET · Technical rounds (x2) | Varies | 45–60 min each | Core Java, DSA, framework, API & test design | Medium–Hard |
| Product Analyst · Online assessment | Mixed | Timed | SQL, aptitude, data interpretation, metrics | Medium |
| Product Analyst · Case interview | 1–2 cases | 45–60 min | Funnel, retention, marketplace analysis | Medium–Hard |
Section-Wise Syllabus
Everything that appears in the assessment, grouped by section.
1. SDE-1 — DSA core
Arrays & strings
- • Prefix sums
- • Difference arrays
- • Two pointers
- • Sliding window
- • Hashing
- • Sorting-based optimisation
- • Subarrays & subsequences
- • Palindromes
- • Anagrams
- • Pattern matching
- • String frequency
- • Minimum window problems
Linked lists
- • Reverse a list
- • Reverse in groups of k
- • Detect a cycle
- • Cycle-entry point
- • Middle node
- • Merge sorted lists
- • Merge k sorted lists
- • Palindrome linked list
- • Clone list with random pointers
Stacks & queues
- • Balanced parentheses
- • Min stack
- • Next greater element
- • Largest rectangle in histogram
- • Sliding-window maximum
- • Queue using stacks
- • Stack using queues
- • Monotonic stack
Trees & BSTs
- • Recursive & iterative traversals
- • Level-order traversal
- • Height & diameter
- • Lowest common ancestor
- • Validate BST
- • Serialize & deserialize
- • Build tree from traversals
- • Root-to-leaf sums
- • Maximum path sum
- • Vertical & boundary traversal
- • Tree views
Graphs
- • BFS & DFS
- • Connected components
- • Cycle detection
- • Bipartite graph
- • Topological sort
- • Course scheduling
- • Shortest unweighted path
- • Dijkstra
- • Minimum spanning tree
- • DSU
- • Number of islands
- • Word ladder
- • Strongly connected components
Dynamic programming
- • House robber
- • Coin change
- • 0/1 knapsack
- • Subset sum
- • Grid DP
- • Longest increasing subsequence
- • Longest common subsequence
- • Edit distance
- • Stock buy–sell
- • Partition DP
- • Interval DP basics
- • Tree DP basics
SQL & API / data processing
- • Joins
- • Aggregation
- • Window functions
- • Common table expressions
- • Date functions
- • JSON parsing
- • Pagination
- • Sorting API results
- • Filtering records
- • Handling missing fields
- • Rate limits & retries
- • HTTP status codes
- • Authentication basics
2. SDET — programming, automation & API
Programming & DSA
- • Java or Python in depth
- • OOP
- • Collections
- • Strings & arrays
- • Hash maps
- • Sorting & searching
- • Linked lists
- • Stacks & queues
- • Recursion
- • Basic trees & graphs
- • Time complexity
- • Exception handling
- • File handling
- • Multithreading basics
Automation
- • Selenium or Playwright
- • Locators, CSS selectors & XPath
- • Explicit vs implicit waits
- • Page Object Model
- • Data-driven testing
- • Keyword-driven testing
- • TestNG or JUnit
- • Fixtures & setup/teardown
- • Parallel execution
- • Screenshots & logs
- • Test reports
- • CI/CD integration
- • Flaky-test analysis
- • Test data management
- • Mocking & stubbing
API testing
- • GET, POST, PUT, PATCH, DELETE
- • Status codes
- • Headers & cookies
- • Authentication
- • JSON schema
- • Contract testing
- • Idempotency
- • Pagination
- • Retry behaviour
- • Timeout behaviour
- • Rate limiting
- • Negative testing
- • Postman / REST-assured
- • API automation in Java or Python
Mobile & product testing scenarios
- • Food search
- • Restaurant availability
- • Cart
- • Coupons
- • Payment success & failure
- • Refund
- • Order cancellation
- • Live order tracking
- • Notifications
- • Weak network
- • App backgrounding
- • Location permissions
- • Device fragmentation
- • Duplicate payment requests
- • Out-of-stock items
3. Product Analyst — SQL, Python, statistics & metrics
SQL
- • SELECT, WHERE, ORDER BY
- • GROUP BY & HAVING
- • Inner, left & self joins
- • Subqueries
- • CTEs
- • Window functions
- • ROW_NUMBER, RANK, DENSE_RANK
- • LAG & LEAD
- • Date & time functions
- • Conditional aggregation
- • Null handling
- • Duplicate detection
- • Cohort analysis
- • Funnel analysis
- • Retention analysis
Python & pandas
- • Lists, dictionaries, sets
- • Functions & comprehensions
- • NumPy
- • pandas DataFrames
- • groupby
- • merge & join
- • pivot_table
- • Filtering & sorting
- • Duplicate removal
- • Missing-value handling
- • Date conversion
- • Aggregation
- • Basic charts
Statistics
- • Mean, median, mode
- • Variance & standard deviation
- • Percentiles
- • Probability
- • Sampling
- • Confidence intervals
- • Hypothesis testing
- • A/B testing
- • Statistical significance
- • Type I & Type II errors
- • Correlation vs causation
- • Regression basics
- • Outlier analysis
- • Skewed distributions
Marketplace metrics
- • Conversion rate
- • Search-to-order conversion
- • Add-to-cart rate
- • Checkout completion
- • Average order value
- • CAC & LTV
- • Repeat purchase rate
- • Retention & churn
- • Cancellation rate
- • Refund rate
- • Delivery time
- • On-time delivery %
- • Restaurant acceptance rate
- • Rider assignment time
- • Order defect rate
- • GMV
- • Contribution margin
- • Discount burn
Product case framework
- • Define the problem and metric
- • Clarify the user segment
- • Break the funnel into stages
- • Check data quality
- • Identify possible causes
- • Prioritise hypotheses
- • Design analysis or experiment
- • Recommend action
- • Define success metrics
Most Asked Topics
Highest-frequency areas across recent test papers.
Graph BFS on grids
Number-of-islands and shortest-path-in-a-delivery-network problems appear repeatedly.
Binary tree path sums
Sum of numbers formed by root-to-leaf paths, identical trees and diameter.
Edit distance & string DP
Reported in live DSA rounds along with sliding-window and prefix-sum problems.
Sorted-matrix search
Row-wise and column-wise sorted matrix search in O(m + n) from the top-right corner.
Maximum product subarray
Track running max and min because a negative value flips them.
Hard SQL query in the OA
One reported assessment combined a medium string problem, an API-response processing task and a hard SQL query.
Automation waits & flaky tests
SDET rounds probe implicit vs explicit waits, locator strategy and debugging randomly failing tests.
Payment & refund test design
Idempotency, duplicate-charge prevention, timeout and reconciliation scenarios.
Free Resources
Curated practice links per section.
DSA practice
SDET / automation
SQL & analytics
50+ DSA Practice Problems
Solve in order — arrays and strings first, then sorting and recursion.
Arrays & strings
- Longest substring without repeated characters
- Minimum window substring
- Maximum subarray sum
- Product of array except self
- Smallest missing positive integer
- Group anagrams
- Subarray sum equals K
- Merge intervals
Linked lists & stacks
- Reverse in groups of k
- Detect cycle and entry node
- Merge k sorted lists
- Palindrome linked list
- Min stack
- Next greater element
- Largest rectangle in histogram
- Sliding-window maximum
Trees & graphs
- Sum of root-to-leaf numbers
- Identical trees
- Lowest common ancestor
- Serialize & deserialize
- Number of islands
- Shortest path in weighted graph (Dijkstra)
- Course schedule
- Word ladder
DP & matrix
- Edit distance
- Maximum product subarray
- Search in row/column-sorted matrix
- Coin change
- 0/1 knapsack
- Longest common subsequence
- House robber
- Stock buy & sell
Previous Year Questions & Patterns
Repeat coding questions with the expected approach.
SDE-1 previous-year-style
- Find the number of islands in a binary matrix (BFS or DFS).
- Find the shortest path in a weighted delivery network (Dijkstra).
- Find the sum of numbers formed by root-to-leaf paths (DFS carrying the current number).
- Find the edit distance between two strings (DP).
- Search in a row-wise and column-wise sorted matrix — O(m + n) from the top-right corner.
- Find the maximum product subarray by tracking current max and min.
- Design a job scheduler supporting add, cancel, suspend, resume, queue and priority execution.
- Process an API response: filter, paginate and handle missing fields.
SDET questions
- Explain your automation framework end-to-end.
- How do you handle flaky tests?
- Difference between implicit and explicit waits.
- How do you choose what to automate?
- How would you test a payment failure and a retry?
- How would you test live delivery tracking?
- How do you validate an order API and test idempotency?
- How do you handle OTP in automation?
- How would you test weak-network behaviour and app backgrounding?
- How do you reduce regression time?
- How do you decide whether a defect is critical?
- Write code to remove duplicates from an array.
Product Analyst questions
- Delivery delays increased by 20% — how would you investigate? (city, restaurant, rider, time slot, distance, weather, demand, assignment time, preparation time, data quality)
- Sales increased but profit fell — what could explain it? (discounts, category mix, delivery cost, returns, cancellations, CAC, restaurant commission)
- How would you measure retention? Define a cohort, take the first order date, measure returns in later periods and segment by city, channel and customer type.
- How would you detect fake reviews? (review timing, account age, order history, repeated phrases, rating distribution, device/IP patterns, verified purchases)
- Find users who ordered more than once in the same week.
- How would you handle missing values in order data?
20+ SQL Query Bank
Write these out by hand — joins and subqueries are asked in both the test and the interview.
Customer behaviour
Repeat users
SELECT user_id
FROM orders
GROUP BY user_id
HAVING COUNT(DISTINCT order_id) > 1;Weekly repeat orders
SELECT user_id,
DATE_TRUNC('week', order_time) AS order_week
FROM orders
GROUP BY user_id, DATE_TRUNC('week', order_time)
HAVING COUNT(*) > 1;Marketplace ranking
Rank restaurants by city
SELECT city,
restaurant_id,
revenue,
RANK() OVER (
PARTITION BY city
ORDER BY revenue DESC
) AS city_rank
FROM restaurant_revenue;Category revenue & order summary
SELECT category,
SUM(revenue) AS revenue,
COUNT(DISTINCT order_id) AS orders
FROM orders
GROUP BY category
ORDER BY revenue DESC;DBMS & Core Interview Q&A
Short answers you should be able to say out loud.
What does DATE_TRUNC('week', ts) return?
The timestamp truncated to the start of the week — used for weekly cohort and repeat-order analysis.
RANK vs DENSE_RANK vs ROW_NUMBER?
RANK skips numbers after ties, DENSE_RANK does not, ROW_NUMBER always increments regardless of ties.
How do you compute retention in SQL?
Build a first-order cohort per user, then join later activity periods and count returning users per cohort.
Why prefer a CTE over nested subqueries?
Readability and reuse of intermediate steps in funnel or cohort pipelines.
What is a self join used for?
Comparing rows in the same table — e.g. consecutive orders for the same user.
How do you handle NULLs in aggregation?
COUNT ignores NULLs, SUM/AVG skip them; use COALESCE deliberately and report missingness separately.
OOPs Concepts + 10 Code Snippets
Theory plus the exact snippets asked in the technical round.
Interface-first design
A job scheduler round expects an interface (add, cancel, suspend, resume) before any implementation detail.
State machine
Model order/job lifecycles explicitly — created, queued, running, cancelled, completed.
Page Object Model
SDET pattern: one class per page exposing behaviour, keeping locators out of tests.
Dependency injection
Inject drivers, clients and test data so tests stay isolated and parallelisable.
Idempotency
Same request applied twice must not double-charge or duplicate an order — core to payment testing.
Job scheduler skeleton (priority queue + state machine)
enum JobState { QUEUED, RUNNING, SUSPENDED, CANCELLED, DONE }
class Job implements Comparable<Job> {
final String id;
final int priority;
JobState state = JobState.QUEUED;
Job(String id, int priority) { this.id = id; this.priority = priority; }
public int compareTo(Job other) { return Integer.compare(other.priority, this.priority); }
}
interface Scheduler {
void add(Job job);
void cancel(String jobId);
void suspend(String jobId);
void resume(String jobId);
Job next(); // highest priority, non-suspended, non-cancelled
}Search in a row/column-sorted matrix — O(m + n)
bool searchMatrix(vector<vector<int>>& m, int target) {
if (m.empty()) return false;
int r = 0, c = (int)m[0].size() - 1;
while (r < (int)m.size() && c >= 0) {
if (m[r][c] == target) return true;
if (m[r][c] > target) --c;
else ++r;
}
return false;
}Funnel conversion query
SELECT stage,
COUNT(DISTINCT user_id) AS users,
ROUND(100.0 * COUNT(DISTINCT user_id)
/ MAX(COUNT(DISTINCT user_id)) OVER (), 2) AS pct_of_top
FROM funnel_events
GROUP BY stage
ORDER BY users DESC;Operating System Basics
Scheduling, deadlock and memory management essentials.
OS & concurrency for SDE/SDET
- • Process vs thread
- • Thread safety and locks
- • Deadlock conditions
- • Multithreading in Java (ExecutorService)
- • Timeouts and retries
- • Memory management basics
Reliability topics for design rounds
- • Idempotent APIs
- • Retry with backoff
- • Rate limiting
- • Caching and invalidation
- • Consistency during order state changes
- • Observability: logs, metrics, traces
4-Week Preparation Roadmap
From zero to test-ready in 28 days.
SDE: arrays, strings, hashing · SDET: Java/Python & OOP · PA: SQL basics
- 6 problems / 1 automation exercise / 10 SQL queries
Goal: Set the foundation for your chosen track.
SDE: sliding window, prefix sums, binary search · SDET: Selenium/Playwright · PA: joins & aggregation
- 6 pattern problems / 1 automation script / 10 SQL queries
Goal: Fluency in the highest-frequency patterns.
SDE: linked lists, stacks, queues · SDET: TestNG/JUnit & POM · PA: window functions
- 5 problems / framework refactor / 8 window-function queries
Goal: Write clean, structured code and queries.
SDE: trees & heaps · SDET: API & JSON testing · PA: Python/pandas
- 5 problems / 10 API cases / 2 pandas notebooks
Goal: Cover the tree and API question banks.
SDE: graphs & DSU · SDET: mobile & payment testing · PA: statistics
- 5 graph problems / 10 payment scenarios / stats revision
Goal: Handle graph modelling and payment edge cases.
SDE: DP & greedy · SDET: CI/CD & flaky tests · PA: funnels & retention
- 5 DP problems / pipeline setup / 2 funnel analyses
Goal: Complete the hardest technical block.
SDE: LLD & mock coding · SDET: end-to-end product scenarios · PA: product cases
- 1 LLD write-up / 1 full E2E suite / 2 cases
Goal: Practise explaining trade-offs out loud.
Timed OAs and mock interviews for all tracks
- 1 timed assessment
- 1 mock interview
- Resume & project revision
Goal: Simulate the real process end-to-end.
Exam Day Strategy
Score targets and time allocation.
Section targets
- Online assessment: Scan all problems, bank the easiest, then split remaining time between the medium and hard problem.
- SQL question in the OA: Write the aggregation first, then layer window functions; verify on a small mental sample.
- DSA interview: Clarify → brute force → optimise → complexity → dry run → edge cases → clean code → test.
- SDET round: Anchor every answer in a real scenario: search, cart, coupon, payment, refund, tracking.
- Product case: Define metric → segment → funnel → data quality → hypotheses → analysis/experiment → recommendation.
Coding time split (50 min)
- SDE-1: 2 hours DSA daily + 45 min timed coding + 30 min CS fundamentals + 30 min project/LLD
- SDET: 60 min coding/DSA + 60 min automation + 45 min API testing + 30 min product scenarios
- Product Analyst: 60 min SQL + 45 min Python/pandas + 30 min statistics + 45 min cases & metrics
Interview Process
What follows the online test.
SDE-1
- • Online assessment — 2–3 coding problems (DSA, SQL or API processing)
- • DSA interview — algorithms, correctness, complexity
- • Technical / design round — LLD, DBMS, APIs, trade-offs
- • Hiring manager / bar raiser — product thinking and ownership
- • HR / final discussion
SDET
- • Online assessment — Java/programming, automation scenarios, SQL (~2 hours)
- • Technical round 1 — core Java, DSA, automation basics
- • Technical round 2 — framework, API and test design
- • System/design round — test architecture, automation strategy, reliability
- • HR / hiring manager
Product Analyst
- • Online assessment — SQL, aptitude, data interpretation, product metrics
- • Technical/data interview — SQL, Python/pandas, statistics
- • Product case interview — funnel, retention, delivery, growth, marketplace
- • Hiring manager — communication and business judgement
- • HR round
Mock Test Plan
Four simulations to run before the real test.
Mock 1 — SDE-1 assessment
- • 3 problems in 90 minutes
- • Include one SQL or API-processing task
- • Partial scoring mindset
Mock 2 — SDET assessment
- • Java coding + automation scenario + SQL optimisation
- • 2 hours, no reference material
- • Review flaky-test reasoning
Mock 3 — Product Analyst
- • 8 SQL queries in 60 minutes
- • 1 pandas cleaning task
- • 1 delivery-delay case with recommendation
Mock 4 — Design discussion
- • Design a job scheduler or order-tracking module
- • Cover interfaces, states, failure handling
- • 45 minutes, spoken aloud
Final Checklist
Tick all of these before test day.
Recent Interview Experiences
First-hand write-ups from students who actually sat the Swiggy process.
Be the first to share a Swiggy interview experience.
Frequently Asked Questions
How long is the Swiggy SDE-1 online assessment?
Reports range from a 60-minute test with three questions to a 90-minute HackerRank/HackerEarth test with two or three problems — prepare for three medium-to-hard problems in 90 minutes.
Does the SDE assessment include SQL?
Yes, some slots do. One reported test had a medium string problem, an API-response processing task and a hard SQL query.
What does the SDET assessment cover?
Around two hours of Java/programming, automation scenario tasks and SQL optimisation, followed by framework, API and test-architecture rounds.
How much DSA does a Product Analyst need?
Very little advanced DSA — SQL, statistics, experimentation and product metrics carry far more weight.
Which DSA topics repeat most?
Graphs, trees, dynamic programming, sliding window, prefix sums, edit distance and shortest-path problems.
Want the full structured prep for Swiggy?
The Premium Vault covers Aptitude, Core CS, DSA, SQL and HR rounds with module-wise courses and drill sheets.
Related Prep
Next steps chosen from the Swiggy pattern and other Indian Unicorn recruiters.
Other Indian Unicorn companies
Flipkart Interview Prep Guide
Flipkart exam pattern, syllabus and previous year questions · ₹18–32 LPA · intern ₹80k–1.2L/mo.
Zomato & Blinkit Interview Prep Guide
Zomato & Blinkit exam pattern, syllabus and previous year questions · ₹14–28 LPA.
Myntra Interview Prep Guide
Myntra exam pattern, syllabus and previous year questions · ₹16–28 LPA.
Core CS subjects for this pattern
DBMS & SQL Essentials
Normalisation, keys, transactions and the SQL queries asked in written rounds.
OOPs Essentials for Interviews
The four pillars with the exact code snippets interviewers ask you to explain.
Operating System Essentials
Processes, scheduling, deadlock and memory management in interview-ready form.
Recommended practice path