The hiring process
| Round | Format | What's tested |
|---|---|---|
| Coding Round | ~60–90 min | DSA fundamentals screen |
| Technical – Developer Round | ~45–60 min | Coding plus fundamentals |
| Team Lead / LLD Round | ~45–60 min | Design and CS depth |
| Leadership / HR Round | ~30–45 min | Fit, ownership, and CTO/lead sync |
Process and cutoffs vary by drive/team and change over time — confirm on the official careers page.
Round-by-round: exactly what's asked & how to prepare
Coding Round
~60–90 minOne coding round (sometimes several problems) drawn from core topics like arrays and linked lists, often with a puzzle or two. Difficulty is easy-to-medium with an emphasis on correct, clean implementation. Campus loops may pack more problems into fewer rounds.
- Array and linked-list manipulation
- Basic string processing
- Simple recursion / backtracking
- Logic puzzles and math
- Hashmap frequency counting
- Drill array, string, and linked-list easies-to-mediums (leetcode.com)
- Practice common logic puzzles
- Review recursion templates
- Follow Striver's SDE sheet basics (takeuforward.org)
- Overthinking easy problems
- Pointer bugs on linked lists
- Skipping edge cases
- Correct, clean solutions
- Sound complexity reasoning
- Solid fundamentals
Technical – Developer Round
~45–60 minA senior developer runs medium DSA plus questions on CS fundamentals — OOP, DBMS, and language internals. You explain your approach and defend your fundamentals. Practical correctness matters more than clever tricks.
- Medium array/tree/DP problems
- OOP concept application
- SQL query and indexing questions
- Language-specific internals (GC, collections)
- Time/space optimization follow-ups
- Solve 15 medium DSA problems (neetcode.io)
- Revise OOP, DBMS, and SQL fundamentals
- Practice explaining language internals
- Do a couple of peer mocks
- Weak DBMS/SQL answers
- Coding before explaining
- Shaky fundamentals under follow-up
- Clean code with clear reasoning
- Strong CS fundamentals
- Good optimization instincts
Team Lead / LLD Round
~45–60 minA team lead covers low-level design (a classic like LRU cache) plus a discussion of your projects, experience, and CS fundamentals. Expect to reason about class structure and trade-offs. This round weighs practical design judgment.
- Implement an LRU / LFU cache
- Design a quote-comparison module
- OOP model for an insurance-policy catalog
- Rate limiter or retry handler for insurer APIs
- Notification / reminder scheduler
- Implement LRU/LFU and 2–3 other LLD problems (refactoring.guru)
- Revise SOLID and design patterns
- Review the low-level-design-primer (github.com/prasadgujar)
- Be ready to defend past-project decisions
- Not clarifying requirements before designing
- Tightly coupled classes
- Vague answers on your own projects
- Clean, correct LLD implementation
- Sensible OOP structure
- Depth on your own work
Leadership / HR Round
~30–45 minA conversation with senior leadership (sometimes the CTO) plus HR on projects, motivation, and culture fit. They probe ownership, communication, and why insurtech. Expect straightforward behavioral questions and offer discussion.
- A project you owned end to end
- Handling a tight deadline or incident
- A disagreement you navigated
- Working across teams / with insurers
- Why PolicyBazaar / fintech
- Prepare 5 STAR stories with impact
- Research PolicyBazaar's business and scale
- Prepare questions for leadership
- Practice concise story delivery
- Vague, unquantified stories
- No specific reason for the company
- Poor conflict framing
- Clear ownership and impact
- Good communication
- Genuine domain interest
What to master
- Arrays & strings
- Linked lists & recursion
- Trees & DP basics
- Low-level design / OOP
- DBMS & SQL
- System design basics
- Language internals
- Caching (LRU/LFU)
Eligibility
open — role-based
PolicyBazaar salary & compensation (2026)
PolicyBazaar pays market India cash with a growing ESOP component; entry bands are solid for a public fintech.
| Role / Level | Experience | India — total CTC | US — total comp | What to know |
|---|---|---|---|---|
| SDE-1 | 0–2 yrs | ₹10–20 LPA | — | mostly fixed; small joining bonus, some ESOP |
| SDE-2 | 2–5 yrs | ₹20–36 LPA | — | fixed + variable + ESOP |
| SDE-3 / Senior | 5–8 yrs | ₹36–55 LPA | — | larger ESOP and variable weight |
| Staff / Lead | 8–12 yrs | ₹55–80 LPA | — | ESOP a meaningful slice of comp |
| Principal / EM | 12+ yrs | ₹80 LPA+ | — | equity-weighted; negotiable |
How the package is structured
- Structure is fixed base + variable + joining bonus + ESOP that grows with level.
- As a listed company (PB Fintech), ask about RSU/ESOP vesting and current share price to value equity.
- Cash base is the most negotiable lever with a competing offer in hand.
- Getting placed at the right level matters more than round-level negotiation.
Indicative 2026 market ranges aggregated from public sources (levels.fyi, Glassdoor, AmbitionBox, candidate reports). Compensation varies widely by location, team, level calibration, and negotiation — use these as directional benchmarks, not guarantees.
Your prep plan
- Days 1–3: arrays, strings, and linked lists to medium level
- Days 4–6: trees, light DP, and a timed coding test
- Days 7–8: revise OOP, DBMS, and SQL fundamentals
- Days 9–11: implement LRU/LFU and two more LLD problems
- Day 12: five STAR stories and a project walkthrough
- Days 13–14: mixed mocks and fundamentals review
Want this plan dated to your interview?
Upload your resume and tell Whis your interview date — get a personalized, day-by-day plan built around your gaps, then run Whis live in the interview.
Get my personalized planFrequently asked questions
How algorithm-heavy is the loop?
It's moderate — solid fundamentals, LLD, and CS basics matter more than hard competitive-programming problems.
Are CS fundamentals actually tested?
Yes, DBMS/SQL, OOP, and language internals come up in the developer and lead rounds, so revise them.
How fast is the process?
It's one of the quicker loops — offers can come within roughly a week to two of the first round.