- Write code to build and enhance applications/services and promote code-reviews, code scanning, and other standard development practices to deliver high-quality artifacts to production.

- Design and implement high-performance, event-driven applications leveraging Java, Go, and modern messaging systems like NATS and Kafka.

- Build scalable architectures and microservices using gRPC streaming and HTTP/2 for low-latency communication.

- Drive system design for high TPS (transactions per second) environments ensuring reliability and fault tolerance.

- Apply advanced design principles and patterns to deliver robust, maintainable solutions.

- Engineer and optimize in-memory, high-performance distributed caches (e.g., Apache Ignite) to enable low-latency reads/writes and resilient data grids at scale.

- Define caching strategies (read-through, write-through, near/cache aside) and tune partitioning, affinity, persistence, and eviction for predictable performance under high TPS.

- Design and operate streaming and batch pipelines for real-time and nearreal-time processing, ensuring exactly-once semantics, backpressure handling, and robust error recovery.

- Orchestrate hybrid data workflows that combine streaming ingestion with batch reconciliation to maintain consistency, auditability, and SLA compliance.

- Implement observability (metrics, tracing, logging) for caches and data pipelines, and conduct capacity planning and performance tuning (GC, thread pools, serialization).

About You :

- Has ability to write secure code in languages (e.g., Java, go)

- Familiar with secure coding standards (e.g., OWASP, CWE, SEI CERT) and vulnerability management

- Has skills in building applications using open frameworks to achieve reuse and reduce development times (e.g., Spring Boot )

- Understands internals of operating systems (Windows, Linux) to write interoperable and performant code

- Able to perform debugging and troubleshooting to analyze core, heap, thread dumps and remove coding errors

- Understands use cases for advanced design patterns (e.g., service-to-worker, MVC, API gateway, intercepting filter, dependency injection, lazy loading, all from the gang of four) to implement efficient code

- Has skills to orchestrate release workflows and pipelines and apply standardized pipelines via APIs to achieve CI and CD using industry-standard tools (e.g., Jenkins, Bamboo, AWS/Azure pipelines, XL Release, others)

- Able to configure rules and build automation for code with vulnerability scanning and software composition analysis using standard tools (e.g., Sonar, Checkmarx, Nexus, JFrog XRay, Veracode, others)

- Proven expertise in Java and Go with hands-on experience in building distributed systems.

- Strong knowledge of gRPC streaming, HTTP/2 protocol, and asynchronous communication patterns.

- Deep understanding of architecture, system design, and design patterns for enterprise-grade applications.

- Experience with event-driven architectures, NATS, Kafka brokers, and designing systems for high throughput and scalability.

- Hands-on experience with in-memory distributed caches (preferably Apache Ignite) including data grid design, cluster sizing, affinity mapping, and persistence configuration.

- Strong understanding of cache consistency models, TTL/eviction strategies, and hot-key mitigation in high-throughput systems.

- Practical expertise in streaming and batch processingdesigning pipelines with checkpointing, idempotency, windowing, and schema evolution across environments.

- Comfortable optimizing end-to-end data paths : serialization formats, network I/O, threading/concurrency, and resource tuning to meet stringent latency and throughput targets.

- Proven ability to balance real-time processing with batch backfill/reprocessing, ensuring data correctness, resilience, and operational simplicity.