From First Kotlin Code to Production-Ready Applications
Kotlin has evolved far beyond its origins as a modern programming language for the JVM. Today, it is used to build Android applications, backend services, asynchronous systems, APIs, and real-time applications.
But learning Kotlin is not simply about memorizing syntax.
To become productive, you need to understand how Kotlin works in real applications — how code is structured, how applications manage state, how data moves between systems, how APIs are built, and how asynchronous operations are handled reliably.
The Waskey Press Kotlin Series is a four-book journey designed to take you through that transformation.
Rather than teaching isolated language features or disconnected programming examples, the series follows one evolving application and progressively introduces the tools, architectures, and concepts needed to turn a simple Kotlin program into a complete, production-oriented system.
You don't just learn Kotlin.
You build with it.
THE JOURNEY
📘 BOOK 1 — KOTLIN FOR ABSOLUTE BEGINNERS
Learn Kotlin by building something real.
Start with the fundamentals of Kotlin and learn how the language works through the development of a practical application.
Beginning with variables, types, null safety, control flow, and functions, you progressively move into classes, data classes, collections, interfaces, inheritance, error handling, file I/O, JSON persistence, lambdas, testing, coroutines, and HTTP APIs.
Instead of learning programming concepts in isolation, you apply them as the application grows.
This is where the journey begins:
Write your first Kotlin code. Build your first application. Understand why the language works the way it does.
📗 BOOK 2 — KOTLIN FOR ANDROID DEVELOPMENT
Turn Kotlin knowledge into modern Android applications.
Once you understand the Kotlin language, the next step is to use it to build a real Android application.
In this book, the KontactBook project is rebuilt as a native Android application using Jetpack Compose.
You will work with Android application architecture, the lifecycle, Compose UI, state and recomposition, navigation, ViewModel, StateFlow, Material 3, Room, coroutines, Retrofit, Coil, permissions, camera integration, device contacts, testing, and Google Play submission.
The goal is not simply to create an Android interface.
It is to understand how Kotlin concepts translate into a complete modern Android application.
From Kotlin fundamentals to a functioning mobile application.
📙 BOOK 3 — KOTLIN FOR BACKEND APIS
Take Kotlin beyond the Android application.
Modern applications rarely exist alone.
They communicate with backend services, databases, APIs, authentication systems, and other applications.
In Book 3, the KontactBook project expands into a Kotlin backend built with Ktor.
You will build REST APIs, work with JSON serialization, connect PostgreSQL using Exposed and HikariCP, manage database migrations with Flyway, and structure the application using repositories and service layers.
The journey continues into authentication with JWT and bcrypt, validation, security, error handling, testing, logging, monitoring with Prometheus, rate limiting, Docker, deployment, and CI/CD.
The result is a backend designed not merely to demonstrate Kotlin, but to show how Kotlin can be used to build a complete, production-oriented API.
Go from Kotlin on the JVM to a live backend system.
📕 BOOK 4 — KOTLIN FOR COROUTINES IN PRACTICE
Master concurrency, Flow, and real-time Kotlin systems.
As applications become more sophisticated, asynchronous programming becomes essential.
Book 4 takes you deep into Kotlin Coroutines and the concepts that make modern concurrent applications possible.
You will explore coroutine internals, structured concurrency, dispatchers, channels, Flow, StateFlow, SharedFlow, error handling, testing, concurrent processing, rate limiting, WebSockets, WorkManager, performance, and production API patterns.
The series culminates with KontactBook Live — a real-time system connecting Android, Ktor, and PostgreSQL.
Here, Kotlin is no longer just a language you use to write individual features.
It becomes the foundation for building systems that communicate, process work concurrently, respond to events, and synchronize information in real time.
Stop treating coroutines as magic. Start understanding how concurrent Kotlin systems actually work.
THE KONTACTBOOK PROJECT
Across all four books, one evolving application connects the entire journey:
KontactBook.
The project begins as a simple command-line contact manager.
Instead of abandoning it when a new technology is introduced, each book takes the same project one step further.
In Book 1, you build the foundation with Kotlin.
In Book 2, you transform it into a modern Android application.
In Book 3, you build the backend API and connect it to PostgreSQL.
In Book 4, you bring the entire system together with coroutines and real-time communication.
The final result is more than four separate programming books.
It is one continuous software development journey showing how a Kotlin application can evolve from a beginner project into a connected, production-oriented system.
BUILT FOR PEOPLE WHO WANT TO BUILD WITH KOTLIN
You do not need to be an experienced software engineer to begin.
The series is designed for Kotlin beginners, developers coming from other programming languages, Android developers, JVM developers, backend developers, and programmers who want to understand modern Kotlin development.
Book 1 provides the foundation.
Book 2 applies Kotlin to Android development.
Book 3 introduces backend engineering and APIs.
Book 4 explores advanced concurrency and real-time systems.
Each book can stand on its own for readers who already have the required background. Together, however, the four books provide a structured path through modern Kotlin development.
THE PHILOSOPHY
The goal is not to learn Kotlin by memorizing hundreds of language features.
The goal is to understand how those features work together when building real software.
Throughout the series, concepts are introduced in context and applied to a continuously evolving project.
You learn the language.
Then you build an application.
Then you connect it to a backend.
Then you make the system communicate and operate in real time.
The philosophy is simple:
Learn the concept. Build with it. Test it. Understand what happens behind the code. Then move to the next level.
THE COMPLETE KOTLIN LEARNING PATH
BOOK 1 — Learn the Kotlin language.
BOOK 2 — Build the Android application.
BOOK 3 — Build the backend API.
BOOK 4 — Connect everything with concurrency and real-time communication.
From Kotlin programming and Kotlin for beginners to Android development, Jetpack Compose, Ktor, PostgreSQL, Kotlin Coroutines, Flow, StateFlow, WebSockets, and real-time applications, the series provides a progressive path through modern Kotlin development.
YOUR NEXT STEP
If you are learning Kotlin, the most important question is not how many language features you can memorize.
It is what you can build with them.
The Waskey Press Kotlin Series gives you a project to follow, a progression to understand, and increasingly sophisticated challenges to solve.
Start with your first Kotlin program.
Build the Android application.
Create the backend.
Connect everything.
And discover how far Kotlin can take you.
Explore the four books of The Waskey Press Kotlin Series and start building real software with Kotlin.
AVAILABLE NOW ON AMAZON
