OctogleHire
Vetted Kotlin engineers, AI-native

Hire senior andproven Kotlinengineers

Android and server-side Kotlin, written by people who have shipped both. The top 4% of applicants, scored on real code and ready to start in days.

Teams shipping with Octogle Hire
Beekey
Hireflow
Corpwise
Solidus
SquareLogik
Unichats
DNO Investments
The Care App
Workchats
Beekey
Hireflow
Corpwise
Solidus
SquareLogik
Unichats
DNO Investments
The Care App
Workchats
Your shortlist, previewed

Pick the Kotlin problem. See who we would send.

16 matching engineers · updated hourly
Oleksandr MelnykSenior Android Engineer94/ 100
StackCompose, Hilt, coroutinesShippedBanking app, 1M+ installsExtrasBaseline profiles
Kharkiv · UTC+3$28/h
Mariana SilvaMobile Engineer90/ 100
StackCompose, RoomShippedOffline-first catalogueExtrasWorkManager sync
Recife · UTC-3$32/h
Camila RodriguesEngineer86/ 100
StackView interopShippedStaged Compose migrationExtrasScreenshot tests
São Paulo · UTC-3$26/h
The funnel

25,000 applied. 1,000 got in.

Five scored stages, all finished before a profile reaches you. Nobody skips a stage to hit a deadline.

25,000remain
Stage 01Application reviewRead by an engineer, not a keyword filter.
10,000remain
Stage 02HR + communication screenLive English fluency and product-mindset interview.
4,000remain
Stage 03AI-led Kotlin interviewA 30–50 minute adaptive interview tuned to the CV.
1,600remain
Stage 04Tech lead interviewSystem design and production judgement, face to face.
1,000remain
Stage 05References + backgroundTwo calls with former leads, plus verification.
What it costs

From £15 an hour. That is the whole pricing page.

One hourly rate with our margin printed on every invoice, billed monthly. No placement fee and no notice period beyond two weeks.

What are you looking for?Rates shown in your currency, compared with hiring locally.
Hiring with Octogle£2,598to£5,716/ monthEquivalent to £15–£33 an hour
Save up to £68,587 a yearAll expenses included. No hidden costs.
Hiring locally in United Kingdom£8,314/ monthEquivalent to £48 an hour
45% higher annual costBased on loaded local cost, including employer on-costs.
Indicative only — your quote is confirmed on the brief call.
The role

What a Kotlin engineer does

Kotlin engineers build backend services, Android applications, data pipelines, internal platforms, and developer tools using Kotlin’s null-safety, coroutines, concise type system, and Java interoperability. In a modern stack, Kotlin commonly sits on the JVM with Spring Boot 3.x, Ktor 3.x, Micronaut, Gradle, PostgreSQL, Kafka, Redis, Docker, Kubernetes, and cloud services. Teams also use Kotlin Multiplatform where shared domain logic across Android, iOS, and server clients makes sense. A mid-level Kotlin engineer can ship features, write idiomatic data classes and sealed hierarchies, use coroutines safely, and work within an existing architecture. A senior Kotlin engineer makes the harder calls: choosing coroutine boundaries, modeling domain states precisely, preventing nullability and Java interop bugs, designing testable APIs, improving Gradle build health, and mentoring teams away from “Java written in Kotlin” toward maintainable Kotlin 2.x code.

Typical responsibilities

  • Design, build, and maintain Kotlin JVM services using frameworks such as Spring Boot 3.x, Ktor 3.x, or Micronaut.
  • Model business domains with idiomatic Kotlin: data classes, sealed interfaces, value classes, extension functions, and expressive type constraints.
  • Implement safe asynchronous and concurrent code with kotlinx.coroutines, structured concurrency, Flow, cancellation, timeouts, and backpressure-aware integrations.
  • Integrate with databases, messaging, and external APIs using tools such as Exposed, jOOQ, Hibernate, Kafka clients, gRPC, REST, and OpenAPI.
  • Own quality through unit, integration, contract, and performance tests using JUnit 5, Kotest, MockK, Testcontainers, and CI pipelines.
  • Improve production reliability by instrumenting services with logs, metrics, traces, health checks, clear error handling, and runbook-ready operational behavior.

Must-have skills

  • Strong Kotlin 2.x knowledge, including null-safety, generics, variance, inline/value classes, sealed types, scope functions, and idiomatic collection APIs.
  • Production experience building JVM backend services with Spring Boot 3.x, Ktor 3.x, or a comparable Kotlin-friendly framework.
  • Practical coroutine experience, including structured concurrency, Dispatchers, cancellation, SupervisorJob, Flow, exception propagation, and avoiding blocking calls on coroutine threads.
  • Solid Java interoperability skills, including platform types, annotations, checked exceptions, Java collections, Lombok pitfalls, and migration from Java codebases.
  • Database and persistence experience with PostgreSQL or MySQL plus jOOQ, Exposed, Hibernate/JPA, Flyway, Liquibase, or similar tools.
  • Testing discipline with JUnit 5, Kotest or AssertJ, MockK, Testcontainers, and clear separation of unit, integration, and contract tests.
  • Build and delivery experience with Gradle Kotlin DSL, dependency management, Docker, CI/CD, observability, and deployment to cloud or Kubernetes environments.

Nice to have

  • Kotlin Multiplatform experience for sharing domain, networking, or validation logic across Android, iOS, backend, or desktop targets.
  • Experience with Kafka, RabbitMQ, or other event-driven systems, including idempotency, retries, ordering, and schema evolution.
  • Android or Compose experience, especially where backend/API design must support mobile clients cleanly.
  • Performance tuning experience on the JVM, including allocation reduction, coroutine debugging, profiling, GC awareness, and load testing.
  • Familiarity with Arrow, functional error handling, OpenTelemetry, gRPC, GraphQL, or native-image/AOT constraints where relevant.
How to interview

8 Kotlin interview questions that reveal real depth

These are the kinds of questions our engineers use in technical interviews. Each comes with what a strong answer sounds like.

Full set: 25 Kotlin questions by level, with red flags
  1. Q1

    How do you decide when to use coroutines, Flow, or regular blocking code in a Kotlin backend service?

    Strong answer: A strong candidate separates concurrency from fashion. They use regular blocking code when the framework and workload are thread-per-request and simple. They use suspend functions for scalable I/O and structured concurrency. They choose Flow for streams or multiple asynchronous values, not single responses. They mention cancellation, dispatcher choice, blocking call isolation, and testability.

  2. Q2

    What are common coroutine bugs you have seen in production Kotlin systems?

    Strong answer: A strong answer covers launching work in GlobalScope, swallowing CancellationException, blocking Default or event-loop threads, forgetting timeouts, leaking child jobs, using SupervisorJob without understanding failure semantics, and mixing reactive APIs poorly. They should explain how structured concurrency, coroutine scopes owned by application components, and observability help find and prevent these issues.

  3. Q3

    How do you model domain state idiomatically in Kotlin?

    Strong answer: Look for sealed interfaces or sealed classes for finite states, data classes for immutable values, value classes for constrained identifiers, and nullable types only when absence is valid. A senior candidate avoids primitive obsession, validates at boundaries, keeps invariants close to constructors or factories, and uses exhaustive when expressions to make invalid states harder to represent.

  4. Q4

    What Kotlin and Java interoperability problems do you watch for?

    Strong answer: A strong candidate mentions platform types from Java, missing nullability annotations, mutable Java collections, Lombok-generated APIs, overloaded methods, checked exceptions, SAM conversions, and Java Optional misuse. They should know how to add annotations, wrap unsafe Java APIs, avoid leaking platform types, and design Kotlin APIs that remain understandable to Java callers when needed.

  5. Q5

    How would you structure tests for a Kotlin service that talks to PostgreSQL and Kafka?

    Strong answer: A strong answer separates fast domain tests from integration tests. They use Kotest or JUnit 5 for pure logic, MockK sparingly for boundaries, Testcontainers for PostgreSQL and Kafka behavior, and contract tests for API or message schemas. They should discuss deterministic coroutine tests with runTest, transaction cleanup, fixtures, and CI runtime control.

  6. Q6

    What does “idiomatic Kotlin” mean to you, and when can it go too far?

    Strong answer: Strong candidates describe clear, type-safe, readable Kotlin rather than clever syntax. They use data classes, null-safety, extension functions, sealed types, and standard library functions where they improve intent. They avoid excessive scope-function nesting, overuse of operator overloads, unnecessary DSLs, and dense functional chains that make debugging or onboarding harder.

  7. Q7

    How do you approach Gradle build health in a Kotlin codebase?

    Strong answer: A senior candidate talks about Gradle Kotlin DSL, version catalogs, convention plugins, dependency locking or verification, avoiding buildSrc bloat, configuration cache readiness, incremental compilation, and clear module boundaries. They understand kapt can slow builds and may prefer KSP where supported. They should also mention reproducible CI and managing Kotlin, JVM, and plugin versions together.

  8. Q8

    How would you migrate a Java service or mixed JVM codebase toward Kotlin safely?

    Strong answer: A strong answer favors incremental migration. They start with tests and boundaries, add nullability annotations to Java, migrate leaf classes or new features first, and avoid rewriting stable code without business reason. They watch for platform types, Lombok, JPA proxy constraints, serialization differences, and ensure Java and Kotlin style guidelines coexist during the transition.

Job description

Senior Kotlin engineer job description

A ready-to-paste template. Or skip the posting entirely: send it to us as your brief and get a scored shortlist in 48 hours.

Mid and lead versions
Senior Kotlin Engineer

About the role
We are hiring a Senior Kotlin Engineer to build and improve JVM-based backend services used by product and platform teams. You will work in a remote engineering team, make technical decisions, and help raise the quality of a Kotlin codebase running in production.

What you'll do
Design and deliver Kotlin services using Spring Boot, Ktor, or similar JVM frameworks.
Model domain logic with clear, type-safe Kotlin.
Build reliable async workflows with coroutines, Flow, and structured concurrency.
Integrate with databases, queues, APIs, and cloud infrastructure.
Write unit, integration, and contract tests with tools such as JUnit 5, Kotest, MockK, and Testcontainers.
Improve observability, build pipelines, performance, and operational reliability.
Review code and mentor engineers moving from Java or less idiomatic Kotlin.

What you'll bring
Strong production Kotlin experience on the JVM.
Deep understanding of null-safety, sealed types, generics, collections, and Java interop.
Hands-on experience with Gradle, Docker, CI/CD, SQL databases, and service monitoring.
Good judgment around architecture, testing, tradeoffs, and remote collaboration.
Why teams choose Octogle

What you get with Kotlin

Pre-Vetted Expertise

Every Kotlin developer on OctogleHire passes a rigorous vetting process covering technical skills, communication, and problem-solving ability.

Start in Days, Not Months

Skip the lengthy recruitment cycle. Our Kotlin engineers are ready to integrate with your team and start delivering within days.

Up to 60% Cost Savings

Access world-class Kotlin talent at a fraction of the cost of local hires, without compromising on quality or experience.

Risk-Free Trial Period

Every Kotlin engagement starts with a trial period. If you're not completely satisfied, you pay nothing.

What you get

The engagement, as a spec sheet

Shortlist3–5 scored profiles in 48 hoursEach with a technical assessment, a system-design write-up and reference checks already completed.
EngagementFull-time on one clientIn your repo, your standups and your on-call rotation. Part-time from 20 hours on request.
RateOne published hourly rateOur margin is printed on every invoice. No placement fee and no annual minimum.
Trial14-day replacement guarantee30 days on Marketplace. If the fit is wrong we re-shortlist inside 48 hours.
NoticeTwo weeksNo long-term lock-in and no cancellation fee.
ComplianceHandled in 30+ countriesContracts, IP assignment, payroll and local employment law. You receive a single invoice.
IPYours from the first commitAssigned in the master agreement, signed before repository access is granted.
SecurityISO 27001, GDPR, CCPAEU or US data residency available on request.
Compare

How OctogleHire compares

Vetting

Agency

Resume screening only

Freelance

Self-reported skills

OctogleHire

5-stage technical vetting (1 in 25 pass rate)

Time to Hire

Agency

6–12 weeks

Freelance

Weeks of filtering

OctogleHire

48 hours to first match

Cost

Agency

$20K–$40K placement fees

Freelance

Low rates, variable quality

OctogleHire

40–60% less, no placement fee

Compliance

Agency

You manage it

Freelance

You manage it

OctogleHire

Fully managed (30+ countries)

Replacement

Agency

30–90 days (if any)

Freelance

None

OctogleHire

14–30 day replacement guarantee

Support

Agency

Account rep (9-5)

Freelance

Ticket system

OctogleHire

Dedicated account manager

Daniel bell
“We in need of a handful of developers for our internal CRM build after speaking with multiple agencies and receiving some quotations we sat down with Yaseen from Octogle and we were pleasantly surprised to see what was available for us within their talent pool. we took on three developers saving upwards of circa £6000 per month and developing the software in record time exactly how we wanted it. Highly suggest anyone to use octogle hire if you’re looking for a cost-effective high-quality software development solution.”
Daniel bellCMO, TNW Energy3Senior full stack developerss hired£225,000saved per year
Questions

Questions engineering leaders ask

Yes, Kotlin is a strong backend choice when you want JVM maturity with a more expressive language than Java. It works well with Spring Boot 3.x, Ktor 3.x, Micronaut, Gradle, PostgreSQL, Kafka, and cloud-native deployment. The main requirement is hiring engineers who understand both Kotlin idioms and JVM production behavior, not just syntax.

For a critical Kotlin codebase, hire someone with real Kotlin production experience. Java engineers can become productive in Kotlin, but senior Kotlin work requires judgment around nullability, coroutines, sealed models, extension functions, Gradle Kotlin DSL, and Java interop. If your team is migrating from Java, a candidate strong in both Java and Kotlin is especially valuable.

Test more than language trivia. Ask candidates to model a domain with sealed types and value objects, review coroutine code for cancellation and blocking issues, write a small integration test, and explain Java interop risks. For backend roles, include SQL, API design, Gradle, observability, and production debugging. The best signal is practical reasoning about tradeoffs.

It depends on the codebase, onboarding quality, and domain complexity. A strong Kotlin engineer can usually start contributing quickly if the project has clear build steps, tests, architecture notes, and local development setup. Productivity is slower when Gradle is fragile, coroutine patterns are inconsistent, or Java interop issues are undocumented. Good onboarding matters as much as language experience.

Choose Kotlin if you value null-safety, concise domain modeling, coroutines, and modern language features while staying on the JVM. Choose Java if your team’s ecosystem, hiring plan, and existing codebase strongly favor it. Many companies run both. The real decision is whether your team can maintain idiomatic Kotlin and avoid mixing incompatible styles across services.

Kotlin is usually easier for JVM teams that want pragmatic language improvements, strong Java interop, and a smaller learning curve. Scala may fit teams committed to advanced functional programming and its ecosystem. For most product engineering teams, Kotlin’s balance of type-safety, readability, and framework compatibility is attractive. The best choice depends on team skill and long-term maintainability.

Use a freelance Kotlin developer for a defined project, migration, audit, performance fix, or short-term delivery gap. Hire full-time when you need long-term ownership of architecture, domain knowledge, production reliability, and mentoring. Kotlin systems benefit from consistency in coroutine patterns, testing style, and Gradle structure, so ownership model matters as much as technical skill.

Use a structured process. Start with a technical conversation about past Kotlin production work, then give a realistic exercise or code review involving coroutines, API design, persistence, and tests. Evaluate written communication, pull request quality, decision-making, and ability to explain tradeoffs. Remote success depends on clarity, async updates, documentation habits, and disciplined engineering, not only coding speed.

You'll receive 3–5 vetted candidate profiles within 48 hours of your demo call. Most companies go from first intro to signed contract in under 5 business days — compared to 6–12 weeks with traditional agencies.

Every developer passes a 5-stage process: application screening, stack-specific technical assessment, live system design interview, soft-skills evaluation, and reference checks. From over 25,000 applicants reviewed, only 1,000 have been accepted into our network.

OctogleHire engineers start at £15/hr (about $19), with senior engineers at about £24/hr. That is roughly 50–65% less than the loaded cost of an equivalent in-house hire in the UK, US or Australia — a senior UK hire costs about £48/hr once employer costs are included. There are no upfront fees or placement commissions; you pay one published hourly rate once your engineer starts.

Every placement includes a risk-free replacement guarantee — 14 days on our On-Demand plan and 30 days on our Marketplace plan. If a developer doesn't meet your expectations, we'll find a replacement at no additional cost and manage the transition for you. Our replacement rate is under 6%.

No sales call in between

Send the brief. Meet Kotlin engineers on Thursday.

Twenty minutes with an Octogle engineer, then three to five scored profiles inside 48 hours. Free to post, with a replacement guarantee on every placement.