Technical Lead - Java

Job Summary

We are looking for a strong, hands-on Java Technical Lead who combines deep engineering capability with architecture, problem solving, design leadership, team guidance, and delivery ownership. The role is expected to understand and influence the complete application stack - from browser and network protocols through Java services, databases, messaging, infrastructure, security, scalability, deployment, and production operations. This is not a coordination-only role. The Technical Lead must remain close to the code, be capable of diagnosing difficult technical issues, review critical implementations, make sound architecture decisions, and ensure that the team produces maintainable, scalable, secure, and production-ready software.

1. End-to-End Architecture & Solution Design

• Own the technical design of major features, modules, integrations, and services from requirements through production deployment.
• Understand the complete request flow: browser/client -> DNS -> TCP/IP -> SSL/TLS -> HTTPS -> WAF/load balancer/reverse proxy -> application/API layer -> Java services -> cache/messaging -> databases -> infrastructure.
• Select appropriate architectural patterns and technologies based on functional requirements, system constraints, operability, and long-term maintainability.
• Design stateless/stateful services, synchronous/asynchronous interactions, clustering, horizontal/vertical scaling, caching, distributed processing, failover, and resilience mechanisms.
• Identify architecture risks, bottlenecks, capacity constraints, integration concerns, and failure modes early in the lifecycle.

2. Hands-on Java & JVM Engineering

• Provide hands-on technical leadership in modern Java development and remain capable of implementing, debugging, profiling, and reviewing complex production code.
• Demonstrate strong knowledge of Java language fundamentals, collections, generics, exception handling, I/O, concurrency, synchronization, thread pools, executors, CompletableFuture, and asynchronous programming patterns.
• Understand JVM behaviour including heap/non-heap memory, garbage collection, class loading, thread dumps, heap dumps, JVM tuning, profiling, memory leaks, CPU bottlenecks, and performance diagnostics.
• Apply clean code principles, SOLID concepts, design patterns, modularity, testability, defensive programming, and appropriate abstraction.
• Perform code reviews for correctness, performance, security, maintainability, concurrency safety, error handling, observability, and alignment with architecture.

3. Spring, APIs & Middle-Tier Engineering

• Strong working experience with Spring Framework and Spring Boot, including dependency injection, configuration, security, validation, persistence, transactions, and application lifecycle.
• Design RESTful APIs and service contracts with appropriate versioning, validation, error models, idempotency, pagination, timeout/retry behaviour, and backward compatibility.
• Understand microservices and modular monolith trade-offs; design service boundaries, inter-service communication, configuration, discovery, resilience, and dependency management appropriately.
• Experience with JPA/Hibernate or equivalent ORM technologies and awareness of ORM performance problems such as N+1 queries, lazy loading, transaction scope, and inefficient object graphs.
• Understand web/application servers, connection/thread pools, reverse proxies, request handling, serialization, session management, and middle-tier performance behaviour.

4. Database, Cache, Search & Messaging

• Strong RDBMS knowledge covering MySQL, PostgreSQL, Oracle, SQL Server or equivalent technologies.
• Design schemas and data models; understand indexing, query plans, SQL optimization, transactions, isolation levels, locking, deadlocks, connection pooling, replication, partitioning, high availability, and database scalability.
• Understand when relational, document, key-value, search, or distributed data stores are appropriate.
• Working knowledge of technologies such as Redis, MongoDB, Elasticsearch, Cassandra or equivalents.
• Design asynchronous and event-driven flows using Kafka, ActiveMQ, RabbitMQ or equivalent messaging platforms; understand delivery semantics, ordering, retries, dead-letter handling, consumer scaling, and idempotency.

5. Web, Network & Security Fundamentals

• Strong understanding of HTTP/HTTPS, SSL/TLS, certificates, DNS, TCP/IP fundamentals, proxies, reverse proxies, load balancers, firewalls/WAFs, and secure service-to-service communication.
• Understand authentication and authorization patterns including OAuth 2.0, OpenID Connect, JWT, SSO, identity providers, RBAC, token/session lifecycle, and secrets handling.
• Apply API and application security fundamentals including input validation, secure headers, transport security, least privilege, secrets management, dependency hygiene, and common web vulnerability mitigation.
• Troubleshoot issues across application, database, network, certificate, proxy, load-balancing, and infrastructure layers rather than viewing the Java application in isolation.

6. High-Level & Low-Level Design

• Own and prepare High-Level Designs (HLDs) for significant product capabilities and customer-facing solutions.
• Document architecture, components, responsibilities, integration points, deployment topology, data flows, interfaces, security considerations, technology choices, assumptions, and NFRs.
• Break HLDs into implementable components and guide engineers in preparing Low-Level Designs (LLDs), class/component designs, sequence diagrams, API specifications, schemas, and detailed integration logic.
• Review and validate LLDs before implementation and verify that delivered code remains aligned to approved architecture and design.
• Maintain design decision records and technical documentation at a level that supports engineering, supportability, future enhancement, and knowledge transfer.

7. Non-Functional Requirements & Production Engineering

• Take explicit ownership of performance, scalability, availability, reliability, resilience, security, maintainability, extensibility, observability, auditability, backup/recovery, disaster recovery, and capacity considerations.