As a Software Engineer at INDmoney, you are at the core of a mission to simplify financial management and wealth creation for millions of users. You will be responsible for building, scaling, and maintaining the robust backend systems and intuitive frontend interfaces that power our investment, tracking, and advisory platforms. Your work directly influences how users manage their net worth, execute trades, and interact with complex financial data in real time. This role is both technically demanding and strategically significant. You will tackle challenges related to high-concurrency systems, distributed architecture, and secure data handling, all while ensuring a seamless user experience. Whether you are optimizing a Go-based microservice or refining a React-based interface, your contribution ensures that INDmoney remains a reliable and performant tool for our users. Expect to work in a fast-paced environment where your technical decisions have an immediate, visible impact on the product. ##### Tip The engineering culture at INDmoney is highly pragmatic. Interviewers prioritize candidates who can demonstrate mastery in their chosen stack while showing a deep understanding of core computer science fundamentals.
Recruiter Screening
reportedInitial screening by a recruiter to assess candidate fit for the role.
What to demonstrate
- Initial screening by a recruiter to assess candidate fit for the role
- Depth in Go (Golang)
How to prepare
- Be able to walk your CV end to end in two minutes, and say why this company specifically.
- Have your salary expectations, notice period and location constraints ready, and ask for the rest of the loop in writing.
Technical Interviews
reportedSeries of technical interviews focusing on specific domain expertise (backend, frontend, or infrastructure).
What to demonstrate
- Series of technical interviews focusing on specific domain expertise (backend, frontend, or infrastructure)
- Depth in Go (Golang)
How to prepare
- Answer aloud and timed: How would you handle string manipulation tasks efficiently in a high-traffic environment?
- Answer aloud and timed: Solve a problem involving a Priority Queue or heap-based structure.
Leadership Rounds
reportedDiscussions about past projects and architectural decisions with leadership.
What to demonstrate
- Discussions about past projects and architectural decisions with leadership
- Depth in Go (Golang)
How to prepare
- Answer aloud and timed: Write code to remove duplicates from a linked list.
- Answer aloud and timed: How would you design a ledger system to ensure transactional integrity?
PracHub editorial advice for the preparation topics above.
Going into the loop without having done this.
Own your projects: Be ready to deep-dive into any project listed on your resume. You should be able to explain the "why" behind every major technical choice you made.
Going into the loop without having done this.
Be prepared for live coding: Whether it is a DSA problem or a machine coding round, practice coding in a shared document or editor without the help of IDE autocomplete.
Going into the loop without having done this.
Ask clarifying questions: In system design rounds, do not start drawing boxes immediately. Ask about scale, traffic patterns, and constraints first.
Going into the loop without having done this.
Master the fundamentals: Regardless of the role, brush up on ACID properties, networking basics, and common design patterns.
Choose a category, try a prompt, then open its approach, worked solution or follow-up when you need it.
Implement a solution for the Coin Change problem.
Implement a solution for the Coin Change problem.
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
Explain the logic behind a Binary Search implementation and its complexity.
Explain the logic behind a Binary Search implementation and its complexity.
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
How would you handle string manipulation tasks efficiently in a high-traffic environment?
How would you handle string manipulation tasks efficiently in a high-traffic environment?
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
Solve a problem involving a Priority Queue or heap-based structure.
Solve a problem involving a Priority Queue or heap-based structure.
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
Write code to remove duplicates from a linked list.
Write code to remove duplicates from a linked list.
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
Discuss the trade-offs between SQL and NoSQL databases in the context of our financial products.
Discuss the trade-offs between SQL and NoSQL databases in the context of our financial products.
Approach
- Name the grain you start from and join outward from it.
- Check whether any join is one-to-many before aggregating, or the sums inflate.
- Say which index the query would use, and what makes it unusable.
- Handle the rows that do not match: that is usually the actual question.
Follow-up
- How does the query change if that join becomes one-to-many?
- What happens to this when the table is ten times larger?
Find version gaps and relay lag with window functions
outbox_event holds event_id, aggregate_type, aggregate_id, aggregate_version, event_type, payload, status ('pending','published','dead'), attempts, created_at, published_at. A projection is missing rows and you must decide whether the relay skipped events or the consumer dropped them. Write three queries over the last seven days: one listing every aggregate_id whose published aggregate_version sequence has a hole, one giving per-day counts with a running total, and one returning the newest published event per aggregate. For each, say where the window function is evaluated relative to WHERE and LIMIT. PostgreSQL 16.
Approach
- Gaps: compute lead(aggregate_version) OVER (PARTITION BY aggregate_id ORDER BY aggregate_version) in a subquery, then filter next_version <> aggregate_version + 1 in the outer query. Window functions are evaluated after WHERE, GROUP BY and HAVING and before the outer ORDER BY and LIMIT, so the predicate cannot sit in the same WHERE clause and PostgreSQL 16 has no QUALIFY.
- Say what the seven-day filter does to the answer: it truncates every partition, so the first row per aggregate has no predecessor inside the window and a hole spanning the boundary is invisible. Widen the window, or join to resource.version as the authority for the true maximum.
- Running total: SELECT date_trunc('day', created_at) AS d, count() AS n, sum(count()) OVER (ORDER BY date_trunc('day', created_at) ROWS UNBOUNDED PRECEDING). An aggregate inside a window call is legal because grouping runs before windowing. The grouping key is unique per row here so ROWS and RANGE agree, but write the frame anyway — over ungrouped rows with tied timestamps the default RANGE frame pulls in every peer row and the total jumps.
- Newest per aggregate: DISTINCT ON (aggregate_id) ... ORDER BY aggregate_id, aggregate_version DESC is the cheap PostgreSQL-only form when an index matches that order; row_number() OVER (PARTITION BY aggregate_id ORDER BY aggregate_version DESC) = 1 is the portable form and needs a subquery for the same evaluation-order reason as the gap query.
Follow-up
- Relay failover redelivers events. Does a duplicate break the gap query, and how would you detect one from this table alone?
- Turn the gap check into a continuous monitor rather than a query someone runs after an incident. What does it watch?
How would you design a ledger system to ensure transactional integrity?
How would you design a ledger system to ensure transactional integrity?
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- State the consistency you need, and where you are willing to be stale.
Follow-up
- What breaks first when traffic grows ten times?
- How does this behave when that dependency is down for an hour?
Explain the architecture required to show real-time updates (e.g., top gainers/losers) to thousands of concurr
Explain the architecture required to show real-time updates (e.g., top gainers/losers) to thousands of concurrent users.
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- State the consistency you need, and where you are willing to be stale.
Follow-up
- What breaks first when traffic grows ten times?
- How does this behave when that dependency is down for an hour?
How do you approach Database Design for a high-frequency trading or investment app?
How do you approach Database Design for a high-frequency trading or investment app?
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- State the consistency you need, and where you are willing to be stale.
Follow-up
- What breaks first when traffic grows ten times?
- How does this behave when that dependency is down for an hour?
Describe your strategy for Disaster Recovery (DR) and maintaining service availability.
Describe your strategy for Disaster Recovery (DR) and maintaining service availability.
Approach
- Fix the scope first: who calls this, how often, and what they do when it fails.
- Name the read and write paths separately; they rarely have the same bottleneck.
- Choose a partition key and say what query it makes expensive.
- State the consistency you need, and where you are willing to be stale.
Follow-up
- What breaks first when traffic grows ten times?
- How does this behave when that dependency is down for an hour?
Explain ACID properties and their implementation in database transactions.
Explain ACID properties and their implementation in database transactions.
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
Compare var, let, and const in JavaScript and explain their scope.
Compare var, let, and const in JavaScript and explain their scope.
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
How do Goroutines and worker pools function in Go?
How do Goroutines and worker pools function in Go?
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
Describe the core concepts of Spring Boot, specifically Dependency Injection and REST API design.
Describe the core concepts of Spring Boot, specifically Dependency Injection and REST API design.
Approach
- Say who the caller is and what they do when the call fails halfway.
- Define the identity of a request so a retry cannot double-apply it.
- Separate accepted, pending, failed and confirmed; they are different facts.
- Design the error taxonomy before the success shape; callers branch on it.
Follow-up
- What happens if the caller retries after a timeout?
- How does a client discover it is on an old version of this contract?
What are the common performance bottlenecks in React applications and how do you resolve them?
What are the common performance bottlenecks in React applications and how do you resolve them?
Approach
- Clarify what is being asked and what a complete answer contains.
- State your assumptions explicitly before working the problem.
- Say what you would check first and why it is the highest-information step.
- Work from the requirement backwards to the design.
Follow-up
- What assumption would you test first?
- How would you know your answer was wrong?
One customer endpoint stalls deliveries to every other destination
The egress service delivers about 1.5k webhooks/second across 40,000 destinations, with a per-destination concurrency cap of 4 and a 10-second connect-plus-read timeout. Throughput falls to 300/second, queue depth climbs, and p99 delivery latency for unaffected destinations goes from 200 ms to minutes, while the error rate barely moves. One tenant holds 900 destination rows whose URLs share a hostname that now answers in 9.5 seconds. Explain the mechanism with the arithmetic, then give the containment in the order you would apply it.
Approach
- Look at saturation before errors. A flat error rate with collapsing throughput says nothing is failing, things are waiting, so the first signal to pull is in-flight request count or pool wait time rather than the error counter. This is the distinction that decides the whole investigation.
- Group in-flight work by resolved host, not by destination id. The cap is keyed per destination row, so 900 rows sharing one hostname buy 3,600 concurrent slots against a single host, each held for 9.5 seconds. The bulkhead was never a bulkhead for that host, and grouping by the wrong dimension is why the dashboard looked healthy.
- Do the arithmetic in both directions. Required concurrency is arrival rate times latency, so 1.5k/second at 200 ms needs about 300 in flight, which is entirely consumed by 3,600 slow slots; conversely whatever concurrency is left sustains rate equals concurrency divided by 9.5 seconds, which is the 300/second you are seeing. Matching both numbers is what promotes this from a plausible story to the mechanism.
- Explain why the circuit breaker never helped. It opens on consecutive failures, and a 9.5-second response inside a 10-second timeout is a success. Slow is not failing, so an error-rate breaker cannot see this; you need a slow-call ratio, a deadline propagated from the caller's remaining budget, or a concurrency limiter.
Follow-up
- The host recovers to 80 ms. How long does the queue take to drain, and what does the drain do to the recovered host?
- Where should the 10-second timeout number actually come from?
Built from the rounds and topics INDmoney candidates report.
Prepare, practise & reflect
One practical outcome each day. Spend longer where you need it.
0 / 7 done01Map the INDmoney loop
- Write out the reported sequence: Recruiter Screening, Technical Interviews, Leadership Rounds.
- For each round, write one sentence on what it is judging, from the description above, and mark the one you are least ready for.
Deliverable: A one-page map of the 3 reported rounds, with the weakest marked.
02Work Go (Golang)
- Spend the session on Go (Golang), which INDmoney candidates report being tested on.
- Write one worked example in Go (Golang) and time yourself on it.
Deliverable: One timed worked example in Go (Golang).
03Work DSA (Data Structures & Algorithms)
- Spend the session on DSA (Data Structures & Algorithms), which INDmoney candidates report being tested on.
- Write one worked example in DSA (Data Structures & Algorithms) and time yourself on it.
Deliverable: One timed worked example in DSA (Data Structures & Algorithms).
04Work REST API Development
- Spend the session on REST API Development, which INDmoney candidates report being tested on.
- Write one worked example in REST API Development and time yourself on it.
Deliverable: One timed worked example in REST API Development.
05Answer out loud: Data Structures & Algorithms
- Answer aloud, timed: Implement a solution for the Coin Change problem.
- Answer aloud, timed: Explain the logic behind a Binary Search implementation and its complexity.
Deliverable: Spoken answers to 2 reported Data Structures & Algorithms question(s), under time.
06Answer out loud: System Design & Architecture
- Answer aloud, timed: How would you design a ledger system to ensure transactional integrity?
- Answer aloud, timed: Explain the architecture required to show real-time updates (e.g., top gainers/losers) to thousands of concurrent users.
Deliverable: Spoken answers to 2 reported System Design & Architecture question(s), under time.
07Answer out loud: Technical Fundamentals
- Answer aloud, timed: Explain ACID properties and their implementation in database transactions.
- Answer aloud, timed: Compare var, let, and const in JavaScript and explain their scope.
Deliverable: Spoken answers to 2 reported Technical Fundamentals question(s), under time.
Expand any day for tasks and deliverables. Your progress is saved on this device.
Behavioural rounds judge the decision you made and what it cost.
Reverse your own decision and price the reversal
Describe a technical decision you made and later reversed. Pick one that cost something: a service you split and merged back, a cache you added and removed, an index you created that pushed the planner onto a worse plan, a projection you rebuilt from scratch. State what you believed when you decided, the measurement that changed your mind, how long the wrong version ran in production, and what the reversal cost in migrations, dual writes, and a deprecation window for callers you did not own.
Approach
- State the original rationale without irony, in the version you would still defend given what was known then. If it is not defensible, the story is about carelessness rather than judgement, and a different example serves you better.
- Give the measurement that moved with a before and after: the p99 that did not improve, the cache hit rate that sat at 40%, the plan that flipped to a sequential scan once the table passed a size you can name.
- Cost the reversal in steps, not adjectives: expand-and-contract deploys, the dual-write window, the callers who had to be notified, the rows already written in the wrong shape that had to be backfilled or abandoned.
- Distinguish reversal from rewrite by naming what you kept. Most good reversals preserve the schema or the interface and undo one decision inside it, which is also why they were affordable.
Follow-up
- What in that decision was irreversible, and did you know it was irreversible when you made it?
- How did you tell the people who had already built on top of the original decision?
Turn a code review disagreement into a decision
A colleague's change updates a row with UPDATE resource SET version = version + 1 WHERE resource_id = $1 AND version = $2 and treats an affected-row count of zero as a successful no-op. You read that as a silently lost update; they think returning 200 is friendlier to clients than returning a conflict. Describe how you have handled a review disagreement of this shape: what goes in the comment, when you leave the thread, and who decides. Then write the comment you would leave here, in under 80 words.
Approach
- Sort the disagreement before writing anything. A silently discarded write is a correctness claim about data; the choice between 409 and 412 is taste. Only the first justifies blocking a merge, and saying which one you are doing is most of the value of the comment.
- Make the claim reproducible in the comment itself with an interleaving rather than a principle: A reads version 7, B reads version 7, B commits version 8, A's predicate matches zero rows, A is told it succeeded and A's edit is gone.
- Offer the alternative with its cost attached: return 409 carrying the current version and the revision that won, so the client can re-read and re-apply. Note that automatic retry is not the fix, because a retry re-reads the winner's state and reapplies an intent formed against data that no longer exists.
- Apply an escalation rule you can state: two round trips on the thread, then a call, and the service's owner decides rather than the reviewer. A reviewer who cannot be overruled is a bottleneck with extra steps.
Follow-up
- Where would you put the test that fails if someone reintroduces the swallowed zero rowcount?
- The author says clients cannot handle a 409. How do you check whether that is true?
Estimate work you have never done and defend the range
You are asked to estimate a change you have never attempted: add a column to a 100-million-row table, populate it, move reads across, and drop the old shape. Give a range with the assumptions that generate it, including batch size, the signal your backfill throttles on, and wall-clock hours, and name the three unknowns that would move the number most. Then describe a real estimate you gave under comparable ignorance: how you expressed its uncertainty, what you committed to, and how wrong you turned out to be.
Approach
- Decompose into independently deployable steps before estimating anything: add the column nullable, write both shapes, backfill in batches, verify, move reads, stop writing the old shape, drop it. That is four deploys spread over days, and the calendar estimate is dominated by them rather than by the loop's runtime.
- Do the arithmetic aloud for the part that has arithmetic in it: batch size times number of batches times per-batch duration, at a write rate the primary can absorb alongside roughly 1.2k writes per second of production traffic. The loop is throttled by replication lag and lock waits, not by how fast it can issue statements.
- Price the schema step by its lock rather than its statement duration. In PostgreSQL an ALTER TABLE taking ACCESS EXCLUSIVE waits for every open transaction on that table while later queries queue behind it, so a millisecond change issued during a thirty-second analytics query stalls that table for thirty seconds. Adding a nullable column with a non-volatile default avoids a rewrite from version 11; a new index wants CREATE INDEX CONCURRENTLY, which cannot run inside a transaction block and leaves an invalid index behind if it fails.
- Express the answer as a range whose endpoints each trace to a stated assumption, then name the cheapest experiment that collapses it, which is almost always running one real batch against the real table and multiplying.
Follow-up
- How do you verify the backfill genuinely finished, given rows written by production traffic while it ran?
- Where does the backfill resume from after a worker is killed mid-batch, and what makes that resume point trustworthy?
- 01
Describe a technical decision you made and later reversed. Pick one that cost something: a service you split and merged back, a cache you added and removed, an index you created that pushed the planner onto a worse plan, a projection you rebuilt from scratch. State what you believed when you decided, the measurement that changed your mind, how long the wrong version ran in production, and what the reversal cost in migrations, dual writes, and a deprecation window for callers you did not own.
- 02
A colleague's change updates a row with UPDATE resource SET version = version + 1 WHERE resource_id = $1 AND version = $2 and treats an affected-row count of zero as a successful no-op. You read that as a silently lost update; they think returning 200 is friendlier to clients than returning a conflict. Describe how you have handled a review disagreement of this shape: what goes in the comment, when you leave the thread, and who decides. Then write the comment you would leave here, in under 80 words.
- 03
You are asked to estimate a change you have never attempted: add a column to a 100-million-row table, populate it, move reads across, and drop the old shape. Give a range with the assumptions that generate it, including batch size, the signal your backfill throttles on, and wall-clock hours, and name the three unknowns that would move the number most. Then describe a real estimate you gave under comparable ignorance: how you expressed its uncertainty, what you committed to, and how wrong you turned out to be.
How difficult are the interviews?
The difficulty is generally considered moderate to high. The focus is on practical application rather than theoretical trivia, so expect to be challenged on your previous project experiences.
INDmoney Software Engineer candidate reports ↗What is the typical timeline for the process?
While it varies, the process can move quickly once you are in the pipeline. It is not uncommon to have multiple technical rounds scheduled in close succession.
INDmoney Software Engineer candidate reports ↗Is there a specific focus on cultural fit?
Yes, the final rounds with leadership or the CTO are specifically designed to ensure you are a good fit for the company's fast-paced, high-ownership culture.
INDmoney Software Engineer candidate reports ↗What should I focus on for the CTO round?
The CTO round usually focuses on your past experiences, architectural decision-making, and your ability to handle ambiguous, high-level design problems.
INDmoney Software Engineer candidate reports ↗How hard is the INDmoney interview?
Candidates most commonly rate INDmoney interviews as medium, based on 71 reported interviews. About 48% of candidates who interview go on to receive an offer.
INDmoney Software Engineer candidate reports ↗What topics does INDmoney test in interviews?
INDmoney interviews most often cover SQL, Go (Golang), DSA (Data Structures & Algorithms), REST API Development, and Product Sense. The exact emphasis depends on the specific role you apply for.
INDmoney Software Engineer candidate reports ↗Where is INDmoney headquartered?
INDmoney is headquartered in Gurgaon, India.
INDmoney Software Engineer candidate reports ↗Sources & methodology 3 sources ↗
Official role evidence, timestamped platform data and clearly labeled preparation advice.
- 01INDmoney Software Engineer candidate reports ↗
Company-reported rounds, questions and FAQ.
candidate · Accessed 2026-09-22 - 02PracHub Software Engineer practice ↗
PracHub practice material, not company-reported.
platform · Accessed 2026-09-22 - 03PracHub preparation framework ↗
PracHub preparation guidance.
platform · Accessed 2026-09-22
Explore related engineering environments and compare the preparation focus.
Whatnot Software Engineer Interview Guide
What Whatnot asks Software Engineer candidates, from reported rounds and questions.
Cartrack Software Engineer Interview Guide
What Cartrack asks Software Engineer candidates, from reported rounds and questions.
Zwift Software Engineer Interview Guide
What Zwift asks Software Engineer candidates, from reported rounds and questions.
Zumper Software Engineer Interview Guide
What Zumper asks Software Engineer candidates, from reported rounds and questions.