Skip to content
  • kotlin backend
  • overview

Overview

You write TypeScript or Go backends. You know git, Docker, and cloud services cold. You have zero Kotlin or Java experience — and you want to get productive on JVM backends fast. This guide is built for exactly that.

It is example-driven: every concept has runnable code, and almost everything is shown three ways — the TypeScript way, the Go way, and the Kotlin way — so you map what you already know onto new syntax instead of starting from scratch.

Who this is for

Section titled “Who this is for”
  • You write TypeScript or Go backends professionally.
  • You know git, Docker, and cloud services well.
  • You have little or no Kotlin or Java experience.
  • You want to be productive on JVM backends quickly.

Setup

Section titled “Setup”

You need JDK 21, Docker, and an IDE (IntelliJ IDEA or VS Code with the Kotlin plugin). Module 01 walks through installing the toolchain in detail; the short version for the shared infrastructure is:

  1. Start all infrastructure (PostgreSQL, Redis, Kafka):

    Terminal window
    cd shared-infra && docker compose up -d

  2. Verify the services are running:

    Terminal window
    docker compose ps

  3. Tear everything down when you’re done:

    Terminal window
    docker compose down -v
Tool Version
JDK 21 (LTS)
Kotlin 2.x
Gradle 8.x (Kotlin DSL)
Spring Boot 3.x
Ktor 3.x
PostgreSQL 16
Redis 7
Kafka 3.7 (KRaft)

Modules

Section titled “Modules”

Kotlin Language

Section titled “Kotlin Language”
Module You build
Dev Environment & First Project A Gradle project from scratch, Docker toolchain
Kotlin Language Essentials Types, null safety, sealed classes — all with TS/Go comparisons
Collections, Sequences & FP Data pipelines, lazy evaluation, scope functions
OOP, Generics & Java Interop A generic repository, Java library integration, design patterns

Async

Section titled “Async”
Module You build
Coroutines & Structured Concurrency A concurrent HTTP fetcher, fan-out/fan-in pipelines
Flow & Reactive Streams A real-time data pipeline, event processing system

Frameworks

Section titled “Frameworks”
Module You build
Gradle Deep Dive A multi-module project, version catalogs, custom tasks
Spring Boot REST APIs A full CRUD API with DI, config profiles, actuator
Ktor Lightweight APIs The same CRUD API in Ktor — compare both, pick your style

Data

Section titled “Data”
Module You build
PostgreSQL Access The same queries in JDBC, JPA, Exposed, and jOOQ — compare all four
Redis & Caching Cache-aside, write-through, pub/sub, rate limiting
Event-Driven with Kafka A producer/consumer pipeline, dead letter queue, event sourcing

Production

Section titled “Production”
Module You build
Testing JUnit 5, MockK, Kotest, Testcontainers — unit through integration
Security & Auth JWT auth, OAuth2 with Keycloak, RBAC
API Design & Serialization REST + GraphQL + gRPC, OpenAPI docs, serialization
Observability Structured logging, Prometheus metrics, distributed tracing

Advanced

Section titled “Advanced”
Module You build
Advanced Kotlin A custom DSL, delegation, inline/reified functions, KSP
Deployment & Production Docker multi-stage, GraalVM native image, K8s manifests, CI/CD

Fullstack

Section titled “Fullstack”
Module You build
Compose Multiplatform A desktop/web UI — React concepts mapped to Compose
Capstone: Notification Service A full microservice: API + DB + Cache + Kafka + Auth + Tests + Deploy

Learning paths

Section titled “Learning paths”

Pick a path based on your goal — modules are referenced by number.

Get productive fast (7 modules)

01 → 02 → 05 → 08 → 10 → 13 → 18

Complete backend (19 modules)

01 → 02 → 03 → 04 → 05 → 06 → 07 → 08 → 09 → 10 → 11 → 12 → 13 → 14 → 15 → 16 → 17 → 18 → 20

Fullstack — the complete backend path, plus module 19.

Spring Boot focus

01 → 02 → 05 → 07 → 08 → 10 → 13 → 14 → 18

Ktor focus

01 → 02 → 05 → 07 → 09 → 10 → 13 → 18

How each module works

Section titled “How each module works”

Each module is a lesson plus one or more hands-on exercises. Every exercise is a self-contained Gradle project with a worked solution:

  • Directorymodule-name/
    • the lesson content + side-by-side code examples
    • Directoryexercises/
      • Directoryproject-name/
        • build.gradle.kts
        • settings.gradle.kts
        • docker-compose.yml if the exercise needs infrastructure
        • Directorysrc/
          • …

Building and running any exercise is the same Gradle dance:

Terminal window
./gradlew build
./gradlew run

Tear down any module-specific Docker services with docker compose down -v.

Shared infrastructure

Section titled “Shared infrastructure”

All modules share one Docker Compose stack under shared-infra/:

Service Port Credentials
PostgreSQL 5432 dev / dev / kotlin_course
Redis 6379 no auth
Kafka 29092 no auth
Kafka UI 8090 browser
Terminal window
# Start everything
cd shared-infra && docker compose up -d


# Stop and wipe all data
docker compose down -v

Ready? Start with Dev Environment & First Project.