From Android to AI Engineering

I released a new course “AI Engineering Fundamentals”.

👉 https://www.udemy.com/course/ai-engineering-fundamentals-build-real-llm-apps-in-python/?referralCode=D1BA2721D48381A98F83

Below you can find the story about my transition 👇

Many Android Developers know me as the “Coroutines & Flow Guy”, since I have the most popular udemy course on that topic.

What few people know is that I haven’t worked as an Android Developer for more than 3 years now.

Why? Because in early 2023, I decided to transition to Backend Development simply because there is much greater demand and higher earning potential for Spring Boot Developers than for native Android Developers.

With quite a bit of luck, I quickly secured a long-running freelance contract as a Backend Developer for a big e-commerce business here in Austria. I was really happy in that project, and in my third year, I envisioned working there for many more years.

However, things can change quickly, and within a day, the company announced that it would completely shut down the service my team was working on by the end of 2025.

One part of me was really sad because I really liked the team and the product we worked on. But another part of me was excited because I had always wanted to find out if I could live off online courses, and now I “got” my chance.

Initially, my plan was this: To create courses around how to become a Backend Developer. However, after starting with the first course about Spring Boot, something didn’t feel right.

I didn’t feel I could sell enough courses on that topic, since there are already so many courses out there and many developers already have the knowledge my courses would teach.

I needed a new field, which is rather new, highly in demand, and for which not many people yet have the skills.

So I did another round of brainstorming and research, and suddenly “AI Engineering” emerged, which is all about building applications on top of LLMs. Initially, I dismissed it because I thought this was just about how to use the OpenAI API.

But boy was I wrong…

… because while it’s easy to build demos and prototypes that integrate LLMs, bringing them to production is what AI Engineering is all about.

In a demo, you can simply use the most powerful frontier model. In production, this would get very expensive, so you need to answer the question: What is the cheapest model that still gets the job done? Furthermore, in production, you have to optimize the context; otherwise, you will face high costs.

Also, in a demo, it’s okay to have low latency. In production, users expect quick responses. In a demo, you present the happy path. In production, users will use your app in ways you didn’t expect.

Also, you need good monitoring in place, so you always know whether your AI System is behaving correctly.

On top of that, there is a fundamental difference to classical software: LLMs are non-deterministic. The same input can produce different outputs every time. This creates entirely new challenges: how do you even know if your system is still working correctly after you change a prompt or switch to a newer model? The answer is evaluations, or “evals” for short. Evals are the unit tests of AI Engineers, and building good evals is one of the most important skills in this new field.

Furthermore, you need to master completely new concepts such as RAG (Retrieval-Augmented Generation) and new frameworks such as LangChain and LangGraph.

Everybody is talking about how AI will replace lots of white-collar jobs. But who is going to develop all the required automations? Right, the AI Engineer. So AI Engineering is probably one of the most future-proof fields in Software Development.

The LinkedIn Jobs on the Rise Report from 2026 states that the AI Engineer is the #1 fastest-growing job role right now.

So in February, I decided to go all in on AI Engineering and started working on my first course. Today, after 6 months of hard work, I can proudly announce that the first version of “AI Engineering Fundamentals” is out now on udemy

👉 https://www.udemy.com/course/ai-engineering-fundamentals-build-real-llm-apps-in-python/?referralCode=D1BA2721D48381A98F83

The course is currently in an “MVP” state, but it already contains about 7 hours of content and more than 50 videos. However, I will spend the rest of the year adding new modules to it, which you will receive automatically for free once you enroll.

Thanks for reading, and if you want to dive deeper into AI Engineering, then check out my course :).

 

My Coroutines Course just got a BIG update: Kotlin Flow for Android Development

Hi Readers 👋

There hasn’t been a lot of news from my side lately, but today I can announce something big!

I spent the last months extending my already existing Course about Kotlin Coroutines for Android with modules about Kotlin Flow!

The result is an additional 6 hours of video content about Kotlin Flow, making the course 15 hours long in total. I am pretty sure that this is now the most comprehensive video course about Coroutines and Flow on Android on the Internet.

The new modules cover:

  • Flow Basics
  • Reactive Programming
  • Flow Builders
  • Flow Operators (lifecycle operators, intermediate operators, terminal operators)
  • Flow Exception Handling
  • Flow Cancellation
  • Hot & Cold Flows
  • SharedFlow and StateFlow
  • Channels

Get the Course with a nice discount!

I hope this course is helpful for a lot of developers!

 

7 common mistakes you might be making when using Kotlin Coroutines

In my opinion, Kotlin Coroutines really simplify the way we write asynchronous and concurrent code. However, I identified some common mistakes that many developers make when using Coroutines.

Read More
 

Kotlin Coroutines Exception Handling Cheat Sheet

Exception Handling with Kotlin Coroutines is hard. I wrote an extensive article about it and gave talks about it at several conferences. Some developers suggested creating some kind of cheat sheet that could be helpful for implementing appropriate exception handling in coroutine-based code. Here it is 😉. It contains the six most important points. You can either download the PDF or read this article.

Read More
 

My first online course “Mastering Kotlin Coroutines for Android Development” is now available!

Today it’s time to celebrate! 🥳

After more than 6 months of really hard work, I finally released my very first online course: Mastering Kotlin Coroutines for Android Development.

Read More
 

Why exception handling with Kotlin Coroutines is so hard and how to successfully master it!

Exception handling is probably one of the hardest parts when learning Coroutines. In this blog post, I am going to describe the reasons for its complexity and give you some key points that will help you to build a good understanding of the subject. You will then be able to implement a successful exception handling infrastructure in your own applications.

Read More
 

How to run an expensive calculation with Kotlin Coroutines on the Android Main Thread without freezing the UI

On Android, you should usually perform CPU-intensive tasks on a background thread. Otherwise, if we perform them on the main thread, the UI freezes and gets unresponsive. With Coroutines, however, it is possible to perform expensive computations without ever leaving the main thread and without impacting the functionality of the UI. In this blog post, I show you how this is possible. However, I will also tell you why you should never follow this approach in a real production app.

Read More
 

Do I need to call suspend functions of Retrofit and Room on a background thread?

After publishing my open source project about Coroutines on Android, which currently includes 16 of the most common, real-world use cases of using Coroutines in an Android application, one of the most common questions I get from developers was whether or not we have to switch to a background thread whenever we call a suspend function to make a network request with Retrofit or a database call with Room in order to not block the main thread which would make the UI freeze and get unresponsive.

Read More
 

Understanding Kotlin Coroutines with this mental model

For the majority of developers, the concept of a coroutine is pretty unfamiliar, although the first ideas date back to the early sixties. This is because we started to learn Software Development with programming languages like Java, in which the concept of a coroutine simply does not exist. What we did learn, however, are how basic concepts like classes, functions, and interfaces work. Over time, we developed a fundamental understanding of these essential, yet abstract concepts.

Read More
 

Comparing Kotlin Coroutines with Callbacks and RxJava

I am currently investing a lot of time in learning about Kotlin Coroutines 🎓. Therefore, I did some research about the most common use cases for using Coroutines on Android and implemented them in an [open-source example project]. It currently contains 16 common use cases implemented with Coroutines. I think the samples in this project can be helpful for lots of developers 👨‍💻.

Read More