Jobra
🐞Step 1 of Jobra:AI Debugging Rounds
DSA+AIPreparing you for both.
JOBRA · AI DEBUG ROUND (PREVIEW)sum.cpp
// buggy snippet
int total(vector<int>& a, int n) {
    int sum = 0;
    for (int i = 0; i <= n; i++) { // 🐞        sum += a[i];
    }
    return sum;
}
A real codebase. A real bug. You + AI.

Jobra drops you into a broken repo. Find it, fix it, ship it. AI helps you debug like on the job.

Prompt:Correct the loop condition
Tap 'Let Jobra fix it' below to simulate AI debugging...

How to Crack NoBroker: The Software Development Engineer Interview, From Real Experiences

22 min read

A complete, evidence-based breakdown of NoBroker's SDE interview process, covering coding speed, Low-Level Design (LLD), Java internals, and manager rounds.

In this article
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() versus hashCode() 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:

ChannelWhat candidates said
Naukri.com and Job PortalsThe most common hiring channel for off-campus and lateral SDE roles. Recruiters actively reach out to candidates matching immediate notice period criteria.
Employee ReferralReported as the fastest channel. Candidates referred by current NoBroker engineers typically received screening calls within 3 to 7 business days.
LinkedIn InMail OutreachCommon for mid-level (SDE-2) and backend engineers with 2 to 4 years of experience building scalable microservices.
University Campus RecruitmentConducted 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 testsLevel
Last Stone WeightMax-heap simulation and dynamic priority reductionEasy / Medium
Minimum Character Replacements to Make AnagramsString frequency counting and character divergenceMedium
Subarray Product Less Than KSliding window and dynamic pointer boundsMedium
Merge IntervalsInterval sorting and contiguous overlap mergingMedium
Maximum Subarray SumKadane’s algorithm and dynamic programmingMedium

NoBroker OA questions shared on Codinzhub:

QuestionDriveTopic
Minimum Square SideIIT GuwahatiBinary search, geometry
Reverse String After K BlinksIIT GuwahatiStrings, simulation
Stable Negative-Zero-Positive PartitionIIT GuwahatiTwo pointers, partitioning
Maximum Alternating Subarray SumPYQDP, Kadane
Last Nodes Sum at Every LevelPYQTree 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 testsLevel
Gas Station Circuit CompletionGreedy traversal and running deficit balance trackingMedium
Critical Connections in a NetworkGraph depth-first search and Tarjan’s bridge algorithmHard
Rotting Oranges Grid SimulationMulti-source breadth-first search and time trackingMedium
Longest Substring Without Repeating CharactersSliding window and character index hash mapMedium
Modify Binary Search Tree to Greater Sum TreeReverse in-order traversal and running sum accumulationMedium
Trapping Rain Water Elevation MapTwo pointers and boundary height constraintsHard

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 testsLevel
Design BookMyShow Cinema Booking SystemClass diagrams, temporary seat locks, and race conditionsSDE-1 / SDE-2
Design Parking Lot Multi-Floor ManagementStrategy pattern pricing and vehicle polymorphismSDE-1 / SDE-2
Design Splitwise Expense Sharing EngineExpense splitting models and transaction simplificationSDE-2
Alternating Odd and Even Thread PrinterThread synchronization, wait/notify, and lock coordinationSDE-1 / SDE-2
Java HashMap Collision and Treeification InternalsHash bucket thresholds, Red-Black trees, and equals contractAll 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 testsLevel
Geospatial Real Estate Property Search SystemGeoHash / QuadTree indexing, distance radius queries, and cachingSDE-2 / Senior
Multi-Channel Property Alert Notification ServiceMessage queue fanout (Kafka/RabbitMQ) and rate limitingSDE-2
Database Sharding and B+ Tree Indexing ArchitectureClustered indexing, write partitioning, and query optimizationSDE-2 / Senior
Distributed Bot Traffic Rate LimiterRedis token bucket algorithm and sliding window countersSDE-2
Idempotent Rent Payment Processing PipelineDistributed transactions, payment webhooks, and reconciliationSenior 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 testsLevel
Deep dive into your most complex past engineering projectArchitectural ownership, technical decisions, and trade-off defenseAll levels
Resolving a severe production outage caused by your releaseRoot cause analysis, accountability, and automated mitigationAll levels
Balancing rapid feature delivery versus accumulating technical debtPrioritization, startup engineering mindset, and code qualityAll levels
Navigating technical disagreements with senior leads or product managersCollaboration, data-driven reasoning, and proof-of-concept buildingAll levels
Why NoBroker specifically over other high-growth Indian tech startups?Motivation, product curiosity, and long-term commitmentAll 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:

CollegeRole and resultWhat was asked
Tier-1 Engineering College (Bangalore)SDE-1 · SelectedHackerRank test with Last Stone Weight and anagram character replacements, live coding on Gas Station, and BookMyShow LLD.
Top Indian University (NIT)SDE-2 · SelectedCritical Connections in a Network (Tarjan’s algorithm), BookMyShow concurrency seat locking, and Java HashMap internals.
Tier-2 Engineering College (Off-Campus)SDE-1 · SelectedKadane’s algorithm, Binary Search Tree to Greater Sum Tree, and Parking Lot multi-floor object-oriented design.
Experienced Backend Developer (3 YOE)SDE-2 · RejectedCleared 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

  1. 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.
  2. 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.
  3. 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

  1. 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.
  2. 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.
  3. 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

  1. 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.
  2. 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.
  3. Master core Java language internals: Be prepared to explain how HashMap handles collisions, why treeification occurs at bucket threshold 8, and the strict contract between equals() and hashCode().

To get past the High-Level System Design round

  1. Familiarize yourself with geospatial indexing: Understand how GeoHash and QuadTree indexing enable fast radius queries for property listings within a specific distance.
  2. Design resilient notification pipelines: Practice architecting message queue fanout systems using Kafka or RabbitMQ with deduplication and consumer rate limiting.
  3. 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

  1. Prepare detailed project architecture walkthroughs: Be ready to defend every technology choice, database schema, and caching layer you implemented in your previous systems.
  2. Demonstrate startup agility and ownership: Share concrete examples where you owned a feature end-to-end, debugged production incidents, and delivered under tight deadlines.
  3. 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:

LevelWhat 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:

TopicWhat it means in plain EnglishEvidence-backed priorityReported problem examplesCodinzhub practice
Low-Level Object-Oriented DesignDesigning 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 & ConcurrencyThread 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 AlgorithmsOptimizing 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 TraversalsFinding 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 & HeapsDynamically 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 SearchStructuring 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

  1. Technical Ownership: Demonstrating that you take full responsibility for features from initial architecture through deployment, monitoring, and post-launch bug fixing.
  2. Startup Agility and Speed: Demonstrating comfort with evolving specifications, short sprint deadlines, and shipping reliable code under practical constraints.
  3. System Resilience and Accountability: Handling production incidents constructively, learning from technical mistakes, and implementing automated testing guards.
  4. 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 promptCore focusWhat interviewers evaluate
Walking through a complex backend architectureArchitectural reasoning and trade-offsDeep ownership of database schemas, caching layers, and bottlenecks you personally resolved.
Diagnosing and fixing a critical production incidentAccountability and root-cause analysisImmediate mitigation, clear communication during outages, and post-mortem preventative fixes.
Delivering a feature under an aggressive sprint deadlinePrioritization and startup executionBreaking scope into testable milestones, shipping MVPs, and managing technical debt tickets.
Resolving a technical disagreement with a team memberConstructive communicationPrototyping proof-of-concept benchmarks to resolve architectural debates objectively.
Why NoBroker specifically over other tech startups?Motivation and product awarenessUnderstanding 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:

  1. Week 1: Core DSA fundamentals and sliding window. Solve array manipulations, prefix sums, two-pointer techniques, and string frequency problems under 20-minute timers.
  2. Week 2: Greedy algorithms, heaps, and priority queues. Master greedy interval scheduling, Gas Station variants, and priority queue simulation problems like Last Stone Weight.
  3. Week 3: Graphs, BFS traversals, and trees. Practice multi-source BFS (Rotting Oranges), graph cycle detection, Tarjan’s bridge algorithm, and BST manipulations.
  4. 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.
  5. Week 5: Java internals, multithreading, and system design. Study HashMap collision treeification, 2-thread alternating printing, database indexing (B+ Trees), and geospatial search architectures.
  6. 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 problemPatternSeen in these experiences as
1Gas StationGreedy & Running BalanceCyclical circuit traversal with running deficit tracking
2Critical Connections in a NetworkGraph DFS & Tarjan’s AlgorithmCritical bridge detection in communication networks
3Rotting OrangesMulti-Source BFSGrid simulation of spreading contamination over time
4Longest Substring Without Repeating CharactersSliding Window & Hash MapDynamic character frequency window expansion
5Last Stone WeightMax-Heap / Priority QueueHeavy element pairing and simulation reduction
6Merge IntervalsSorting & IntervalsMerging contiguous overlapping scheduling intervals
7Maximum SubarrayKadane’s AlgorithmMaximum contiguous range sum optimization
8Subarray Product Less Than KSliding WindowCounting valid contiguous subarray product bounds
9Print Zero Even OddConcurrency SynchronizationAlternating multi-thread number coordination
10Trapping Rain WaterTwo Pointers / Monotonic StackComputing 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:

  1. 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.
  2. 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)$).
  3. 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.
  4. 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?"
  5. 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.
  6. 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-else blocks 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 HashMap and ArrayList but 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:

  1. Speed is decisive in Round 1: Practice solving 2 LeetCode Medium problems in 45 minutes; pace yourself to finish question 1 within 20 minutes.
  2. Master Low-Level Design patterns: Be ready to design BookMyShow, Parking Lot, or Splitwise using clean Strategy, Factory, and modular class hierarchies.
  3. Review Java collections and concurrency: Understand HashMap internal mechanics, thread synchronization (wait/notify), and concurrent collections thoroughly.
  4. 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.
  5. 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


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).

    On CodinzhubIIT GuwahatiBinary search, geometryCodingOnline assessment
  • Reverse String After K Blinks

    A NoBroker online assessment question shared on Codinzhub (IIT Guwahati).

    On CodinzhubIIT GuwahatiStrings, simulationCodingOnline assessment
  • Stable Negative-Zero-Positive Partition

    A NoBroker online assessment question shared on Codinzhub (IIT Guwahati).

    On CodinzhubIIT GuwahatiTwo pointers, partitioningCodingOnline assessment
  • Maximum Alternating Subarray Sum

    A NoBroker online assessment question shared on Codinzhub (PYQ).

    On CodinzhubPYQDP, KadaneCodingOnline assessment
  • Last Nodes Sum at Every Level

    A NoBroker online assessment question shared on Codinzhub (PYQ).

    On CodinzhubPYQTree BFSCodingOnline assessment
  • Last Stone Weight

    Level: Easy / Medium.

    Max-heap simulation and dynamic priority reductionCodingOnline assessment
  • Minimum Character Replacements to Make Anagrams

    Topic: String frequency counting and character divergence.

    String frequency counting and character divergenceCodingMediumOnline assessment
  • Subarray Product Less Than K

    Topic: Sliding window and dynamic pointer bounds.

    Sliding window and dynamic pointer boundsCodingMediumOnline assessment
  • Merge Intervals

    Topic: Interval sorting and contiguous overlap merging.

    Interval sorting and contiguous overlap mergingCodingMediumOnline assessment
  • Maximum Subarray Sum

    Topic: Kadane’s algorithm and dynamic programming.

    Kadane’s algorithm and dynamic programmingCodingMediumOnline assessment
  • Gas Station Circuit Completion

    Topic: Greedy traversal and running deficit balance tracking.

    Greedy traversal and running deficit balance trackingCodingMediumRound not stated
  • Critical Connections in a Network

    Topic: Graph depth-first search and Tarjan’s bridge algorithm.

    Graph depth-first search and Tarjan’s bridge algorithmCodingHardRound not stated
  • Rotting Oranges Grid Simulation

    Topic: Multi-source breadth-first search and time tracking.

    Multi-source breadth-first search and time trackingCodingMediumRound not stated
  • Longest Substring Without Repeating Characters

    Topic: Sliding window and character index hash map.

    Sliding window and character index hash mapCodingMediumRound not stated
  • Modify Binary Search Tree to Greater Sum Tree

    Topic: Reverse in-order traversal and running sum accumulation.

    Reverse in-order traversal and running sum accumulationCodingMediumRound not stated
  • Trapping Rain Water Elevation Map

    Topic: Two pointers and boundary height constraints.

    Two pointers and boundary height constraintsCodingHardRound not stated
  • Design BookMyShow Cinema Booking System

    Level: SDE-1 / SDE-2.

    Class diagrams, temporary seat locks, and race conditionsCodingRound not stated
  • Design Parking Lot Multi-Floor Management

    Level: SDE-1 / SDE-2.

    Strategy pattern pricing and vehicle polymorphismCodingRound not stated
  • Design Splitwise Expense Sharing Engine

    Level: SDE-2.

    Expense splitting models and transaction simplificationCodingRound not stated
  • Alternating Odd and Even Thread Printer

    Level: SDE-1 / SDE-2.

    Thread synchronization, wait/notify, and lock coordinationCodingRound not stated
Page 1 of 3

Keep preparing on Codinzhub

Ready for the next topic?

Keep track of what you’ve learned.