For concurrency bugs that should be impossible, not just rare

Hire Kotlin Developers

Kotlin's null-safety and structured concurrency only protect a codebase that actually uses them with discipline. A platform type or a leaked coroutine slips through the exact gap the language exists to close, and these engineers are tested on catching it.

  • Profiles typically within two business days
  • Replacement Assurance: If an engineer is not the right fit, a replacement from our own team starts within ten business days of your request, at no extra cost
  • You interview before placement if you want to
  • At least four hours a day inside your core working hours. Two hours plus a daily written handover for the US West Coast
  • 14-Day Risk-Free Trial: For your first engineer on a time-and-materials engagement. Up to 14 calendar days or 80 logged working hours, whichever comes first. End within the trial and pay nothing for trial hours. Continue beyond it and those hours are billed at the agreed rate. Unpaid trial work remains ours if you stop
Concurrency proven safe, not just likelyReplacement is our cost, not yoursAI augmented, human governedEvidence before estimatesYour IP from day oneOne accountable owner per engagementFounded in 2011. Part of the Vinove Group500+ full-time engineers, as of September 2026NASSCOM member
Watch · the 90-second brief

How we evaluate a Kotlin engineer

The tasks, the signals and the onboarding, walked through by the people who run them.

90 secWatch without filling in a form.
Engineers reviewing Kotlin coroutine behaviour together.90 secSample frame · video pending

01Published, not promised

The assessment behind every engineer we send.

The Kotlin bar is published, not assumed: five competencies, the exact task behind each, and the shortcut that ends a candidacy. Most interviews ask about syntax sugar. This one asks whether the concurrency is actually safe.

What we listen forWhether they understand coroutine scope and cancellation, not just the async keyword equivalent.

The task we set

A coroutine launched from a screen keeps a network call running long after the screen has closed. Diagnose why and fix it.

What strong sounds like
Identifies the missing structured scope tied to the screen's lifecycle and proposes a fix that cancels automatically, not manually.
What gives us pause
Adds a manual cancellation call at screen exit instead of fixing the coroutine's scope in the first place.
Core

Kotlin · Coroutines · Kotlin Multiplatform

Frameworks

Ktor · Compose Multiplatform · Spring

Testing

Kotest · JUnit · MockK

Tooling

Gradle · IntelliJ · Detekt

02Who you actually meet

The bench, priced by seniority.

Three seniority tiers, priced honestly, and the engineers who fill each one today. Real names and photos take their place as soon as we can share them, and the standard stays exactly the same.

Engineer

Features scoped tightly enough to ship inside your review bar, every time.

The right first hire when your seniors already set the standard.

$2,500–3,200per month

Senior

The hard module nobody else wants to own, taken end to end.

Ownership of a surface, without adding a manager to your headcount.

$3,500–4,400per month

Lead

The workstream's decisions, made daily, so nothing waits on a meeting.

One accountable voice for a pod or initiative that can't afford to drift.

$4,700–5,900per month

  • Kotlin engineer

    3 yrs · US East overlap

    Fixed a coroutine leak that kept network calls alive long after screens had closed

    • Kotlin
    • Coroutines
    • Kotest
  • Senior Kotlin engineer

    7 yrs · UK + EU hours

    Redesigned a contradictory UI-state model into a sealed class hierarchy that made the bug class disappear

    • Kotlin
    • Ktor
    • MockK
    • Multiplatform
  • Lead Kotlin engineer

    10 yrs · EU + US split

    Owns the shared Kotlin Multiplatform module two mobile teams now build on

    • Kotlin Multiplatform
    • Architecture
    • Compose Multiplatform
    • CI/CD

Indicative ranges, representative profiles. Exact figures and named engineers arrive with your shortlist.

Weighing this against a freelancer, a direct hire or a marketplace? See the honest comparison

03From stated problem to first change

Four steps, each closing on evidence.

The hiring sequence favours evidence over a features checklist. Every step produces an artefact you can inspect, and exiting after any of them costs nothing.

  1. Define the safety problem

    We map where your codebase's concurrency or null-safety guarantees are actually under strain. The brief names that problem, not a list of Kotlin keywords.

    A brief your leads sign
  2. Match against your codebase

    Candidates are screened against your actual coroutine patterns, your Java interop surface and your review culture. Three engineers who read your code beat thirty who list Kotlin on a CV.

    Three fits, not thirty CVs
  3. Assess on the real tasks

    Bring your own engineers to the coroutine-leak and sealed-class exercises. Concurrency judgement is visible here, not a rehearsed answer about syntax.

    Evaluation you can watch
  4. Onboard inside your process

    Access, standards and a first bounded fix merged for real. Continuity cover means a departure is handled on our side before your roadmap notices.

    A merged change in week one

04Evidence and proof

Engineers who made concurrency actually safe.

Kotlin proof is a leak or a race condition caught before it reaches users, not a clean build alone. Every record here waits for written client approval before production.

Explore case studies
A Kotlin coroutine leak fixed before reaching production.
Tern · Logistics SaaS, EU

A coroutine leak found before it drained a fleet of devices.

Tern's sync feature quietly kept coroutines alive after screens closed, a slow battery drain nobody had traced. An embedded Kotlin engineer found the leak and fixed the cancellation handling before the next release.

Battery drain reports
Eliminated
Time to root cause
Under one week
Sample · pending client approval
Portrait of an operations director reviewing a Kotlin interop fix.

He found a platform-type crash our static analysis had missed for two release cycles.

Mei TanakaDirector of Operations, Tern
Sample · pending client approval
Portrait of a product VP discussing Kotlin state modeling.

Our sealed-class redesign made a bug class that used to recur every quarter simply stop happening.

Anika RaoVP Product, Koru Health
Sample · pending client approval

05Three shapes, one standard

Add an engineer, a platform pod, or a practice.

Most engagements start small: one engineer working inside your existing coroutine-heavy codebase. Larger needs call for a pod that owns a shared module across your Android and backend targets. A platform genuinely delivered, rather than a seat filled, is a job for the practice instead.

  • One named engineer

    A single Kotlin specialist inside your direction and your reviews. The smallest commitment, and the most common starting point.

    Team extension
  • A platform pod

    A pod with its own lead that owns a Kotlin Multiplatform module shared across your apps. You set priorities while the pod carries delivery.

    Delivery pods
  • The practice, not the person

    When the honest need is a mobile platform built end to end, not a role filled, mobile app development takes on that responsibility instead.

    Mobile app development

06Straight answers

Asked before a Kotlin hire is signed.

What does a Kotlin engineer actually do day to day?

Writes structured, cancellation-safe coroutines, closes the gaps Java interop reopens in null-safety, and models state with sealed classes instead of loose booleans and flags. The unglamorous majority of the work is discipline the compiler cannot enforce alone.

Do you hire for Kotlin on Android specifically, or more broadly?

Matched to where your code actually runs. Concurrency and type-safety judgement transfers across Android, backend and multiplatform work, then the evaluation confirms familiarity with your specific runtime.

Can we run our own interviews as well?

Yes, the published tasks are built to be reused directly. Some clients now run the coroutine-leak exercise themselves in later hiring rounds.

How fast can a Kotlin engineer start?

A shortlist arrives within days from a continuously evaluated bench. From there, start speed mostly tracks how quickly your side can grant repository access.

Who manages the engineer day to day?

Your leads set direction and hold the review bar, same as with any hire. We take on what sits behind that instead: continuity, payroll, replacement exposure and the transitions in between.

What if the engineer is not the right fit?

Tell us as soon as you notice and the swap is funded by us. The next engineer arrives briefed on precisely what missed, so a repeat mismatch is unlikely.

Do your Kotlin developers use AI coding tools?

Yes, openly. AI drafts boilerplate and test fixtures quickly; the engineer stays accountable for every concurrency decision, null-safety boundary and merge that reaches your codebase.

How does pricing work for a hired Kotlin engineer?

The bands above frame the honest range; your shortlist arrives with the exact number attached. Monthly billing, no fee before an interview, and notice-period exit only.