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 course 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

• 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

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):

   cd shared-infra && docker compose up -d

2. Verify the services are running:

   docker compose ps

3. Tear everything down when you’re done:

   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

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

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

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

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

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

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

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

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

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:

./gradlew build
./gradlew run

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

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

# 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.