Java Backend Engineer (Java 17 + ADX/KQL + Event Hub + Search/Retrieval APIs)

Title - Java Backend Engineer (Java 17 + ADX/KQL + Event Hub + Search/Retrieval APIs)

Location-Hybrid @ Dayton, OH

Duration Contract

Job Description Senior Backend Contractor (Java 17 + ADX/KQL + Event Hub + Search/Retrieval APIs)

Role summary

We re hiring a senior contractor to build and operate a Java 17, event-driven service ( ITP ) running in Azure AKS. The service consumes events from Azure Event Hubs, processes JSON payloads, persists metadata/operational data in Azure Data Explorer (ADX), stores large objects in ADLS, and exposes secure Search + Retrieval APIs.

This is a Java/ADX/API role first. You do not need to be an SRE, but you must be platform-literate enough to deploy and troubleshoot your service in AKS via Helm + ArgoCD and work effectively with SRE when deeper cluster issues arise.

Seniority is a must-have. We need someone we can rely on to work independently with guidance from more senior resources, become an SME on the service and its data/query behavior, and help drive future initiatives (not just execute tickets).

Seniority & working style (must-have)

We re looking for someone senior who can operate with limited direction, ramp quickly, and become the go-to person for the service.

You should be comfortable:

• Owning problems end-to-end (requirements design implementation rollout monitoring iteration)
• Making pragmatic technical decisions and documenting trade-offs
• Proactively identifying risks and proposing improvements (not just implementing assigned work)
• Driving cross-team alignment when needed (API consumers, SRE, security/identity, data stakeholders)
• Leaving behind durable artifacts: runbooks, dashboards, query patterns, test strategy, and clear system docs

What you ll build

• Ingest & processing pipeline (Event Hub Java service) with concurrency controls, back-pressure, retries, and idempotency.
• Search API: fast, structured filter/sort/paginate queries with well-designed results.
• Retrieval API: fetch by ID(s) with optional server-side views (projection/transform) to customize client output safely.
• Performance & reliability: profiling and tuning across Java + ADX/KQL + AKS runtime behavior.
• Test & validation harness: unit/integration tests plus targeted performance tests reflecting real query/retrieval patterns.

Key responsibilities

Java backend / event-driven processing

• Implement Event Hub consumption patterns: consumer groups, partition awareness, batching, checkpointing strategy, retries/DLQ, idempotency.
• Design and tune thread pools and scheduled work (e.g., backfills/replays/retries) with safe operational controls.
• Build robust JSON parsing/validation, schema evolution handling, and error routing

ADX (Azure Data Explorer) + query performance

• Write KQL queries for search/filter use cases and operational diagnostics.
• Profile and tune ADX queries (query plan/diagnostics), reducing p95 latency and cost for hot queries.
• Create clear query patterns and guardrails (parameterization, paging strategy, consistent query shapes).

API design: Search vs Retrieval

• Define clean API contracts for search results: returned fields, filters, pagination semantics, error handling.
• Implement retrieval views carefully (versioned, testable, limited scope) to avoid a server-side dumping ground.
• Apply JWT authentication patterns and integrate with internal auth requirements.

Deployment literacy (not SRE, but must be self-sufficient)

• Make safe updates to Helm chart values.
• Use ArgoCD workflows to deploy and understand diffs/sync/rollback.
• Troubleshoot common AKS runtime issues: CrashLoopBackOff, OOMKilled, probe failures, CPU throttling, config/secrets/Managed Identity failures.

Testing + performance testing

• Write strong unit tests (JUnit; mock only boundaries) and integration tests against key dependencies (ADX/ADLS/Event Hub) or realistic test doubles.
• Create repeatable performance tests and publish results/thresholds.

Required qualifications (must-have)

• Senior-level experience shipping and operating production backend services.
• Java 17: concurrency/thread pools, scheduled work, resilience patterns, profiling (CPU/threading).
• Event-driven systems (Event Hub/Kafka equivalents): idempotency, retries/DLQ, replay/backfill safety.
• ADX / KQL: proven ability to write and tune/profile queries (not just run them).
• API design: production experience building search/filter endpoints and retrieval endpoints with stable contracts.
• AKS/Kubernetes literacy: can deploy and debug your service (pods, logs, resources, probes, HPA basics).
• Security basics: JWT validation/claims awareness; practical Managed Identity understanding for accessing Azure services.
• Demonstrated history of becoming the go-to engineer/SME for a service or subsystem.
• Proven ability to drive initiatives: propose roadmap items, shape scope, and deliver with minimal oversight.
• Strong written communication: can produce clear design notes/runbooks and explain complex issues to other teams.

Preferred qualifications (nice-to-have)

• Direct hands-on experience with Azure Event Hubs, ADLS Gen2, AKS, and ADX in the same system.
• HashiCorp Vault and/or Akeyless integrations and secret management patterns.
• Helm chart authoring (not just values editing) and ArgoCD operational experience.
• API views / projection patterns, versioning strategies, and backward compatibility discipline.
• Broader search architecture experience (facets/filter UX, result shaping, pagination edge cases, indexing strategy).
• Observability maturity

Platform literate definition (what we mean)

You are not expected to be SRE, but you are expected to:

• Diagnose: restart loops, OOMs, CPU throttling, misconfigured probes, bad config rollouts.
• Adjust: Helm values for resources/config safely and validate via ArgoCD.
• Identify: when it s a service issue vs a cluster/network/identity policy issue and escalate with crisp evidence.

Regards,

Sai Srikar

Email: