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