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

Experience:
9–12 Years

Location:
Bangalore Commitment: Full-Time Team: Technology Function: Lending Systems

Job Description
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 current 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 strong 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