Technical / Senior Technical Lead

Position Overview

We
are looking for an experienced Core Java Technical Architect / Microservices
Architect with strong expertise in Java, Spring Boot, Apache Kafka,
Reactive Programming, Spring WebFlux, and AWS Cloud Services. The ideal
candidate will be responsible for leading the technical design,
architecture, development, and delivery of highly scalable, resilient, and
cloud-native microservices applications.

The
role requires a hands-on technical leader who can make architectural decisions,
solve complex technical problems, establish coding and design standards, and
guide engineering teams in building high-performance distributed systems.

Key Responsibilities

1. Technical Architecture & Design

• Lead
  the architecture, technical design, and implementation strategy for
  enterprise-scale microservices applications.
  
• Define
  scalable, resilient, secure, and maintainable microservices
  architecture aligned with business and technical requirements.
  
• Evaluate
  existing systems and recommend modernization, re-engineering, and
  architectural improvements.
  
• Define
  service boundaries, API contracts, communication patterns, data flows, and
  integration strategies.
  
• Make
  key architectural decisions related to synchronous and asynchronous
  communication, scalability, availability, performance, and fault tolerance.
  
• Create
  and maintain High-Level Design (HLD) and Low-Level Design (LLD) documents.
  
• Establish
  architecture and development standards, design patterns, coding
  guidelines, and best practices across engineering teams.
  

2. Java & Spring Boot Development

• Provide
  hands-on technical leadership in developing robust applications using Java
  and Spring Boot.
  
• Design
  and develop production-grade REST APIs and microservices.
  
• Apply
  appropriate Object-Oriented Design, SOLID principles, Design Patterns,
  and clean-code practices.
  
• Review
  complex code and provide technical guidance to developers.
  
• Develop
  proof-of-concepts and reference implementations to establish technical
  direction and demonstrate best practices.
  
• Take
  ownership of technically complex modules and critical application
  components.
  

3. Microservices Architecture

• Design
  and implement highly scalable and loosely coupled microservices.
  
• Define
  service-to-service communication and integration patterns.
  
• Design
  solutions for distributed systems, service resiliency, fault tolerance,
  scalability, and high availability.
  
• Apply
  patterns such as:
  
• Event-driven
  architecture
  
• Asynchronous
  communication
  
• Circuit
  Breaker
  
• Retry
  and timeout strategies
  
• Bulkhead
  isolation
  
• Idempotency
  
• Saga
  and distributed transaction patterns
  
• API
  Gateway and service discovery patterns
  
• Identify
  and address architectural bottlenecks and technical debt.
  

4. Kafka & Asynchronous Communication

• Lead
  the design and implementation of event-driven architectures using
  Apache Kafka.
  
• Design
  asynchronous communication between multiple microservices using Kafka
  topics, producers, and consumers.
  
• Define
  appropriate topic, partitioning, consumer-group, retry, error-handling,
  and message-processing strategies.
  
• Design
  solutions for message ordering, idempotency, delivery guarantees, and
  failure recovery.
  
• Optimize
  Kafka-based applications for high throughput, scalability, and
  reliability.
  
• Establish
  best practices for asynchronous workflows and event-driven microservices.
  

5. Reactive Programming & Spring WebFlux

• Design
  and develop reactive, non-blocking applications using Spring
  WebFlux.
  
• Apply
  Reactive Programming principles for handling high-concurrency and
  I/O-intensive workloads.
  
• Implement
  asynchronous and non-blocking communication between multiple services.
  
• Work
  with Reactive Streams, Mono, Flux, backpressure, and non-blocking I/O.
  
• Identify
  blocking operations and design appropriate reactive alternatives.
  
• Optimize
  application performance, resource utilization, throughput, and response
  times.
  
• Establish
  coding standards and reusable patterns for reactive application
  development.
  

6. AWS Cloud Architecture

• Design
  and implement cloud-native solutions using AWS Cloud Services.
  
• Define
  appropriate AWS services based on application scalability, reliability,
  security, and performance requirements.
  
• Design
  microservices for deployment and operation in AWS environments.
  
• Work
  with cloud infrastructure, networking, security, monitoring, logging, and
  scalability concepts.
  
• Drive
  cloud adoption, modernization, and optimization initiatives.
  
• Ensure
  solutions follow AWS Well-Architected principles and enterprise
  security standards.
  

7. Hands-on Technical Leadership

• Provide
  technical leadership to development teams throughout the software
  development lifecycle.
  
• Lead
  technical discussions, architecture reviews, design reviews, and code
  reviews.
  
• Establish reference implementations and exemplary code that developers can
  follow.
  
• Mentor
  senior and junior developers on architecture, coding standards, design
  patterns, and engineering best practices.
  
• Help
  teams troubleshoot complex technical and production issues.
  
• Drive
  continuous improvement in engineering quality, development practices, and
  system architecture.
  

8. Complex Problem Solving & Technical Analysis

• Analyze
  complex technical and business requirements and translate them into
  scalable technical solutions.
  
• Investigate
  challenging performance, scalability, concurrency, integration, and
  distributed-system problems.
  
• Perform root cause analysis (RCA) for critical application and production
  issues.
  
• Evaluate
  multiple technical approaches and recommend the most appropriate solution
  based on trade-offs.
  
• Identify
  potential risks, bottlenecks, and failure scenarios before implementation.
  
• Provide
  practical solutions for complex technical challenges while balancing
  business priorities and technical constraints.
  

9. Production & Post-Production Support

• Provide
  strong technical ownership of applications throughout the production
  and post-production lifecycle.
  
• Troubleshoot
  and resolve critical production incidents and performance issues.
  
• Analyze
  application logs, metrics, traces, and system behavior to identify root
  causes.
  
• Lead
  production incident investigations and RCA activities.
  
• Support
  performance tuning, scalability improvements, and reliability initiatives.
  
• Define
  preventive and corrective actions to minimize recurring production issues.
  
• Work
  closely with DevOps, infrastructure, QA, and support teams during
  production deployments and incidents.
  
• Ensure
  applications meet required availability, reliability, performance, and
  operational SLAs.
  

Required Technical Skills

Core Technologies

• Java
  8/11/17+
  
• Spring
  Boot
  
• Spring
  Framework
  
• Microservices
  Architecture
  
• REST
  APIs
  
• Apache
  Kafka
  
• Reactive
  Programming
  
• Spring
  WebFlux
  
• AWS
  Cloud Services
  

Architecture & Design

• Distributed
  Systems
  
• Event-Driven
  Architecture
  
• Asynchronous
  Communication
  
• Microservices
  Design Patterns
  
• SOLID
  Principles
  
• Design
  Patterns
  
• API
  Design
  
• Resiliency
  and Fault-Tolerant Architecture
  
• Scalability
  and High Availability
  
• Performance
  Optimization
  
• System
  Integration
  

Reactive Technology

• Spring
  WebFlux
  
• Project
  Reactor
  
• Mono
  / Flux
  
• Reactive
  Streams
  
• Non-blocking
  I/O
  
• Backpressure
  
• Asynchronous
  Programming
  
• Reactive
  API design
  

Cloud & DevOps

• Strong
  understanding of AWS architecture and cloud-native application design
  
• Experience
  with containerized/microservices deployments is highly desirable
  
• Understanding
  of CI/CD pipelines, observability, monitoring, logging, and cloud
  operations
  
• Familiarity
  with AWS services such as EKS/ECS, EC2, S3, RDS, DynamoDB, API Gateway,
  Lambda, CloudWatch, IAM, and networking services is desirable.
  

Leadership & Behavioral Skills

• Strong technical leadership and architectural decision-making skills.
  
• Excellent
  analytical and problem-solving capabilities.
  
• Ability
  to break down complex problems and develop practical solutions.
  
• Strong
  communication and stakeholder-management skills.
  
• Ability
  to influence technical direction across multiple engineering teams.
  
• Strong
  mentoring and knowledge-sharing capabilities.
  
• Comfortable
  working in a hands-on architect role, balancing architecture
  responsibilities with complex coding.
  
• Strong
  ownership and accountability for production systems.
  
• Ability
  to work effectively in an Agile/Scrum environment.
  

Ideal Candidate Profile

The
ideal candidate is a hands-on Technical Architect who combines deep Java
development expertise with strong experience in microservices, Kafka,
reactive programming, WebFlux, and AWS.

The
candidate should be capable of moving seamlessly between architecture and
implementation—from defining the overall system architecture and service
interaction patterns to writing complex code, reviewing implementations,
troubleshooting production issues, and mentoring the engineering team.

Key Competencies

• Technical
  Architecture & Design: Expert
  
• Java
  & Spring Boot: Expert
  
• Microservices: Expert
  
• Kafka
  & Event-Driven Architecture: Strong
  
• Reactive
  Programming / WebFlux: Strong
  
• AWS
  Cloud: Strong
  
• Distributed
  Systems: Strong
  
• Problem
  Solving & Analytical Skills: Excellent
  
• Production
  Support & Troubleshooting: Strong
  
• Technical
  Leadership & Mentoring: Strong
  
• Hands-on
  Coding: Strong