How to Crack NoBroker: The Software Development Engineer Interview, From Real Experiences
A complete, evidence-based breakdown of NoBroker's SDE interview process, covering coding speed, Low-Level Design (LLD), Java internals, and manager rounds.
On this page
Last updated November 19, 2026 · 21 min read · For software development engineers targeting SDE-1 and SDE-2 roles in India
Researched and written by the Codinzhub Editorial Team. Based on 16 verified candidate reports, public engineering interview accounts, and Codinzhub practice datasets. All questions are verbatim candidate reports or faithful paraphrases from historical accounts.
The 30-second version. Across the reports in our dataset, NoBroker's technical hiring loop moves rapidly through an automated online coding assessment, a strict 45-minute live DSA problem-solving round (2 LeetCode Medium questions), an intensive Low-Level Design (LLD) machine coding round featuring core Java concurrency and object-oriented design patterns, an optional High-Level System Design round for experienced candidates, and a decisive Engineering Manager discussion. If you take away only one habit from this entire guide, make it this one: master fast problem-solving under tight time limits, brush up on core Java internals (especially HashMap collision mechanics and multithreading synchronization), and structure machine coding designs using clean Strategy and Factory patterns rather than writing procedural scripts.
What this guide is, and what it is not
If you are preparing for a Software Development Engineer interview at NoBroker, technical forums consistently highlight two dominant themes: intense time pressure during live coding and deep probing into Java internals and Low-Level Design (LLD). The accounts in our dataset show a structured, highly predictable engineering loop with distinct evaluation bars.
This guide is:
- Built from 16 verified candidate reports across NoBroker SDE-1 and SDE-2 hiring loops between 2024 and 2026.
- An evidence-backed breakdown of actual rounds, recurring question patterns, stage playbooks, and verified practice analogues.
- A transparent view of where candidates succeeded and where they were eliminated.
This guide is not:
- A leaked exam bank or a guarantee that specific questions will be asked in your interview.
- An official statement by NoBroker Technologies.
- An acceptance rate calculation, as candidate reports are self-reported and reflect individual experiences.
A note on scope: this guide focuses on the Software Development Engineer role across entry-level (SDE-1) and mid-level (SDE-2) engineering tracks based primarily out of Bangalore tech offices. While the core algorithmic and design standards remain consistent, individual team expectations vary. Always confirm current stage formats and tooling with your recruiter.
Important things to know before the interview
Severe time pressure in Round 1. Candidates frequently report that Round 1 is extraordinarily fast-paced. You are given 45 to 50 minutes to discuss your background, solve 2 full LeetCode Medium problems, explain time and space complexity, and dry-run custom edge cases. Spending more than 20 minutes on the first question severely jeopardizes completing the round.
Heavy Java and multithreading focus. NoBroker's high-throughput backend infrastructure is heavily built on Java and Spring Boot. Even if you interview in another language, interviewers routinely ask deep questions on Java collection internals (such as HashMap collision resolution, treeification thresholds, and
equals()versushashCode()contracts), volatile variables, and concurrent locking mechanisms.
Low-Level Design is a primary elimination round. Writing code that merely solves the immediate requirement is insufficient in Round 2. Interviewers evaluate how you apply object-oriented design patterns (such as Factory, Strategy, and Observer), decouple class hierarchies, and prevent race conditions when modeling real-world systems like BookMyShow or Parking Lot.
Round-by-round breakdown
Stage 1: Application, where candidates applied
Candidates in our reviewed accounts entered the NoBroker hiring pipeline through four primary channels:
| Channel | What candidates said |
|---|---|
| Naukri.com and Job Portals | The most common hiring channel for off-campus and lateral SDE roles. Recruiters actively reach out to candidates matching immediate notice period criteria. |
| Employee Referral | Reported as the fastest channel. Candidates referred by current NoBroker engineers typically received screening calls within 3 to 7 business days. |
| LinkedIn InMail Outreach | Common for mid-level (SDE-2) and backend engineers with 2 to 4 years of experience building scalable microservices. |
| University Campus Recruitment | Conducted across engineering colleges in India, beginning with a centralized HackerRank online test. |
What helped:
- Highlighting practical experience with high-concurrency backend services, Redis caching, and relational database query optimization.
- Stating a short notice period (immediate joiners or 15 to 30 days are strongly prioritized).
Stage 2: Shortlisting, how candidates moved forward
Once an application is submitted, candidates move forward through a preliminary screening conversation.
How it works.
- Recruiter Screen (15 to 20 minutes): A telephonic conversation focusing on current employment details, total years of relevant experience, primary tech stack (Java/Spring Boot versus other stacks), current CTC, notice period duration, and location preferences in Bangalore.
- Immediate Next Steps: Candidates who meet the operational criteria are scheduled directly for the automated online assessment or live technical Round 1.
Stage 3: Technical assessments and phone screens
Online assessment
How it works. An automated coding challenge hosted on HackerRank. Candidates receive 2 to 3 algorithmic coding problems focusing on priority queues, string character replacements, prefix sums, and interval merging. Solutions must pass all public and hidden automated test suites within 60 minutes.
At a glance
- Duration: 60 minutes
- Questions per round: 2 to 3 coding problems
- Coding surface: HackerRank browser environment with automated test runner
- Topics: Priority queues, strings, sliding window, intervals, dynamic programming
- Most common: Last Stone Weight, Anagram character replacements, Merge Intervals
| Question (our summary) | What it tests | Level |
|---|---|---|
| Last Stone Weight | Max-heap simulation and dynamic priority reduction | Easy / Medium |
| Minimum Character Replacements to Make Anagrams | String frequency counting and character divergence | Medium |
| Subarray Product Less Than K | Sliding window and dynamic pointer bounds | Medium |
| Merge Intervals | Interval sorting and contiguous overlap merging | Medium |
| Maximum Subarray Sum | Kadane’s algorithm and dynamic programming | Medium |
NoBroker OA questions shared on Codinzhub:
| Question | Drive | Topic |
|---|---|---|
| Minimum Square Side | IIT Guwahati | Binary search, geometry |
| Reverse String After K Blinks | IIT Guwahati | Strings, simulation |
| Stable Negative-Zero-Positive Partition | IIT Guwahati | Two pointers, partitioning |
| Maximum Alternating Subarray Sum | PYQ | DP, Kadane |
| Last Nodes Sum at Every Level | PYQ | Tree BFS |
More Codinzhub questions: Browse NoBroker questions.
Technical problem solving round
How it works. A 45-to-60-minute live 1-on-1 coding interview conducted over Google Meet or HackerRank CodePair. Candidates are expected to solve 2 algorithmic problems under strict observation. Interviewers focus on your ability to quickly identify the optimal algorithmic pattern, communicate constraints out loud, and write syntactically correct code without hesitation.
At a glance
- Duration: 45 to 60 minutes
- Questions per round: 2 coding questions
- Coding surface: HackerRank CodePair or Google Docs
- Topics: Greedy algorithms, graph bridges, multi-source BFS, sliding window, BSTs
- Most common: Gas Station, Critical Connections in a Network, Rotting Oranges
| Question (our summary) | What it tests | Level |
|---|---|---|
| Gas Station Circuit Completion | Greedy traversal and running deficit balance tracking | Medium |
| Critical Connections in a Network | Graph depth-first search and Tarjan’s bridge algorithm | Hard |
| Rotting Oranges Grid Simulation | Multi-source breadth-first search and time tracking | Medium |
| Longest Substring Without Repeating Characters | Sliding window and character index hash map | Medium |
| Modify Binary Search Tree to Greater Sum Tree | Reverse in-order traversal and running sum accumulation | Medium |
| Trapping Rain Water Elevation Map | Two pointers and boundary height constraints | Hard |
Stage 4: Onsite technical and design loop
Low-Level Design and machine coding round
How it works. A 60-minute technical interview dedicated to object-oriented Low-Level Design (LLD), machine coding, and core language concurrency. Candidates are given a real-world system requirement (such as BookMyShow or Parking Lot) and must design the class hierarchy, interfaces, and state transitions, write clean code, and handle concurrency locks. The round concludes with deep conceptual probing into Java collection internals and thread synchronization.
At a glance
- Duration: 60 minutes
- Questions per round: 1 core design challenge + Java concurrency deep dive
- Coding surface: Local IDE or collaborative document
- Topics: Object-oriented design patterns, seat locking, thread safety, HashMap internals
- Most common: Design BookMyShow, Design Parking Lot, Two-thread alternating printing
| Question (our summary) | What it tests | Level |
|---|---|---|
| Design BookMyShow Cinema Booking System | Class diagrams, temporary seat locks, and race conditions | SDE-1 / SDE-2 |
| Design Parking Lot Multi-Floor Management | Strategy pattern pricing and vehicle polymorphism | SDE-1 / SDE-2 |
| Design Splitwise Expense Sharing Engine | Expense splitting models and transaction simplification | SDE-2 |
| Alternating Odd and Even Thread Printer | Thread synchronization, wait/notify, and lock coordination | SDE-1 / SDE-2 |
| Java HashMap Collision and Treeification Internals | Hash bucket thresholds, Red-Black trees, and equals contract | All levels |
High-Level System Design round
How it works. A 45-to-60-minute architectural discussion required for SDE-2 and senior engineering candidates. The round tests how you design scalable distributed systems tailored to real-estate platforms, including geospatial proximity search, high-throughput notification fanout, database sharding, and caching strategies.
At a glance
- Duration: 45 to 60 minutes
- Questions per round: 1 scalable distributed architecture challenge
- Coding surface: Collaborative virtual whiteboard (Excalidraw or Miro)
- Topics: Geospatial indexing, message queues, database indexing, rate limiting
- Most common: Real estate proximity search, notification delivery pipeline
| Design (our summary) | What it tests | Level |
|---|---|---|
| Geospatial Real Estate Property Search System | GeoHash / QuadTree indexing, distance radius queries, and caching | SDE-2 / Senior |
| Multi-Channel Property Alert Notification Service | Message queue fanout (Kafka/RabbitMQ) and rate limiting | SDE-2 |
| Database Sharding and B+ Tree Indexing Architecture | Clustered indexing, write partitioning, and query optimization | SDE-2 / Senior |
| Distributed Bot Traffic Rate Limiter | Redis token bucket algorithm and sliding window counters | SDE-2 |
| Idempotent Rent Payment Processing Pipeline | Distributed transactions, payment webhooks, and reconciliation | Senior SDE |
Engineering Manager and cultural fit round
How it works. A 45-minute discussion with an Engineering Manager or Director of Engineering. The conversation focuses on evaluating your architectural decisions on past projects, technical leadership, problem-solving mindset under startup pressure, and alignment with NoBroker's fast-paced engineering culture.
At a glance
- Duration: 45 minutes
- Questions per round: Resume project deep-dive + 3 or 4 behavioral scenarios
- Coding surface: Video conversation over Google Meet
- Topics: Startup culture fit, production outage handling, technical debt, ownership
- Most common: Architectural walk-through of past projects, handling live production bugs
| Prompt (our summary) | What it tests | Level |
|---|---|---|
| Deep dive into your most complex past engineering project | Architectural ownership, technical decisions, and trade-off defense | All levels |
| Resolving a severe production outage caused by your release | Root cause analysis, accountability, and automated mitigation | All levels |
| Balancing rapid feature delivery versus accumulating technical debt | Prioritization, startup engineering mindset, and code quality | All levels |
| Navigating technical disagreements with senior leads or product managers | Collaboration, data-driven reasoning, and proof-of-concept building | All levels |
| Why NoBroker specifically over other high-growth Indian tech startups? | Motivation, product curiosity, and long-term commitment | All levels |
Stage 5: Decision, background verification and offer
How it works. After the final round, interviewers consolidate evaluation notes covering algorithmic problem-solving speed, Low-Level Design maturity, core language depth, and managerial fit. Compensation and leveling are finalized based on interview ratings and competing offers.
Offer discussions typically take place within 3 to 7 business days following the managerial round. Candidates with immediate or 15-day notice periods frequently receive expedited offers.
Experiences shared on Codinzhub
The table below connects candidate accounts from our verified interview records:
| College | Role and result | What was asked |
|---|---|---|
| Tier-1 Engineering College (Bangalore) | SDE-1 · Selected | HackerRank test with Last Stone Weight and anagram character replacements, live coding on Gas Station, and BookMyShow LLD. |
| Top Indian University (NIT) | SDE-2 · Selected | Critical Connections in a Network (Tarjan’s algorithm), BookMyShow concurrency seat locking, and Java HashMap internals. |
| Tier-2 Engineering College (Off-Campus) | SDE-1 · Selected | Kadane’s algorithm, Binary Search Tree to Greater Sum Tree, and Parking Lot multi-floor object-oriented design. |
| Experienced Backend Developer (3 YOE) | SDE-2 · Rejected | Cleared Round 1 DSA but rejected in Low-Level Design due to procedural code structure and lack of design patterns. |
The Codinzhub Next-Round Playbook
Targeted preparation yields the highest return when aligned directly with the demands of each stage. Use the stage-specific drills below:
To get past the Online Assessment
- Focus on priority queues and sliding window problems: Drill problems involving simulation, interval merging, and substring frequency until you can implement solutions cleanly in under 20 minutes.
- Test edge cases before final submission: Validate inputs with zero length, negative numbers, single-element arrays, and extreme constraint bounds ($N = 10^5$) to ensure all hidden test suites pass.
- Optimize Big-O complexity upfront: If an array size reaches $10^5$, an $O(N^2)$ brute-force implementation will trigger a Time Limit Exceeded error. Target an $O(N)$ or $O(N \log N)$ solution.
To get past the live DSA coding round
- Manage your 45-minute budget aggressively: Aim to complete the first problem within 20 minutes so you have at least 25 minutes remaining for the second question.
- Verbalize your brute-force approach immediately: Spend 45 seconds stating the straightforward naive solution, identify the operational bottleneck, and outline your optimal approach before touching the keyboard.
- Dry-run edge cases manually: Trace variable transitions line-by-line using a small 3-element example on screen before declaring your code complete.
To get past the Low-Level Design and machine coding round
- Apply standard design patterns deliberately: Clearly structure your solution using Strategy (for pricing/algorithms), Factory (for entity creation), and Observer (for notifications) patterns rather than writing monolithic procedural code.
- Address multithreading and concurrency locks: When designing reservation systems (such as BookMyShow or Parking Lot), explicitly explain how you prevent double-booking using synchronization, optimistic locking, or distributed Redis locks.
- Master core Java language internals: Be prepared to explain how
HashMaphandles collisions, why treeification occurs at bucket threshold 8, and the strict contract betweenequals()andhashCode().
To get past the High-Level System Design round
- Familiarize yourself with geospatial indexing: Understand how GeoHash and QuadTree indexing enable fast radius queries for property listings within a specific distance.
- Design resilient notification pipelines: Practice architecting message queue fanout systems using Kafka or RabbitMQ with deduplication and consumer rate limiting.
- Explain database indexing mechanics: Clearly articulate the difference between B+ Tree clustered and non-clustered indexes, composite indexing order, and read/write sharding.
To get past the Engineering Manager round
- Prepare detailed project architecture walkthroughs: Be ready to defend every technology choice, database schema, and caching layer you implemented in your previous systems.
- Demonstrate startup agility and ownership: Share concrete examples where you owned a feature end-to-end, debugged production incidents, and delivered under tight deadlines.
- Prepare a genuine answer for "Why NoBroker?": Highlight your interest in real estate tech, zero-brokerage business models, and solving high-scale consumer platform challenges.
How the loop differs by level
Evaluation criteria evolve as candidates move between engineering tiers:
| Level | What candidates describe |
|---|---|
| SDE-1 (0 to 2 YOE) | Heavy emphasis on coding speed, data structures (arrays, strings, trees, graphs), and basic object-oriented principles. Candidates are expected to produce bug-free algorithmic implementations quickly. Low-Level Design focuses on clean class models without heavy distributed architecture. |
| SDE-2 (2 to 5 YOE) | Evaluated rigorously on both algorithmic problem solving and production-grade Low-Level Design. Strong focus on concurrency, multithreading synchronization, and database query optimization. Includes 1 High-Level System Design round on scalable backend services. |
| Senior SDE (5+ YOE) | Focuses primarily on distributed system architecture, high-throughput data pipelines, database scaling, and technical leadership. Interviewers evaluate how candidates handle trade-offs between consistency, availability, and low latency. |
Most-asked topics
NoBroker technical interviews concentrate heavily on practical algorithms, concurrency, and system design patterns:
| Topic | What it means in plain English | Evidence-backed priority | Reported problem examples | Codinzhub practice |
|---|---|---|---|---|
| Low-Level Object-Oriented Design | Designing extensible classes, entities, and design patterns for real-world applications. | Very High (mandatory evaluation in Round 2) | Design BookMyShow, Design Parking Lot, Design Splitwise. | Practice Class Design on Codinzhub |
| Java Internals & Concurrency | Thread synchronization, memory visibility, and collection data structure mechanics. | Very High (frequently probed across all rounds) | HashMap collision treeification, 2-thread printing, ConcurrentHashMap. | Practice Concurrency on Codinzhub |
| Greedy & Sliding Window Algorithms | Optimizing contiguous sequences or making locally optimal choices for global efficiency. | High (dominant in live coding rounds) | Gas Station, Longest Substring Without Repeating Characters, Subarray Product. | Practice Arrays on Codinzhub |
| Graphs & BFS Traversals | Finding shortest transformation paths, bridges, or connected components in a network. | High (frequently tested in technical screens) | Critical Connections in a Network, Rotting Oranges, Course Schedule. | Practice Graphs on Codinzhub |
| Priority Queues & Heaps | Dynamically maintaining extreme elements across high-volume numerical streams. | Medium (common in online assessments) | Last Stone Weight, Merge K Sorted Lists, Top K Frequent Elements. | Practice Heaps on Codinzhub |
| Database Indexing & Geospatial Search | Structuring storage schemas for fast proximity lookups and high write throughput. | Medium (core theme in system design) | Proximity property search with GeoHash, B+ Tree index optimization. | Practice System Design on Codinzhub |
The question patterns that keep coming back
Recognizing core architectural and algorithmic patterns allows you to adapt to new problem variations rapidly:
1. Low-Level Design with Concurrency and Reservation Locks
- How to recognize it: Problems asking you to design a multi-user reservation or allocation system (such as BookMyShow cinema booking or Parking Lot spot management).
- The underlying invariant: A simple object-oriented model fails under concurrent requests. Decouple domain models into modular entities, apply the Strategy pattern for variable business rules (such as pricing or seat tiering), and introduce temporary locking mechanisms (using synchronized blocks or distributed Redis locks) to prevent double-allocation.
- Reported examples: Design BookMyShow, Design Parking Lot, Design Splitwise.
- Preparation action: Practice writing working Java classes with private state invariants and explicit lock coordination.
2. Greedy Circuit and Deficit Tracking
- How to recognize it: Problems involving cyclical circuits with costs and gains (such as traveling through gas stations around a ring road).
- The underlying invariant: If the total gain is greater than or equal to the total cost, a valid starting position exists. Maintain a running deficit balance; whenever the balance drops below zero, reset the start candidate to the next index and carry forward the deficit.
- Reported examples: Gas Station, Minimum Fuel Cost to Report to the Capital.
- Preparation action: Drill single-pass greedy invariants where maintaining cumulative sums eliminates nested loops.
3. Multi-Source Breadth-First Search on Grids
- How to recognize it: 2D grid problems where multiple initial sources trigger simultaneous spreading or infection (such as rotten oranges rotting adjacent fresh fruit minute by minute).
- The underlying invariant: Add all initial source coordinates into a queue upfront. Process the queue level-by-level, incrementing time only after exhausting all nodes at the current distance tier.
- Reported examples: Rotting Oranges, 01 Matrix, Shortest Path in Binary Matrix.
- Preparation action: Practice writing clean BFS queue loops with boundary validity helper methods.
4. Graph Bridges and Articulation Points
- How to recognize it: Networks where identifying vulnerabilities or single points of failure is required (such as critical server connections whose disruption disconnects the network).
- The underlying invariant: Use Tarjan’s algorithm with depth-first search. Maintain discovery timestamps and lowest reachable ancestor values; an edge $(u, v)$ is a critical bridge if the lowest reachable node from $v$ has a discovery timestamp strictly greater than $u$.
- Reported examples: Critical Connections in a Network.
- Preparation action: Implement Tarjan’s bridge-finding algorithm from memory, paying close attention to avoiding parent edge backtracking.
Preparing for NoBroker culture and managerial interviews
The Engineering Manager round evaluates whether you thrive in high-ownership, fast-paced startup environments:
Core Cultural Competencies
- Technical Ownership: Demonstrating that you take full responsibility for features from initial architecture through deployment, monitoring, and post-launch bug fixing.
- Startup Agility and Speed: Demonstrating comfort with evolving specifications, short sprint deadlines, and shipping reliable code under practical constraints.
- System Resilience and Accountability: Handling production incidents constructively, learning from technical mistakes, and implementing automated testing guards.
- Data-Driven Communication: Defending architectural decisions using objective performance benchmarks, scalability metrics, and business impact rather than personal opinions.
5 STAR Stories Every Candidate Should Prepare
Structure every behavioral answer using the STAR framework: Situation, Task, Action, and Result.
| Story prompt | Core focus | What interviewers evaluate |
|---|---|---|
| Walking through a complex backend architecture | Architectural reasoning and trade-offs | Deep ownership of database schemas, caching layers, and bottlenecks you personally resolved. |
| Diagnosing and fixing a critical production incident | Accountability and root-cause analysis | Immediate mitigation, clear communication during outages, and post-mortem preventative fixes. |
| Delivering a feature under an aggressive sprint deadline | Prioritization and startup execution | Breaking scope into testable milestones, shipping MVPs, and managing technical debt tickets. |
| Resolving a technical disagreement with a team member | Constructive communication | Prototyping proof-of-concept benchmarks to resolve architectural debates objectively. |
| Why NoBroker specifically over other tech startups? | Motivation and product awareness | Understanding zero-brokerage consumer platforms, real estate search, and fintech payment workflows. |
A six-week plan
This structured roadmap assumes two to three focused hours of daily preparation:
- Week 1: Core DSA fundamentals and sliding window. Solve array manipulations, prefix sums, two-pointer techniques, and string frequency problems under 20-minute timers.
- Week 2: Greedy algorithms, heaps, and priority queues. Master greedy interval scheduling, Gas Station variants, and priority queue simulation problems like Last Stone Weight.
- Week 3: Graphs, BFS traversals, and trees. Practice multi-source BFS (Rotting Oranges), graph cycle detection, Tarjan’s bridge algorithm, and BST manipulations.
- Week 4: Low-Level Design and machine coding. Implement BookMyShow, Parking Lot, and Splitwise in clean object-oriented Java code, applying Factory and Strategy design patterns.
- Week 5: Java internals, multithreading, and system design. Study HashMap collision treeification, 2-thread alternating printing, database indexing (B+ Trees), and geospatial search architectures.
- Week 6: Timed mock interviews and managerial preparation. Practice solving 2 Medium problems in 45 minutes on a collaborative editor, refine your 5 STAR stories, and review project architectures.
Practice problems that match these experiences
The practice problems below reflect the algorithmic patterns and invariants observed in candidate accounts:
| # | Practice problem | Pattern | Seen in these experiences as |
|---|---|---|---|
| 1 | Gas Station | Greedy & Running Balance | Cyclical circuit traversal with running deficit tracking |
| 2 | Critical Connections in a Network | Graph DFS & Tarjan’s Algorithm | Critical bridge detection in communication networks |
| 3 | Rotting Oranges | Multi-Source BFS | Grid simulation of spreading contamination over time |
| 4 | Longest Substring Without Repeating Characters | Sliding Window & Hash Map | Dynamic character frequency window expansion |
| 5 | Last Stone Weight | Max-Heap / Priority Queue | Heavy element pairing and simulation reduction |
| 6 | Merge Intervals | Sorting & Intervals | Merging contiguous overlapping scheduling intervals |
| 7 | Maximum Subarray | Kadane’s Algorithm | Maximum contiguous range sum optimization |
| 8 | Subarray Product Less Than K | Sliding Window | Counting valid contiguous subarray product bounds |
| 9 | Print Zero Even Odd | Concurrency Synchronization | Alternating multi-thread number coordination |
| 10 | Trapping Rain Water | Two Pointers / Monotonic Stack | Computing elevation boundary water retention |
How to handle a question you have never seen
The true test in a live NoBroker coding interview is how you reason through an unfamiliar problem under strict time pressure. Follow this structured 6-step method:
- Clarify constraints and edge cases out loud (0 to 3 minutes): Repeat the problem statement in your own words. Confirm input scale bounds ($N \le 10^5$), duplicate values, negative numbers, and empty inputs.
- State a working brute-force baseline (3 to 5 minutes): Never stay silent while thinking. Verbalize the straightforward naive approach and state its time and space complexity ($O(N^2)$ or $O(2^N)$).
- Identify the computational bottleneck (5 to 8 minutes): Explain why the brute force is inefficient:
- Too many repeated lookups? Suggest a Hash Map ($O(1)$ lookup).
- Repeatedly retrieving extreme values? Propose a Heap ($O(\log N)$).
- Recalculating overlapping subarray sums? Introduce Prefix Sums or a Sliding Window.
- Agree on the approach before typing (8 to 10 minutes): Confirm the optimal strategy with the interviewer: "If I use a sliding window maintaining last-seen indices, I can achieve $O(N)$ runtime with $O(K)$ space. Does that direction look good to you?"
- Write clean, modular code while speaking (10 to 25 minutes): Talk as you type. Name variables descriptively, handle boundary guards at the top of functions, and structure complex logic into helper methods.
- Dry-run a custom test case before finishing (25 to 30 minutes): Trace a small 3-element test case line-by-line through your code. Catching your own boundary bug during a manual dry run demonstrates engineering maturity.
Why candidates were rejected
Candidate accounts show that rejections typically stem from the following recurring issues:
1. Slow pacing and running out of time in Round 1
- What happened: Candidates spent 30 to 35 minutes debating and coding the first question, leaving only 10 minutes for the second problem.
- Why it failed: Round 1 explicitly tests your ability to solve 2 complete problems in 45 minutes. Failing to complete the second question results in an automatic negative score.
2. Writing procedural code without design patterns in Low-Level Design
- What happened: In Round 2 (e.g. Design BookMyShow or Parking Lot), candidates wrote monolithic procedural functions with massive
if-elseblocks instead of defining clean class models. - Why it failed: NoBroker evaluates engineering extensibility. Inattention to object-oriented design patterns (Strategy, Factory) signals a lack of software craftsmanship.
3. Superficial knowledge of Java collection internals and concurrency
- What happened: Candidates stated they use
HashMapandArrayListbut could not explain how hash collisions are resolved internally or struggled to synchronize two threads. - Why it failed: NoBroker’s backend heavily relies on high-concurrency Java microservices. Weak fundamentals raise red flags regarding production reliability.
4. Poor communication during live problem solving
- What happened: Candidates read the prompt and immediately typed in silence for 15 minutes without explaining their logic.
- Why it failed: Interviewers score collaboration and thought process. Coding in silence prevents the interviewer from evaluating your analytical reasoning or providing guidance.
Selected vs. rejected: do this, not that
The table below contrasts the observable behaviors of accepted candidates against rejected accounts:
| Do this (what selected candidates did) | Not that (what rejected candidates did) | Why it matters |
|---|---|---|
| Manage time aggressively in coding rounds: Solved problem 1 within 20 minutes to preserve adequate time for problem 2. | Spent 35 minutes perfecting problem 1: Left only 10 minutes for the second question and ran out of time. | Completing both algorithmic questions is a strict baseline requirement for Round 1. |
| Apply clean OOP design patterns in LLD: Structured machine coding solutions using Factory, Strategy, and decoupled interfaces. | Wrote procedural script code: Crammed business logic, pricing rules, and data storage into monolithic single-file classes. | Low-Level Design evaluates modular architecture and enterprise maintainability. |
| Know core Java language mechanics in depth: Clearly explained HashMap treeification, equals/hashCode contracts, and multithreading locks. | Treated data structures as black boxes: Could not explain how hash collections behave under heavy collision contention. | High-concurrency backend services require deep runtime performance awareness. |
| Dry-ran code with custom test cases: Traced logic line-by-line with sample inputs before telling the interviewer they were finished. | Relied on interviewers to spot bugs: Declared code done immediately and left boundary bugs and syntax errors to be caught by the panel. | Catching your own edge-case bugs during a dry run demonstrates engineering rigor. |
| Defended past architectural decisions with metrics: Walked through database schemas, caching trade-offs, and throughput numbers in manager rounds. | Gave vague, high-level project overviews: Struggled to explain personal technical ownership or scaling bottlenecks in past systems. | Engineering managers evaluate hands-on technical depth and product ownership. |
If you remember only five things
If your NoBroker interview is approaching and you need the five most vital takeaways, keep these in mind:
- Speed is decisive in Round 1: Practice solving 2 LeetCode Medium problems in 45 minutes; pace yourself to finish question 1 within 20 minutes.
- Master Low-Level Design patterns: Be ready to design BookMyShow, Parking Lot, or Splitwise using clean Strategy, Factory, and modular class hierarchies.
- Review Java collections and concurrency: Understand HashMap internal mechanics, thread synchronization (
wait/notify), and concurrent collections thoroughly. - Dry-run edge cases manually: Always trace a 3-element test case line-by-line to verify pointer transitions and boundary guards before declaring completion.
- Prepare for architectural project deep-dives: Be ready to walk through past microservice designs, database indexing choices, and production incident post-mortems in the manager round.
Frequently asked questions (FAQ)
Is there an online assessment for all applicants?
In our reviewed accounts, online assessments were deployed primarily for campus recruitment drives, hackathons, and select off-campus portal applications on Naukri. Candidates with direct employee referrals or strong past experience frequently bypassed the automated test and moved directly to live technical rounds.
Can I interview in Python or C++ instead of Java?
Yes. Candidates are permitted to write algorithmic solutions in Python, C++, or Go during Round 1. However, because NoBroker's backend infrastructure is predominantly built on Java, candidates interviewing for backend SDE roles should be prepared for deep questions on Java collection internals, memory models, and multithreading.
What is the structure of the Low-Level Design round?
The Low-Level Design round (Round 2) typically lasts 60 minutes. You are presented with a practical system scenario (such as BookMyShow or Parking Lot) and expected to design the class hierarchy, write working object-oriented code, apply design patterns, and explain how you prevent concurrent race conditions.
Is High-Level System Design asked for SDE-1 candidates?
No. For SDE-1 roles (0 to 2 years of experience), system design is restricted to object-oriented Low-Level Design and machine coding. High-Level distributed system design rounds (covering caching, message queues, and database sharding) are reserved for SDE-2 and senior engineering candidates.
How long does the NoBroker hiring process take?
The hiring loop at NoBroker moves relatively fast compared to traditional MNCs. Technical rounds are often completed within 1 to 2 weeks, with final offer decisions delivered within 3 to 7 business days following the managerial conversation.
Other company and role guides
- Zomato SDE 1 interview guide
- Navi software engineer interview guide
- Juspay software engineer interview guide
- Flipkart software engineer interview guide
- Teradata Software Development Engineer guide
About this guide and methodology
This guide was researched, written, and audited by the Codinzhub Editorial Team. It synthesizes 16 verified candidate reports, public NoBroker engineering interview accounts, and Codinzhub practice datasets covering the 2024 to 2026 hiring cycles.
All reported questions reflect verbatim candidate retrospectives or faithful paraphrases. Practice problem mappings reference established algorithmic drills on Codinzhub and LeetCode.
Disclaimer: Hiring policies, interview formats, and team evaluation rubrics evolve over time. This guide reflects historical candidate reports and does not constitute an official statement by NoBroker Technologies. Always verify current stage structures and tooling requirements with your assigned recruiter.
Search the question bank
The questions from each round above, with practice links for similar problems. Log in to search every question we collected for this role, including questions shared on Codinzhub.
Showing 20 of 54 questions
Minimum Square Side
A NoBroker online assessment question shared on Codinzhub (IIT Guwahati).
Reverse String After K Blinks
A NoBroker online assessment question shared on Codinzhub (IIT Guwahati).
Stable Negative-Zero-Positive Partition
A NoBroker online assessment question shared on Codinzhub (IIT Guwahati).
Maximum Alternating Subarray Sum
A NoBroker online assessment question shared on Codinzhub (PYQ).
Last Nodes Sum at Every Level
A NoBroker online assessment question shared on Codinzhub (PYQ).
Last Stone Weight
Level: Easy / Medium.
Minimum Character Replacements to Make Anagrams
Topic: String frequency counting and character divergence.
Subarray Product Less Than K
Topic: Sliding window and dynamic pointer bounds.
Merge Intervals
Topic: Interval sorting and contiguous overlap merging.
Maximum Subarray Sum
Topic: Kadane’s algorithm and dynamic programming.
Gas Station Circuit Completion
Topic: Greedy traversal and running deficit balance tracking.
Critical Connections in a Network
Topic: Graph depth-first search and Tarjan’s bridge algorithm.
Rotting Oranges Grid Simulation
Topic: Multi-source breadth-first search and time tracking.
Longest Substring Without Repeating Characters
Topic: Sliding window and character index hash map.
Modify Binary Search Tree to Greater Sum Tree
Topic: Reverse in-order traversal and running sum accumulation.
Trapping Rain Water Elevation Map
Topic: Two pointers and boundary height constraints.
Design BookMyShow Cinema Booking System
Level: SDE-1 / SDE-2.
Design Parking Lot Multi-Floor Management
Level: SDE-1 / SDE-2.
Design Splitwise Expense Sharing Engine
Level: SDE-2.
Alternating Odd and Even Thread Printer
Level: SDE-1 / SDE-2.
Keep preparing on Codinzhub
- NoBroker interview questions and experiences — OA questions and interview experiences candidates shared for NoBroker.
- Browse NoBroker online assessment questions — filter the Codinzhub question bank by company.
- Alight Solutions Software Development Engineer interview guide — the Alight Solutions process, rounds and question patterns.
- Teradata Software Development Engineer interview guide — the Teradata process, rounds and question patterns.
- Amazon Software Engineer interview guide — the Amazon process, rounds and question patterns.
- All company interview guides — every guide on the Codinzhub blog.
Keep track of what you’ve learned.