CAP theorem
~11 minTwo data centres hold the same data. The link between them breaks. Each must now answer from its own copy, or refuse. CAP is the proof that there is no third way.
Gets you ready for Kotlin backend interviews end to end, from the language and coroutines to Spring and Ktor services in production. Covers persistence, APIs, testing, security, and system design.
16551 of 16551 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 16551 new. 0 cut, outside your plan.
Kotlin backend interviews turn on the seam between the language and the Java libraries beneath it, and interviewers go looking for that seam on purpose. The rounds around it keep their JVM order: a screen first, then a coding round that normally accepts Kotlin and rewards an idiomatic solution over a ported Java one, then one conversation on the language and another on Spring or Ktor. Postings at middle level and above add system design, and the behavioral interview, on past projects and how you work with a team, usually comes last. Usually that seam is brought to the table as a few lines of code. A `data class` mapped as a JPA entity: why Hibernate wants a no-argument constructor the class does not have, and why an `equals` built from every constructor property misbehaves once an id is generated. A `catch (e: Exception)` around a suspending call, and the cancellation it swallows. A `@Transactional` function made `suspend` over a JDBC driver, and where a transaction held by one thread goes when the coroutine resumes on another. A Java method that returns null into Kotlin code that never declared a nullable type, and the line, far from the call, where it finally throws. Earlier levels are graded on reading such code correctly; higher levels on the running service. Latency that climbs while the CPU sits idle, traced to blocking driver calls on `Dispatchers.Default`. A `GlobalScope.launch` in a controller that outlives the request and loses its errors. Spring MVC with coroutines, WebFlux or Ktor for a team that must maintain the result. At that level an answer earns credit by saying how the cause would be confirmed, a thread dump or a dispatcher that never frees up, before it proposes a fix.
Kotlin opens the plan with [the JVM](/topics/lang-jvm) directly beneath it, because later questions are asked in Kotlin terms and answered in JVM terms: a coroutine still runs on JVM threads, and a data class still compiles to an ordinary class with a generated `equals`. [The language module](/topics/lang-kotlin), from null safety to coroutines and Flow, is where a Kotlin loop spends its longest stretch. Theory comes before any framework; [programming paradigms](/topics/found-paradigms) count for more here than on a Java plan, since one Kotlin file can mix object, functional and reactive styles, and [algorithms](/topics/found-dsa) carry the coding round. The framework module forks into two ways of writing a service. Spring is built up from its [container](/topics/be-spring-core) through Boot to servlet MVC and reactive [WebFlux](/topics/be-spring-webflux), where coroutines and Flow can stand in for Reactor's `Mono` and `Flux`. [Ktor](/topics/be-ktor) follows as the framework written in Kotlin, built on coroutines from the start. What crosses the network comes next: HTTP and TLS, the API contracts, and the push channels a live feature needs. Persistence passes from [ORM concepts](/topics/be-orm-concepts) through [JDBC](/topics/be-jdbc) to Hibernate and Spring Data. That middle stop matters on a Kotlin plan: JDBC is a blocking API, and most questions about coroutines meeting a database start there. The stores below the mapping layer follow, relational first. Architecture and distributed systems then change the unit from one service to a system, with [system design](/topics/found-system-design) as the applied end of it. From Testing to Coding with AI the plan sets Kotlin aside: these modules would read the same for a service in any language, and they cover what an interviewer asks once the code exists, how it is checked, who may call it, and how it reaches a container taking traffic and stays healthy there. The return to the JVM opens with [transactions](/topics/be-spring-tx) and then [AOP](/topics/be-spring-aop), the problem before the machinery, so the module can dwell on where the proxy falls short: a self-call, a propagation setting, a class the Kotlin compiler left final. Gradle follows, then the test tools in a telling sequence, JUnit and Mockito before Kotest and [MockK](/topics/dev-mockk), which stubs final classes, `object` declarations and suspending calls. The logging module ends at [OpenTelemetry](/topics/cloud-opentelemetry), where the thread question returns: MDC values and trace context stay on the thread that set them unless something carries them across a coroutine's hops. Spring Cloud is the last technical module. What follows is about the candidate, not the code: answering [behavioral questions](/topics/found-behavioral) from your own projects, and the stages a hiring process moves through.
For an engineer arriving from Java, the plan is shorter than it looks: the Spring, persistence and architecture stretches carry over almost unchanged. The hours belong to the first module, coroutines and Java interop above all, and to the places where Kotlin changes a familiar tool, such as the compiler plugins that open classes for Spring and add constructors for JPA. Set study order to by topics for that pass and skip the language-neutral stretch you already know. Android developers arrive with the opposite gap: the language is home ground, and the work starts at the framework module and runs down through persistence and the data stores. If the interview is days away, leave by frequency where it is and trim from both ends instead: take should know and nice to know off importance, and the bands of level above and below the posting. A junior should first make null safety, classes and Spring's container hold up under follow-up questions; WebFlux and Ktor can wait. Brokers appear here as concepts and operations, never as one product. A team that runs Kafka will ask about partitions, consumer groups and offset commits by name, and the [Apache Kafka roadmap](/roadmaps/kafka) takes that product in depth.
Two data centres hold the same data. The link between them breaks. Each must now answer from its own copy, or refuse. CAP is the proof that there is no third way.
Kotlin backend interviews turn on the seam between the language and the Java libraries beneath it, and interviewers go looking for that seam on purpose. The rounds around it keep their JVM order: a screen first, then a coding round that normally accepts Kotlin and rewards an idiomatic solution over a ported Java one, then one conversation on the language and another on Spring or Ktor. Postings at middle level and above add system design, and the behavioral interview, on past projects and how you work with a team, usually comes last.
Usually that seam is brought to the table as a few lines of code. A data class mapped as a JPA entity: why Hibernate wants a no-argument constructor the class does not have, and why an equals built from every constructor property misbehaves once an id is generated. A catch (e: Exception) around a suspending call, and the cancellation it swallows. A @Transactional function made suspend over a JDBC driver, and where a transaction held by one thread goes when the coroutine resumes on another. A Java method that returns null into Kotlin code that never declared a nullable type, and the line, far from the call, where it finally throws.
Earlier levels are graded on reading such code correctly; higher levels on the running service. Latency that climbs while the CPU sits idle, traced to blocking driver calls on Dispatchers.Default. A GlobalScope.launch in a controller that outlives the request and loses its errors. Spring MVC with coroutines, WebFlux or Ktor for a team that must maintain the result. At that level an answer earns credit by saying how the cause would be confirmed, a thread dump or a dispatcher that never frees up, before it proposes a fix.
Kotlin opens the plan with the JVM directly beneath it, because later questions are asked in Kotlin terms and answered in JVM terms: a coroutine still runs on JVM threads, and a data class still compiles to an ordinary class with a generated equals. The language module, from null safety to coroutines and Flow, is where a Kotlin loop spends its longest stretch. Theory comes before any framework; programming paradigms count for more here than on a Java plan, since one Kotlin file can mix object, functional and reactive styles, and algorithms carry the coding round.
The framework module forks into two ways of writing a service. Spring is built up from its container through Boot to servlet MVC and reactive WebFlux, where coroutines and Flow can stand in for Reactor's Mono and Flux. Ktor follows as the framework written in Kotlin, built on coroutines from the start. What crosses the network comes next: HTTP and TLS, the API contracts, and the push channels a live feature needs.
Persistence passes from ORM concepts through JDBC to Hibernate and Spring Data. That middle stop matters on a Kotlin plan: JDBC is a blocking API, and most questions about coroutines meeting a database start there. The stores below the mapping layer follow, relational first. Architecture and distributed systems then change the unit from one service to a system, with system design as the applied end of it.
From Testing to Coding with AI the plan sets Kotlin aside: these modules would read the same for a service in any language, and they cover what an interviewer asks once the code exists, how it is checked, who may call it, and how it reaches a container taking traffic and stays healthy there.
The return to the JVM opens with transactions and then AOP, the problem before the machinery, so the module can dwell on where the proxy falls short: a self-call, a propagation setting, a class the Kotlin compiler left final. Gradle follows, then the test tools in a telling sequence, JUnit and Mockito before Kotest and MockK, which stubs final classes, object declarations and suspending calls. The logging module ends at OpenTelemetry, where the thread question returns: MDC values and trace context stay on the thread that set them unless something carries them across a coroutine's hops. Spring Cloud is the last technical module. What follows is about the candidate, not the code: answering behavioral questions from your own projects, and the stages a hiring process moves through.
For an engineer arriving from Java, the plan is shorter than it looks: the Spring, persistence and architecture stretches carry over almost unchanged. The hours belong to the first module, coroutines and Java interop above all, and to the places where Kotlin changes a familiar tool, such as the compiler plugins that open classes for Spring and add constructors for JPA. Set study order to by topics for that pass and skip the language-neutral stretch you already know. Android developers arrive with the opposite gap: the language is home ground, and the work starts at the framework module and runs down through persistence and the data stores.
If the interview is days away, leave by frequency where it is and trim from both ends instead: take should know and nice to know off importance, and the bands of level above and below the posting. A junior should first make null safety, classes and Spring's container hold up under follow-up questions; WebFlux and Ktor can wait.
Brokers appear here as concepts and operations, never as one product. A team that runs Kafka will ask about partitions, consumer groups and offset commits by name, and the Apache Kafka roadmap takes that product in depth.