Job: Staff Engineer / SDE-4 — Backend (Lending Systems)

Experience: 9–12 Years

Location: Bangalore

Commitment: Full-Time

Team: Technology

Function: Lending Systems

Moneyview is looking for a Staff Engineer to own the backend systems that run our lending operations end to end till disbursal. You will be the senior-most technical voice in the OPS/LOS team: setting architecture across a large fleet of microservices, holding the line on reliability and correctness in a domain where a bug is a money or compliance event, and raising the bar on how fast the team ships by making AI-assisted development the default way we work.

Key Responsibilities

- Own the architecture of the lending OPS platform end to end — workflow, KYC, calling, OPS etc. — not just the services your POD writes.
- Be accountable for correctness of money movement and loan state: idempotency, reconciliation, retries, compensating flows, audit trails and eventual consistency across services.
- Treat the regulatory reality of lending as a design constraint, not a retrofit — RBI and partner-bank obligations, PII handling, data retention and auditability.
- Drive both high-level and low-level design: service boundaries, APIs, schemas, data segregation, class and sequence design — with scalability, extensibility, maintainability and security as explicit acceptance criteria.
- Influence architecture beyond your own POD; review and shape peer-team designs wherever lending flows cross team boundaries.
- Define, instrument and monitor the key metrics of the systems you own — latency, error budgets, disbursement success rate, queue lag and cost per transaction.
- Cut through ambiguity on business problems: establish technical scope, boundaries, assumptions, limitations and a recommended solution, and create direction where none exists.
- Advocate for the simplest solution that holds, and for long-term flexibility without slowing delivery.
- Work across Dev, DevOps and QA boundaries; go deep and hands-on to unblock others rather than delegating the hard parts.
- Partner directly with Operations, Credit, Risk and Collections teams to understand pain points first-hand, and design working backwards from those needs.
- Articulate complex technical trade-offs to non-technical stakeholders and drive alignment.
- Mentor and coach engineers across PODs; be the recognised SME in your area and deliberately build depth in others.
- Introduce tools, processes and practices that raise software quality, and codify them as team standards.
- Participate actively in hiring and continuously improve the hiring bar and process.
- Be frugal with resources — engineering time, software, infrastructure and cloud spend.

Microservices Ownership — 360 Degrees

- Reason about a fleet of microservices as one system: service boundaries, synchronous versus event-driven contracts, backward-compatible API and schema evolution, and where to draw the line between shared and owned data.
- Own the full lifecycle of a service, not just its code — build and CI/CD, deployment and rollback strategy, config and secrets, feature flags, capacity planning and cost.
- Design for failure: timeouts, retries with backoff, circuit breakers, bulkheads, dead-letter handling,



graceful degradation and blast-radius containment across dependent services.
- Guarantee data correctness across service boundaries — distributed transactions and saga patterns, exactly-once versus at-least-once semantics, idempotency keys and reconciliation jobs.
- Drive observability as a first-class deliverable: structured logging, distributed tracing, RED/USE metrics, actionable alerting and meaningful SLOs.
- Lead production operations for the OPS fleet — on-call, incident command, root-cause analysis and follow-through on corrective actions.
- Lead decomposition and migration work: carve services out of monoliths or consolidate over-fragmented ones, with dual-write, backfill and cutover plans that carry no data loss.
- Own performance and scale for lending peaks — profiling, query and index tuning, caching strategy, connection pooling, and load and chaos testing before month-end and campaign spikes.

AI-Enabled Engineering (Must Have)

- You already build with AI daily, not occasionally. We use Claude and Cursor heavily across the team, and we expect a Staff Engineer to be among the strongest users in the org.
- Ship production code with AI-assisted workflows — decomposing a task into promptable units, driving agentic coding sessions, and reviewing AI output with the same rigour you apply to a junior engineer’s pull request.
- Make large legacy codebases tractable with AI: onboarding onto unfamiliar services, generating tests and documentation, planning refactors and migrations, and accelerating incident investigation.
- Set the standard for how the team works with AI — repository context and rules files, prompt and workflow patterns worth reusing, evaluation of new tools, and clear guidance on where AI output must not be trusted.
- Apply sound judgement on the limits: no unreviewed AI code in money-movement or decisioning paths, no customer or credit data in tools that are not approved, and security and licensing checks on generated code.
- Bonus: hands-on experience building AI-backed product features — LLM API integration, retrieval, prompt evaluation, guardrails and cost or latency management in production.

Problem Solving (PS)

- Take a loosely defined business goal and turn it into a solved technical problem.
- Create clarity and direction where the problem is ambiguous, and drive the technical vision and solution.
- Define technical scope, boundaries, assumptions, limitations and the recommended solution explicitly.

Architecture, Design & Data Structures

- Strong command of data structures and algorithms, and deliberate use of design patterns that hold up over years.
- Breadth across technologies, with the judgement to argue the pros and cons of each for a given problem.
- Ability to drive architecture across the chosen tech stack, not just a single service.




- High-level design with scalability, extensibility, maintainability and security as first-class concerns.
- Low-level design including API contracts, class diagrams, schema and data segregation.
- Proactive framework and tooling choices that raise code quality by default.

Required Skills

- 9–12 years building and operating backend systems at scale, including a track record as the technical owner of a business-critical domain.
- Strong hands-on Java with Spring Boot or equivalent; fluent enough in a second language to pick the right tool.
- Real depth in microservices — you have designed, decomposed and operated a multi-service estate in production, not merely contributed to one.
- Strong data layer skills: relational schema design and query tuning (MySQL or PostgreSQL), plus practical use of a NoSQL or caching store such as Redis, MongoDB or DynamoDB.
- Event-driven systems in production with Kafka or an equivalent broker — partitioning, ordering, consumer lag, replay and idempotent consumers.
- Containers and orchestration (Docker, Kubernetes or equivalent) with hands-on CI/CD ownership; comfortable on AWS or an equivalent cloud.
- Production observability and on-call experience — you have owned an SLO and led an incident to resolution.
- Solid understanding of distributed systems design and trade-offs, with solid command of data structures, algorithms and design patterns.
- Demonstrated daily use of AI coding tools such as Claude and Cursor to ship production software, with clear judgement about where not to rely on them.
- Clear written communication — design documents, RFCs and post-mortems that others can act on.

Good to Have

- Experience building service-oriented distributed systems.
- Experience with big data processing — either real-time streaming or offline batch pipelines.
- Familiarity with messaging systems such as Kafka, RabbitMQ, or Kinesis.
- Familiarity with real-time computation frameworks such as Storm, Spark, or Hadoop-based tools.
- Familiarity with data warehousing technologies such as Redshift or BigQuery.
- Experience in lending, payments or fintech — loan origination or management systems, credit bureau and KYC integrations, partner-bank or co-lending flows, payment gateways, NACH or UPI mandates, or collections systems.
- Experience building systems that operate under regulatory audit — RBI, ISO 27001 or SOC 2.
- Experience with rules or workflow engines used for underwriting and decisioning.
- Prior experience as a bar-raiser interviewer or as the owner of an architecture review forum.

How We Will Measure Success

- First 90 days: you can trace any lending flow end to end across services, you are on-call, and you have shipped a meaningful change to a core OPS service.
- By six months: you own the architecture roadmap for a lending domain, have retired at least one significant source of reliability or correctness risk, and the team’s AI-assisted workflows have visibly improved with your input.
- By twelve months: measurable movement on the metrics you defined — reliability, throughput, delivery speed and cost — and at least two engineers noticeably stronger because of your coaching.

📌 Software Engineer (Bengaluru)
🏢 MoneyView
📍 Bengaluru