Java Backend Developer

Compunnel, Inc.; Alpharetta (GA); On-site; USD 110,000 - 150,000; Full time

Job summary

Compunnel, Inc. is seeking a Java Backend Developer to design, optimize, and troubleshoot high-performance applications for large user bases.

You will work across Java 8–21, focusing on concurrency, load testing, and distributed systems, building reliable microservices in containerized environments. You will design load-testing strategies with JMeter, optimize SQL interactions, and perform root-cause analysis using profilers like YourKit.

Qualifications

• Java development across Java 8–21.
• Expert in multi-threading and concurrency.
• Strong SQL optimization and indexing knowledge.
• Experience with performance profiling and load testing.
• Experience building microservices with Docker and Kubernetes.
• Experience with distributed systems and caching (Redis).

Responsibilities

• Read, debug, optimize, and refactor backend code across Java 8–21.
• Design and execute load testing with JMeter.
• Tune SQL interactions with indexing and pooling.
• Analyze logs and use profilers like YourKit for root-cause analysis.
• Troubleshoot CPU, memory, and concurrency bottlenecks.
• Architect and maintain backend components on Kubernetes and load balancers.
• Apply data structures and Big-O analysis to reduce latency.
• Develop and deploy scalable microservices with Docker/Kubernetes.
• Implement and optimize caching with Redis.

Skills

Java

Multithreading

SQL optimization

Performance profiling

Microservices

Load testing

Debugging

Tools

Docker

Kubernetes

Redis

JMeter

YourKit

Job description

The Java Backend Developer will design, maintain, optimize, and troubleshoot high-performance backend applications supporting large user bases. The role requires deep hands-on Java expertise across Java 8, 11, 17, and 21, with a strong focus on performance engineering, load testing, database optimization, concurrency, and distributed systems. The developer will analyze and refactor existing code, identify and resolve CPU, memory, and concurrency issues, and build reliable microservices using modern containerized and distributed architectures.

Key Responsibilities

• Read, debug, optimize, and refactor existing backend codebases written across Java 8, 11, 17, and 21.
• Design and execute load-testing strategies using tools such as JMeter to evaluate system stability, performance, and bottleneck boundaries.
• Manage, tune, and optimize SQL database interactions using indexing, connection pooling, lock management, and other performance optimization techniques.
• Perform root-cause analysis of application and system issues by analyzing logs and using profiling tools such as YourKit or equivalent.
• Troubleshoot CPU spikes, memory leaks, concurrency bottlenecks, and other performance-related issues.
• Architect and maintain reliable backend components operating across load balancers, Kubernetes environments, and distributed networks.
• Apply appropriate data structures, algorithms, and Big O analysis to address latency and throughput challenges.
• Develop and deploy scalable microservices using Docker, Kubernetes, and load-balanced architectures.
• Implement and optimize caching solutions using technologies such as Redis.

Required Qualifications

• Deep hands-on Java development experience across Java 8 through Java 21.
• Expert understanding of multi-threading, thread safety, locks, and concurrent programming patterns.
• Advanced knowledge of SQL optimization, execution plans, indexing strategies, and connection pooling.
• Demonstrated experience with performance profiling and load testing using JMeter, YourKit, or similar tools.
• Experience building and deploying microservices using Docker and Kubernetes.
• Experience working with load-balanced and distributed network architectures.
• Hands-on experience with caching frameworks such as Redis.
• Strong understanding of data structures, algorithms, and time and space complexity using Big O analysis.
• Proven ability to identify and resolve memory leaks and performance bottlenecks.
• Strong root-cause analysis and troubleshooting skills for enterprise backend applications.
• Ability to read, debug, and refactor complex existing codebases.

Preferred Qualifications

• Experience supporting high-throughput applications with a large active user base.
• Strong background in performance engineering and system optimization for enterprise-scale applications.