Software Solution Architect II

UST; Bengaluru; On-site; INR 1,200,000 - 2,000,000; Full time

Job summary

UST FinX in Bengaluru is seeking a Senior Solution Architect to raise backend engineering quality across delivery teams through hands-on contribution, technical leadership, mentoring, and architectural execution. This senior role focuses on production-ready Java/Spring Boot services, distributed systems, and scalable designs, with code reviews guiding multiple pods.

Reporting to the CTO, you will influence architecture across the platform, ensuring maintainable, observable, secure, and resilient

Qualifications

• Minimum 8 years of backend engineering experience with ownership of production systems.
• Excellent modern Java and Spring Boot skills with deep understanding of distributed systems.
• Experience designing RESTful APIs, event-driven patterns, and scalable service boundaries.

Responsibilities

• Provide hands-on technical leadership for backend across one or more delivery pods.
• Translate platform requirements into well-designed backend services, APIs, and event-driven components.
• Review code daily to improve correctness, maintainability, and production readiness.
• Mentor engineers through pairing, design discussions, and debugging sessions.
• Guide distributed-system concerns: retries, idempotency, consistency, backpressure, and failure isolation.

Skills

Code Review

Distributed Systems

Domain-Driven Design

Java

Kubernetes

Microservices

Observability

OpenTelemetry

Performance Tuning

Event-Driven Architecture

REST

Job description

Role Description

Solution Architect II – Enterprise Solutions Who We Look For We are looking for a Senior Solution Architect to raise backend engineering quality across delivery teams through daily hands‑on contribution, technical leadership, mentoring, and architectural execution. This is a senior hands‑on role, not people management—your influence comes from your code, design judgment, code reviews, and ability to mentor engineers toward production‑ready backend systems. You will guide backend implementation across teams, ensuring architecture becomes clean, maintainable, testable, observable, and scalable software—staying close to the code every day and setting a high bar for production readiness. The role suits someone combining excellent Java and Spring Boot skills with strong distributed‑systems understanding—building services that survive real production conditions. Technical leadership here means working in the details, not producing diagrams alone. In an AI‑assisted development environment, you apply engineering judgment to validate, refine, and sometimes reject generated output, ensuring it still meets strict standards for correctness, resilience, testability, security, and maintainability. We value a merit‑based culture where leads challenge weak designs, simplify complexity, and drive strong engineering practices. What You Will Do Provide hands‑on technical leadership for backend engineering across one or more delivery teams—writing production Java/Spring Boot code while guiding engineers through design, implementation, testing, review, and production readiness. Translate platform architecture and product requirements into well‑designed backend services, APIs, event‑driven components, integrations, and reusable engineering patterns. Review code daily, using reviews to improve correctness, maintainability, design quality, testing, observability, and engineering discipline. Mentor engineers through pairing, design discussions, debugging sessions, and refactoring work. Guide RESTful API design, asynchronous/event‑driven flows, data access layers, service boundaries, error handling, and operational controls. Guide distributed‑systems concerns: consistency, retries, idempotency, concurrency, transaction boundaries, backpressure, resilience, failure isolation, and performance under load. Define and promote testing strategies—unit, integration, contract, component, API, performance, and production validation. Identify and remove technical debt, weak abstractions, poor service boundaries, and fragile integrations. Support production readiness: observable, secure, scalable, resilient, deployable, diagnosable, and maintainable systems. Collaborate with architects, platform, QA, DevOps, product, and client‑facing delivery teams so speed never compromises engineering quality. Raise the engineering standard via reusable examples, reference implementations, coding guidelines, review checklists, and technical documentation. Reporting Line and Role Context This role reports directly to the CTO of UST FinX. You will act as one of the CTO’s senior technical lieutenants—creating engineering leverage while remaining deeply hands‑on: influencing multiple pods, establishing reusable standards, mentoring technical leaders, challenging weak designs, and turning technical direction into production‑quality execution. This is neither a passive advisory role nor traditional people management; your authority comes from technical credibility, judgment, and the ability to make other engineers better. As a force multiplier, you work with the CTO to define standards, identify engineering gaps, raise delivery quality, and ensure architecture is reflected in real code, platforms, and operational behavior across UST FinX. Skills and Experience We Are Looking For Minimum 8 years of professional backend engineering (ideally 10–12), with meaningful hands‑on ownership of production backend systems. Excellent modern Java: language features, concurrency, collections, error handling, performance, modularity, and maintainable code design. Strong Spring Boot and broader Spring ecosystem: REST APIs, dependency injection, configuration, security, data access, testing, observability, and deployment. Strong distributed systems: latency, partial failure, retries, idempotency, consistency, concurrency, transaction boundaries, backpressure, and operational failure modes. Event‑driven architecture: producers, consumers, event contracts, schema evolution, async processing, replay, retries, dead‑letter handling, and eventual consistency. API design: RESTful design, versioning, validation, error models, pagination, security, documentation, and consumer‑oriented contract discipline. Testing strategies: unit, integration, contract, and component testing, test data management, mocking boundaries, and automated regression protection. Performance tuning: profiling, query optimization, JVM behavior, memory, threads, connection pools, serialization, caching, and high‑throughput behavior. Cloud‑native backend systems, preferably on AWS or equivalent: containers, managed services, CI/CD, observability, and automated deployment. Extensive code review: identifying design flaws, correctness, maintainability, security, performance, and operational risks, plus missing tests. Architecture executed through working code, strong service boundaries, and reusable patterns. Mentoring that raises standards without friction; clear communication of decisions, trade‑offs, and risks to distributed teams. Comfortable in a global, distributed organization with multiple pods, stakeholders, and time zones. Preferred Qualifications Financial services, banking, payments, lending, servicing, compliance, or regulated enterprise environments. Kafka, Redpanda, or equivalent messaging and event‑streaming platforms. Kubernetes and cloud‑native deployment: containerized workloads, autoscaling, service discovery, configuration management, and runtime operations. Observability stacks: Prometheus, Grafana, CloudWatch, OpenTelemetry, distributed tracing, structured logging, and ing. Database design and tuning across relational and non‑relational systems: schema, indexing, transactions, and query performance. CI/CD, automated quality gates, static analysis, dependency scanning, deployment automation, and zero‑downtime practices. Domain‑driven design, clean and hexagonal architecture, modular monoliths, microservices, and service decomposition. Reusable backend frameworks, shared libraries, platform components, and reference implementations consumed by multiple teams. Security‑aware development: authentication, authorization, OAuth2/OIDC, secrets handling, input validation, auditability, and least‑privilege design. Large, complex, evolving codebases where maintainability and refactoring discipline matter—living with the long‑term consequences of engineering decisions: supporting, debugging, scaling, migrating, and evolving critical production systems.

Skills

• Code Review
• Distributed Systems
• Domain-Driven Design
• Java
• Kubernetes
• Microservices
• Observability
• OpenTelemetry
• Performance Tuning
• Event-Driven Architecture
• REST