Module Lead - Java

YASH Technologies, Inc.; Bengaluru; On-site; INR 2,800,000 - 4,200,000; Full time

Job summary

YASH Technologies, Inc. seeks an experienced Senior Backend Developer to build scalable backend services in Java/Spring, focusing on reactive programming and AWS.

You will work across two Java + Spring Boot WebFlux codebases, handling data ingestion, data delivery, and cloud-native workflows, ensuring performance, testing and observability.

The role emphasizes end-to-end ownership, OpenAPI-first APIs, CI/CD, and secure-by-default design.

Qualifications

• Proficient in Java 17+ with Spring Boot, WebFlux and reactive patterns.
• Experience building cloud-native, event-driven services on AWS.
• Strong testing, observability and secure-by-default design.

Responsibilities

• Design, build and maintain reactive REST APIs using Spring Boot WebFlux.
• Develop and evolve event-driven background jobs on AWS Lambda with SQS.
• Model and query data in PostgreSQL using R2DBC and jOOQ.
• Maintain multi-module Gradle architecture and CI/CD pipelines.
• Ensure OpenAPI-first APIs and proper observability.

Skills

Java

Spring Boot / WebFlux

Reactive programming

AWS

PostgreSQL

Testing (JUnit 5)

CI/CD

Tools

Project Reactor

R2DBC

jOOQ

Flyway

OpenTelemetry

CloudFormation

Docker

GitHub Actions

Job description

Select how often (in days) to receive an alert: Create Alert

Senior Backend Developer (Java / Spring / AWS)

Job Title: Senior Backend Developer — Java, Reactive Spring, AWS Experience: 6+ years of hands-on backend engineering, including 3+ years building cloud-native, event-driven services on AWS.

Job Summary

We are seeking an experienced Senior Backend Developer to build and scale the services behind our Dynamic Service Options (DSO) platform. You will work across two Java + Spring Boot (WebFlux) codebases:

• an authoring backend — the data-production side, where machine parts and service data are ingested from a cloud data warehouse, validated, enriched by a service-option engine, and published as datasets
• a delivery backend — the consumption side, which receives published datasets, applies dataset-level permissions, and serves the user-facing APIs behind the embeddable Dynamic Service
• Both are fully reactive, event-driven systems on R2DBC/PostgreSQL, AWS Lambda, SQS and ECS Fargate, sharing a multi-module Gradle structure, OpenAPI-first APIs, Flyway-managed schemas, OpenTelemetry tracing and CloudFormation-driven deployments.
• The ideal candidate is fluent in non-blocking reactive programming with Project Reactor, comfortable owning a feature end-to-end (API → async job → database → infrastructure → dashboard), and holds a high bar for testing, observability and secure-by-default design.

Key Responsibilities

• Design, build and maintain reactive REST APIs using Spring Boot WebFlux, returning `Mono`/`Flux` end-to-end with no blocking calls anywhere in the request path.
• Develop and evolve event-driven background jobs running on AWS Lambda, triggered by SQS FIFO queues and EventBridge cron schedules, using a mediator/command-handler pattern with explicit concurrency control, retry policies and dead-letter queue handling.
• Model and query data in PostgreSQL (Aurora Serverless) using Spring Data R2DBC repositories and a type-safe jOOQ DSL for dynamic queries; leverage advanced Postgres features such as JSONB, ltree hierarchies, partitioning and appropriate GIN/GIST indexing.
• Author and review Flyway migrations (versioned and repeatable), keeping schema changes backward-compatible and validated in CI.
• Maintain a clean multi-module Gradle architecture — shared library, API service and Lambda worker — placing code in the correct module and avoiding cross-layer leakage.
• Design OpenAPI-first APIs: generated specs, standardized response envelopes and error models, spec linting in the pipeline, and consistent HTTP semantics
• Integrate with external systems — Snowflake (REST API with JWT key-pair auth and long-running query polling), internal product/entitlement services, and AWS services (S3, Secrets Manager, DynamoDB) via async SDK clients.
• Implement caching and performance strategies (Caffeine in-memory/Redis caches with TTLs, query tuning, parallel composition with `Mono.zip`) for high-volume ingestion and reporting workloads.
• Instrument services with OpenTelemetry / AWS Distro for OpenTelemetry (ADOT): custom spans, trace-context propagation across HTTP and SQS boundaries, structured logging, and RED metrics surfaced in CloudWatch Application Signals, X-Ray and Grafana dashboards.
• Write unit and integration tests with JUnit 5, Mockito and Reactor `StepVerifier`; keep coverage and quality gates green in SonarQube.
• Contribute to CI/CD: GitHub Actions build/test/scan workflows, multi-stage Docker builds, ECR image publishing, Lambda artifact packaging, and CloudFormation deployments across dev/QA/UAT/prod.
• Apply secure-by-default practices: OAuth2 resource-server token validation, role/entitlement-based authorization filters, least-privilege IAM, secrets in AWS Secrets Manager (never in code), and input validation at every boundary.
• Participate in code reviews, uphold documented coding standards, and mentor mid-level engineers on reactive patterns and cloud design.

Required Skills & Qualifications

• Java 17+ (we run the latest LTS) — records, sealed types, streams and modern language features.
• Spring Boot in depth, including WebFlux and Spring Security (OAuth2 Resource Server).
• Project Reactor — `Mono`/`Flux` composition, error operators, backpressure and retries; no `.block()`, `Thread.sleep()` or blocking SDKs.

Data

• PostgreSQL at a professional level — schema design, indexing and query plans.
• R2DBC or equivalent reactive data access, and jOOQ or comparable type-safe SQL tooling.
• Flyway or Liquibase migrations validated in CI.
• Hands-on AWS — Lambda, SQS (FIFO semantics, visibility timeouts, DLQs), EventBridge, S3, Secrets Manager, ECS Fargate, RDS/Aurora, CloudWatch, IAM.
• AWS SDK v2 async clients or Spring Cloud AWS.
• Infrastructure as Code — CloudFormation, or SAM/CDK/Terraform with willingness to work in CloudFormation.

APIs & Contracts

• OpenAPI 3, REST conventions, versioning, consistent error contracts and bean validation.

Quality & Delivery

• JUnit 5, Mockito, Spring Boot Test, Reactor Test — meaningful tests for both success and failure paths.
• Docker and Compose for local development.
• Git, pull-request workflow and GitHub Actions or equivalent CI/CD.
• SonarQube or similar static analysis, with coverage discipline.

Engineering Judgment

• Distributed-systems fluency — idempotency, at-least-once delivery, retries, timeouts, partial failure and eventual consistency.
• Strong analytical, debugging and communication skills; owns delivery end-to-end.

Preferred Skills

• OpenTelemetry / distributed tracing; Grafana, Tempo, Prometheus or Loki.
• Snowflake or another cloud data warehouse; large-scale ingestion pipelines.
• Spring Cloud Function on Lambda, and JVM cold-start tuning (CRaC, SnapStart, fat JARs).
• LocalStack for local AWS emulation.
• Serverless cost/performance tuning and JVM tuning for containers.
• Enterprise SSO (Azure Entra, OAuth2 introspection) and centralized entitlement/RBAC services.
• OWASP Top 10 awareness and secure code review.
• Agile/Scrum delivery and trunk-friendly branching.

What You'll Work On

• High-volume data ingestion pipelines pulling from a cloud data warehouse, staging, applying prediction rules, and loading results.
• SBOM generation with parallel warehouse queries, CSV assembly and S3 delivery via presigned URLs.
• A service-option engine performing tiered template matching against external product-catalog lookups.
• Template upload & validation flows with CSV parsing, cached external validation and transactional persistence.
• The Service-option dataset lifecycle — request intake, generation, versioning, locking, expiry and custom (user-modified) dataset variants persisted to S3 and served through presigned URLs.
• Publish/consume Lambda workflows that move datasets from the authoring system into delivery: SQS request and FIFO job queues, EventBridge-scheduled invocations, a command/handler job model with bounded concurrency, retry limits, dead-letter queues and per-run status and log tracking.
• Dataset-level permissions — organization- and user-scoped access grants with multiple levels, owner attribution, layered on top of OAuth2 token validation and entitlement-based authorization enforced per endpoint.
• Third-party orchestration — ServiceNow request/task lifecycle for dataset provisioning, product-information lookups, and identity/directory resolution, all with caching, timeouts and graceful degradation.
• Scheduled housekeeping jobs driven by EventBridge, with per-job log capture and status tracking.
• The observability layer that makes all of the above debuggable in production.