Interview questions by language
Null safety, coroutines, data classes, and interop with Java.
What it really tests
A Kotlin interview tests whether you use the language's safety and conciseness features idiomatically, and whether you understand the JVM it compiles to. The flagship topic is null safety. Kotlin bakes nullability into the type system: String and String? are different types, the compiler forces you to handle the nullable case, and the safe-call (?.), Elvis (?:), and not-null (!!) operators are the daily tools. An interviewer's first real question is usually some variation on 'how does Kotlin prevent NullPointerExceptions, and where can they still happen?'
The second pillar is coroutines, Kotlin's structured-concurrency model for asynchronous code. Coroutines let you write sequential-looking suspending functions that do not block threads, which is transformative on Android (keeping the UI thread responsive) and useful on the backend. Interviewers probe suspend functions, the difference between launch and async, coroutine scopes and structured concurrency, and dispatchers (Main, IO, Default). A candidate who can contrast coroutines with Java threads or callbacks is showing modern fluency.
The third pillar is the everyday conveniences that make Kotlin pleasant and the Java interop that makes it practical: data classes (which auto-generate equals, hashCode, toString, and copy), sealed classes for exhaustive when expressions, extension functions, and the difference between val and var. Because most Kotlin runs alongside Java, expect questions on calling Java from Kotlin (and the platform-type nullability hole that creates) and why Kotlin chose certain different defaults.
Kotlin is the default for Android and a growing choice for JVM backend across the US and EU; interviews lean on null safety, coroutines, and how Kotlin improves on Java while interoperating with it.
The map
Nullable vs non-null types, the ?. ?: and !! operators, and platform types from Java interop where nulls can still sneak in.
suspend functions, launch vs async, structured concurrency and scopes, and dispatchers. The modern async model and a top Android question.
data class auto-generation, copy(), and sealed classes powering exhaustive when. The conciseness features over Java.
Calling Java from Kotlin and vice versa, platform types, and why Kotlin's defaults (immutability, non-null) differ from Java's.
Question bank
The questions that come up most often, each with a sample answer you can adapt into your own words. Read them out loud until the explanation feels natural.
Nullability is part of the type system: a non-null type like String cannot hold null, and you must use the nullable type String? to allow it, which the compiler then forces you to handle. The safe-call operator ?. returns null instead of throwing if the receiver is null, the Elvis operator ?: supplies a default, and !! asserts non-null and throws if wrong. This eliminates most NullPointerExceptions at compile time.
val declares a read-only (immutable) reference that cannot be reassigned after initialisation, while var declares a mutable one. val is preferred by default for safety and clarity. Note that val makes the reference immutable, not the object it points to; a val list reference can still have its contents mutated unless the collection itself is immutable.
A coroutine is a lightweight unit of asynchronous work that can suspend and resume without blocking the underlying thread, so thousands can run on a small thread pool. A thread is a heavier OS-level resource. A suspending function pauses at suspension points and frees its thread for other work, which is why coroutines keep the Android main thread responsive and scale better than thread-per-task on the backend.
launch starts a coroutine that does not return a result (fire-and-forget), returning a Job you can cancel or join. async starts a coroutine that computes a value and returns a Deferred, whose result you obtain with await. Use launch for side-effecting work and async when you need a result, especially to run several computations concurrently and await them together.
A data class is a class declared with the data keyword for which the compiler auto-generates equals(), hashCode(), toString(), and copy() based on the properties in the primary constructor, plus componentN() functions for destructuring. It is ideal for value/DTO types and removes the boilerplate Java requires. copy() makes it easy to produce a modified duplicate while keeping immutability.
A sealed class restricts its subclasses to a known set declared in the same module, so the compiler knows every possible subtype. This makes a when expression over it exhaustive without an else branch, and the compiler flags you if you add a subtype and forget to handle it. It is the idiomatic way to model a closed set of states, like a UI state of Loading, Success, or Error.
An extension function lets you add a method to an existing type without modifying or inheriting from it, by declaring fun Type.newMethod(). It is resolved statically (it does not actually modify the class) and is widely used to add readable helpers to standard or third-party types. The Kotlin standard library is built largely from extension functions on collections and strings.
When Kotlin calls Java code, the Java type's nullability is usually unknown, so Kotlin treats it as a platform type (written String!), trusting you to know whether it can be null. The risk is that you can use it as non-null without a compiler check, so a Java method returning null can still cause an NPE at runtime. The mitigation is to annotate Java with @Nullable/@NonNull or defensively treat interop values as nullable.
Avoid these
The plan
An external resource we recommend. Educative is not affiliated with us and we earn nothing from this link.
Apply it to a role
Keep exploring
Language fluency gets you through the screen. Pair it with the coding interview patterns, rehearse the behavioral round with worked STAR answers, and when the offer comes, check it is competitive with the salary comparison tool.