Senior Java Software Engineer Medellin, Colombia, Remote

Our Client is a custom software development firm in the US. The teams of senior engineers has built production web applications, mobile applications, and systems integrations for established and growing businesses.
Services: custom software development, data integration and systems architecture, AI-enabled software solutions, technical discovery and product definition.

We're building an advertising marketplace on top of an established network of digital screens. Screen owners bundle up their inventory and sell it. Brands buy placements and run campaigns against them. Our system pushes approved creative out to screens, counts every play, cuts the ad when the budget's spent, and produces the numbers that underpin the invoicing.

The marketplace itself is new. None of it exists yet. The architecture we’ve proposed is what will make this a success.

Some of what's in it:

• An event ledger handling around 5 million plays a day. Append-only, idempotent, auditable, and it needs to accept new event types later without anyone going near the schema.


• Budget enforcement, which runs as a loop across several systems. Playback gets measured, attributed to a campaign, drawn down against that campaign's budget, and the allow/deny result gets picked up downstream at the next scheduling cycle. Those systems don't all run at the same speed, so their latencies are inputs to the design rather than something we assume away.


• Attribution that happens exactly once to avoid confusion. Do it twice and you eventually get an audit trail that disagrees with an invoice.


• The marketplace domain proper: inventory, packages, campaigns, approvals, and two ways to price a buy — a flat package price, or CPM drawn down against measured delivery.


• The interface contracts between our service and the existing platform. You'd co-author them and own them through implementation.


• The new service doesn't run on its own. It reaches into identity, content and scheduling, policy evaluation, and a data lake that all belong to the customer’s existing platform, and a fair share of the work is changes we write into that platform's repositories and take through its review process. Everything additive, everything shipped switched off until we turn it on. Nothing already running is allowed to break.


• So there's design work here and there's integration work, and we want someone who's interested in both. There's plenty of each.


• We use AI coding agents as a normal part of how we work; the requirements doc covers what that means day to day and it's worth reading properly.

Your Team

This team uses AI coding agents as a standard part of the development workflow. A meaningful share of first-draft implementation is agent-generated and then reviewed, corrected, and integrated by engineers. This does not change what we are hiring for — senior engineering judgment, systems design, and accountability for what ships — but it does change the daily shape of the work: proportionally more specification, review, and integration; proportionally less first-draft typing.

We are looking for an engineer who has already worked this way in production and has developed real calibration around it: high trust on mechanical and boilerplate output, high scrutiny on contracts, correctness, security, and edge cases. The common failure modes — confidently wrong logic, misremembered APIs, silent scope creep, over-broad refactors — should be familiar territory rather than a new discovery.

Candidates who are categorically opposed to this workflow and those who would merge generated code without independent verification are both poor fits.

We are seeking a Senior Java Engineer to serve as the technical anchor for a high-stakes, greenfield platform development initiative. In this role, you play a large role in the implementation of complex backend systems using Kotlin and Java on Spring Boot, operating within an AWS-native environment. Your focus will be on building scalable, distributed architectures that integrate seamlessly with various production systems, requiring a deep understanding of systems design and high-performance engineering.

This is a high-impact engineering leadership role that demands both hands-on technical excellence and the ability to drive architectural standards. You will own the design of critical API contracts, manage complex integration points across multiple teams, and maintain a rigorous quality bar through comprehensive code reviews. Working closely with the project lead, you will be responsible for translating high-level architecture into robust, production-ready services while navigating the technical challenges of a cross-functional engineering landscape.

The successful candidate will demonstrate accountability for the correctness and reliability of core system components, including authentication, idempotency, and transactional integrity. We expect an engineer who can manage the technical debt and integration complexities inherent in large-scale platform delivery, ensuring that all shipped systems are verified, performant, and maintainable.

What's in it for you

• Interview process that respects people and their time


• Professional and open IT community


• Internal meet-ups and resources for knowledge sharing


• Time for recovery and relaxation


• Bright online and offline events


• Opportunity to become part of our internal volunteer community

Responsibilities

Architecture & Implementation

• Design and build backend services in Kotlin and Java on Spring Boot, deployed to AWS ECS Fargate behind API Gateway.


• Design and implement the high-throughput, append-only playback ledger — idempotent, auditable, and correct at approximately 5M events per day.


• Model and tune MySQL (Aurora/RDS) schemas for the ledger and marketplace read paths.


• Provision and maintain application infrastructure as code.


• Contribute to SPAs in React and TypeScript where backend work extends into the client.


• Own the code reviews and standards for the Kotlin and Java Spring Boot applications

Contracts & Cross-Team Integration

• Co-author the interface contracts between new services and the existing platform repositories; own them through implementation and revision.


• Author pull requests, negotiating scope and API changes with the owning teams through to merge and deploy.


• Implement and secure machine-to-machine authentication across service boundaries (JWT/OAuth, Cognito, KMS-signed tokens).


• Reconcile documented behavior against live system behavior — the existing documentation diverges from production in places, and finding those gaps early is part of the job.

Quality, Review & Delivery

• Review code at volume and set the standard for what merges.


• Verify by execution and automated test, not by inspection.


• Decompose the delivery plan into well-specified, independently buildable work streams and write the specifications others build against.


• Instrument the platform for observability and support limited-store pilot deployments, including full-loop validation on physical hardware.

Skills

Required Qualifications

• 8+ years of professional software engineering experience, with at least 5 years building and operating production JVM services.


• Deep Java and Kotlin proficiency — able to author and review idiomatic Kotlin and Java with equal confidence.


• Expert-level Spring Boot , including working experience across both the 2.7 and 3.x generations and the differences between them.


• AWS-native engineering experience — ECS Fargate, API Gateway, Aurora/RDS PostgreSQL, Redis, SQS or Kinesis, S3, Cognito, and KMS/IAM.


• Infrastructure-as-code fluency in any mainstream tool (Terraform, CDK, Pulumi, CloudFormation). The concepts transfer; the specific tool does not matter.


• REST API contract design and machine-to-machine authentication (JWT/OAuth, Cognito) in multi-service environments.


• Production MySQL experience — schema design, indexing, and query performance under sustained write load.


• Working proficiency in React and TypeScript — sufficient to review and extend a modern SPA.


• A demonstrated record of cross-team technical negotiation — landing an API or contract change through another team's review and release process.


• Professional experience using AI coding agents (Claude Code or equivalent) as part of a production development workflow, with calibrated judgment about where generated output can be trusted and where it must be scrutinized.

Preferred Qualifications

• Domain experience in DOOH, digital signage, AdTech, or CMS — playlists, impressions, CPM, and sold-unit mechanics.


• Data engineering literacy — Python, Prefect, AWS Glue, and Athena for data-lake read paths.


• Event-driven architecture and idempotent, append-only ledger design at scale.


• Terraform specifically , which is the incumbent IaC standard in the existing repositories.


• Observability and operations depth — metrics, tracing, and alerting design for a system entering pilot.