Job Type:

Permanent

Experience:

8 - 12 Years

Location:

Bangalore

Life at EvoluteIQ:

We at EvoluteIQ believe in the power of transformation. We are committed to building a industry-leading technology that will revolutionize the way enterprises conduct business. To make that happen, we need people who are generous, genuine, self-driven and collaborative. People who not only want to be a part of a fast-growing and radical thinking company, but who are kind and care—about each other. We at EvoluteIQ thrive in the company of each other and make each other a better version of ourselves every day.

Could that be you?

The EIQ Mission:

Our culture is who we are, and it defines us. We are nimble, fast, dedicated, humble and bold. We see opportunities everywhere around us to make a “dent in the universe”. Our core fabric is Innovation! And this is not just a word, but the way of life within EvoluteIQ. Changing the way business is done, reimagining the future of work, and enabling people to improve their quality of work every day, is a daunting task. That is what we all strive every day at EvoluteIQ. To enable everyone to automate complicated processes with their instinct and knowledge.

We make building of automation simple for everyone, so that it is not mystery for a few.

Would you like to be part of this journey?

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 solid 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.
- Translate NFRs into measurable design and engineering requirements rather than treating them as late-stage testing concerns.
- Define appropriate timeouts, retries, circuit-breaking, resource limits, thread/connection pools, caching, queue sizing, health checks, graceful degradation, and failure-handling behaviour.
- Work with QA/Performance/DevOps teams to validate NFRs through performance, load, resilience, failover, security, and operational readiness testing.
- Ensure production telemetry is sufficient for diagnosis through structured logging, metrics, traces, alerts, correlation IDs, dashboards, and actionable health indicators.

8. Problem Solving, Troubleshooting & Root-Cause Analysis

- Demonstrate strong analytical problem solving and the ability to break down complex issues systematically.
- Diagnose performance degradation, memory problems, CPU spikes, deadlocks, thread starvation, slow database queries, network latency, connection exhaustion, message backlogs, and integration failures.
- Use logs, metrics, thread dumps, heap dumps, profilers, query plans, traces, operating-system indicators, and infrastructure telemetry to isolate causes.
- Drive root-cause analysis and permanent corrective actions rather than temporary workarounds.
- Lead the engineering response for difficult production incidents and customer-critical technical problems when required.

9. WBS, Estimation & Delivery Planning

- Translate requirements and designs into clear technical work packages and implementation plans.
- Prepare and/or validate Work Breakdown Structures (WBS), ensuring tasks are sufficiently decomposed for execution and tracking.
- Prepare and validate estimates for design, development, unit testing, integration, documentation, security, performance, deployment, and production-readiness activities.
- Identify dependencies, assumptions, risks, unknowns, external interfaces, and critical technical sequencing before commitments are made.
- Work closely with Project Management to track technical progress, resolve blockers, highlight delivery risks early, and maintain realistic implementation plans.

10.



Product Management & Requirement Collaboration

- Work closely with Product Management to understand business objectives, user journeys, product requirements, priorities, and acceptance criteria.
- Challenge ambiguous or incomplete requirements constructively and identify missing technical, data, integration, error-handling, security, and NFR considerations.
- Provide feasibility assessments, technical options, trade-offs, dependencies, and cost/complexity implications to support product decisions.
- Participate in backlog refinement and ensure that requirements are technically actionable before they enter development.
- Translate product intent into a solution that the engineering team can design, estimate, implement, test, and support.

11. Technical Leadership & Team Development

- Lead and mentor Java/backend engineers while setting a high bar for engineering quality and ownership.
- Guide developers in architecture, detailed design, coding, debugging, testing, performance, and production support practices.
- Conduct architecture reviews, design reviews, code reviews, and technical walkthroughs.
- Delegate detailed engineering ownership appropriately while remaining accountable for overall technical quality.
- Establish reusable patterns, coding standards, engineering guidelines, and review practices.
- Identify and manage technical debt, refactoring needs, obsolete dependencies, and structural weaknesses in the codebase.
- Improve the team’s capability to independently perform LLD, estimation, troubleshooting, and production-quality engineering.

What you'll do at EvoluteIQ:

- Java 11/17/21 or comparable modern Java versions; strong core Java and JVM fundamentals.
- Spring Framework / Spring Boot; Spring Security and related ecosystem experience preferred.
- REST APIs, web services, microservices and distributed application architecture.
- JPA/Hibernate or equivalent persistence technologies.
- RDBMS and SQL; schema design, transaction management, query optimisation and performance tuning.
- NoSQL/cache/search technologies such as Redis, MongoDB, Elasticsearch or equivalent.
- Messaging/event technologies such as Kafka, ActiveMQ, RabbitMQ or equivalent.
- HTTP/HTTPS, SSL/TLS, DNS, OAuth2/OIDC/JWT, API security and certificate fundamentals.
- Linux, NGINX/reverse proxies, load balancing and clustering concepts.
- Docker, Kubernetes fundamentals, CI/CD, cloud deployment concepts and observability tooling.
- Performance engineering, JVM troubleshooting, profiling, logging, metrics and distributed system diagnostics.
- HLD/LLD, architecture diagrams, sequence diagrams, API contracts, data modelling, design patterns and technical documentation.

What will you bring to the team?

- Typically 8-12+ years of software engineering experience with substantial hands-on Java/backend development.
- At least 2-4+ years in a Technical Lead, Lead Engineer, Senior Technical Architect or equivalent role with direct engineering ownership.
- Proven experience delivering enterprise-grade or large-scale web applications from design through production.
- Demonstrated experience leading developers through HLD/LLD, implementation, code review, testing, deployment and production support.
- Experience working closely with Product Managers, Project Managers, Architects, QA, DevOps/SRE, security teams and other engineering stakeholders.

Must-have:

- The ideal candidate can move comfortably across the complete engineering lifecycle: Requirement -> Architecture -> HLD -> LLD -> WBS -> Estimation -> Hands-on Development -> Code Review -> Testing -> Deployment -> Production Troubleshooting.
- Most importantly, this person should think beyond the Java codebase. They should understand how the full system behaves, be able to trace problems across layers, make sound engineering trade-offs, and provide the technical leadership required to deliver secure, scalable, reliable, maintainable, and operable software.

What We Offer:

- Opportunity to shape the strategy of a next-gen hyper-automation platform.
- Work with a cross-disciplinary team in a fast-growing, innovation-driven environment.
- Competitive compensation and growth opportunities.
- A culture of innovation, ownership, and continuous learning.

Ready to take the next step in your career journey with us? Apply now and become part of a dynamic team that values expertise, collaboration, and a positive work culture! Don’t Meet Every Requirement? We Still Want to Hear From You!

Please go ahead and apply anyway.

We know that experience comes in all shapes and sizes and passion can’t be learned. If you believe, then we would like to meet you and explore that belief!

We value a range of diverse backgrounds, experiences, and ideas. We pride ourselves on our diversity and inclusive workplace that provides equal opportunities to all persons regardless of age, race, colour, religion, sex, sexual orientation, gender identity and expression, national origin, disability, neurodiversity, military and/or veteran status, or any other protected classes.

📌 Technical Lead – Java (Bengaluru)
🏢 evoluteIQ
📍 Bengaluru