Jobs by Fastorial
Back to all jobs

Software Engineer

0 views
MoneyviewBengaluruHybrid

12+ years

Posted 1 day ago

  • AWS
  • Devops
  • Docker
  • DynamoDB
  • Java
  • Kafka
  • Kubernetes
  • Microservices

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