Java Architect

Klaxontech Inc; Cary (NC); On-site; USD 150,000 - 190,000; Full time

Job summary

Klaxontech Inc. is seeking a hands-on Java API architect to own the enterprise API layer on Azure.

You will design end-to-end API contracts, data models and versioning, then implement reference services in Java Spring WebFlux and Python automation. You will work closely with customer teams, define standard patterns for inbound/outbound interfaces, and ensure scalable, resilient API delivery with Azure services such as App Service and AKS.

Qualifications

• 10+ years in API, integration or backend engineering.
• 3+ years owning API architecture and design at enterprise scale.
• Strong hands-on Java with Spring Boot and Spring WebFlux; reactive streams and non-blocking I/O.
• Deep API design skills: REST & OpenAPI, contract-first development, versioning & idempotency.
• Secure file-transfer patterns at scale (SFTP, signed URLs, multipart uploads).
• Proven ability to design and architect, not just build, with target-state designs and ADRs.
• Hands-on API delivery in an Azure environment with App Service, AKS or Container Apps.

Responsibilities

• Design and own the end-to-end API layer architecture, including service boundaries, contracts, data models and versioning.
• Build reactive Java Spring WebFlux services for data exchange and large file transfers.
• Define OpenAPI specifications and contract-first workflows; enforce backward compatibility.
• Develop reference services and patterns for the engineering team to pattern-match.
• Deploy and operate APIs on Azure using App Service, AKS or Container Apps and Azure API Management.
• Collaborate with client teams to align interfaces, ADRs and delivery sequencing.

Skills

API architecture ownership

Java with Spring WebFlux

Azure cloud

Python automation

Contract-first API design

SQL & data modeling

CI/CD & IaC

Technical writing

Tools

Azure App Service

AKS

Container Apps

Terraform

Azure API Management

Kafka / Event Hubs

Job description

Experience

• Hands-on architect · API design and architecture · Java Spring WebFlux · Azure · Python
• Function / team
• Engagement
• Embedded with the customer team, working alongside their architects and engineers

About the role

• We are building an enterprise Data Hub on Azure that ingests, curates and serves data across a wide set of inbound and outbound interfaces. APIs are the front door to that platform: reactive Java Spring WebFlux services handle both data exchange and large file transfers to and from partner and downstream systems.
• We are looking for a hands-on Java API architect to own that API layer end to end. You will work closely with the customer, partnering with their architects, engineers and system owners to agree interface contracts and delivery sequencing, and you will be accountable for the design and architecture of every API the Data Hub exposes and consumes.
• This is a design-and-build role, not a diagrams-only role. You will set the standards, then prove them by writing the reference services your engineers pattern-match against. Expect roughly a 60/40 split between architecture and hands-on engineering.
• Own the API architecture: define and maintain the end-to-end design of the API layer, covering service boundaries, contracts, data models, error semantics and versioning strategy, and keep it documented and current.
• Design the interface landscape: produce repeatable, reusable API patterns for the many inbound and outbound interfaces, covering data exchange, file push and pull, synchronous and asynchronous flows, rather than one-off services per consumer.
• Set the contract standards: own the OpenAPI specification approach, naming and payload conventions, backward-compatibility rules and the contract-first workflow between producers and consumers.
• Design for large file transfer: define the patterns for moving large payloads reliably, including chunked and resumable transfers, streaming request and response bodies, signed URLs, checksums and restart on failure.
• Make and record trade-offs: choose between synchronous APIs, queue-backed asynchronous flows and bulk file interfaces, and capture the reasoning in ADRs so decisions survive team turnover.
• Design for resilience and scale: throughput and latency targets, backpressure, circuit breaking, retries with idempotency, rate limiting, timeout budgets and graceful degradation.

Hands-on Engineering

• Build the reference services: design and hands-on develop reactive Java Spring WebFlux services for data exchange and large file transfer, and set the template the rest of the team builds from.
• Work reactive, not blocking: apply Project Reactor properly, covering backpressure, non-blocking I/O and streaming of large payloads and files without exhausting memory.
• Build the supporting tooling: use Python for automation, test harnesses, contract validation, load and soak testing, and operational scripting around the API estate.
• Stay in the codebase: review pull requests, pair with engineers, unblock hard technical problems and debug production incidents alongside the team.
• Run APIs on Azure: design and deploy services on Azure using App Service, AKS or Container Apps, with Azure API Management fronting the estate for gateway policies, throttling and subscription management.
• Integrate with the platform: connect the API layer to ADLS Gen2 storage and to the pipelines that populate it, so APIs serve curated data and land inbound files into the right zones.
• Handle asynchronous flows: use Azure Event Hubs, Service Bus or Kafka where messaging fits better than a synchronous call, including CDC and event-driven notification patterns.

Security & governance

• Design the API security model: OAuth2, OIDC and JWT, mutual TLS where partner integrations require it, Entra ID (Azure AD) identities and managed identities, and Key Vault for secret management.
• Lock down the network: private endpoints, network isolation, IP restrictions and gateway policy enforcement across environments.
• Protect sensitive data: define PII classification, masking, tokenisation and encryption standards in transit and at rest, and ensure they hold across every interface.
• Build in quality controls: contract testing, payload validation, reconciliation and audit logging so integration issues are caught before a consumer finds them.

DevOps & operations

• Automate everything: CI/CD for API code in Azure DevOps, with automated unit, contract and integration testing, environment promotion and rollback.
• Infrastructure as code: define and maintain the API infrastructure with Terraform.
• Make it observable: logging, distributed tracing, metrics, alerting and SLA monitoring across APIs with Azure Monitor and Application Insights.

Collaboration & leadership

• Partner with the customer team: work day to day with their architects, engineers and system owners to agree contracts, resolve design questions and keep delivery moving.
• Lead technically: mentor API engineers, run design reviews, and raise the engineering bar without becoming a bottleneck.
• Support delivery: size work, flag risk early, and work with delivery leads on sequencing and dependencies across interfaces.

What you'll need (must-have)

• 10+ years in API, integration or backend engineering, including 3+ years owning API architecture and design at an enterprise scale.
• Strong hands-on Java with Spring Boot and Spring WebFlux / Project Reactor: reactive streams, backpressure, non-blocking I/O, and streaming large payloads and files without exhausting memory.
• Deep API design skills: REST and OpenAPI, contract-first development, versioning, pagination, error and status-code semantics, and idempotency.
• Secure file-transfer patterns at scale, including SFTP, signed URLs, and multipart and resumable uploads and downloads.
• Proven ability to design and architect, not just build: you can produce target-state designs, sequence diagrams and interface specifications, and defend the trade-offs to a client architecture forum.
• Hands-on API delivery in an Azure environment:
• Compute and hosting: App Service, AKS or Container Apps, with containerised deployment.
• Azure API Management for gateway policies, throttling, subscriptions and developer portal.
• Entra ID, managed identities, RBAC, Key Vault and private endpoints.
• Messaging and event-driven integration with Azure Event Hubs, Service Bus or Kafka.
• Working knowledge of Python for automation, testing and operational tooling around the API estate.
• Strong SQL and data modelling, plus schema and contract design for integration.
• CI/CD and IaC in anger: Git branching strategy, automated pipelines in Azure DevOps, Terraform, and automated contract and integration testing.
• Clear technical writing, and the ability to present and defend a design to both engineers and non-technical stakeholders, including client-side teams.

Nice to have

• Working experience on data engagements with Azure Databricks, Azure Data Factory and ADLS Gen2, including medallion or lakehouse architectures.

Azure certifications (AZ-204, AZ-305) or equivalent.

• Experience working as part of a client-embedded team in a services or consulting model.
• Insurance or wider financial services experience, with GDPR and SOC 2 obligations.
• Experience in integrating with ERP systems(Workday)
• GraphQL, gRPC or event-streaming API styles alongside REST.
• API gateway migration or estate consolidation experience.
• Data mesh or data-product thinking, and data contracts between producers and consumers.