Monitor Jetpack Compose & Koin Events in Real Time with the Kotzilla Platform

Many Android apps today use Koin for dependency injection and Jetpack Compose for UI.

Both make development faster and cleaner but as your app grows, it’s not always easy to see what’s happening under the hood while everything’s running.

When you’re analyzing performance, you might want to know:

• When does a screen start rendering?

• How long does navigation take?

• Were dependencies already resolved when the composable appeared?

That visibility is exactly what kotzilla-sdk-compose brings.

It adds end-to-end observability to your Compose apps by automatically tracking UI, navigation, Android lifecycle, and dependency injection events in a single, unified timeline.

In this article, we’ll talk about how it works, what’s new, and why it helps Kotlin developers understand your app behavior more deeply.

The Challenge: Seeing What Happens Across Layers

Compose makes UI code simpler, and Koin keeps dependency management clean.
But once your app scales, understanding what happens across layers (DI, navigation, recomposition, and threading) can get complex.

Traditional logging and profilers show parts of the story.
The Kotzilla Platform shows the whole flow so you can correlate what happens as your app initializes, navigates, and renders.

Introducing kotzilla-sdk-compose: Full Runtime Observability for Compose

The new Kotzilla SDK for Compose gives you a complete, real-time view of your app’s runtime behavior by combining Compose navigation, Android lifecycle, and Koin dependency events in one unified timeline.

Here’s what it adds out of the box:

🟣 Compose event tracking
Captures when composable screens start rendering, when navigation occurs, and when recompositions happen including any route arguments.
In the example above, you can see events like ForYouRoute starting and stopping as users navigate between screens.

🟢 Lifecycle alignment
Correlates Compose events with Android lifecycle transitions from your host MainActivity.
Even in a pure Compose app, this single activity remains the container for your entire UI so you’ll see events such as created, started, resumed, paused, and stopped aligned alongside Compose rendering activity.

🟡 Koin integration
Tracks dependency lifecycle events  from module load to instance creation and reuse.
You can immediately see when dependencies are resolved relative to UI rendering, helping spot potential startup or recomposition bottlenecks.

⚙️ Performance issues
Highlights issues like “Main thread performance” or “Child dependency performance,” showing exactly where expensive operations occur during initialization or rendering

Now you can inspect what happens in your app as it runs without additional logging or instrumentation in both Android and Compose Multiplatform projets

Why It Matters

• Faster Debugging
  Pinpoint exactly when navigation starts, recompositions occur, or dependencies initialize without guesswork.
•  End-to-End Correlation
  See how and when different layers (DI, navigation, lifecycle, UI) interact in real time.
• Actionable Performance Insights
  Identify navigation delays, expensive resolutions, or rendering slowdowns with precise timestamps.
• Cross-Platform Monitoring
  Observe consistent runtime behavior across Compose Multiplatform targets.
  
• Developer Productivity
  No need for custom logging or tracing. The SDK captures it automatically so you can focus on optimization.

Conclusion

The Kotzilla Platform already helps you identify performance issues and crashes across your app. The new Kotzilla SDK for Compose extends this by adding full visibility into Compose UI events and navigation, complementing the monitoring you already get for Android lifecycle and dependency injection.

With the addition of Compose events, you get extra context to understand exactly how UI, navigation, and dependencies interact, making it easier to pinpoint the root cause of slowdowns or crashes.

This enhanced visibility works across Android and Compose Multiplatform projects, letting you correlate all relevant runtime behavior and optimize your app with confidence.

About the Author: This article was written by Miguel Valdes-Faura from the Kotzilla team. Kotzilla provides AI-powered performance monitoring for Koin-based Android applications, trusted by leading companies like Canal+, TotalEnergies, Worldline, Volkswagen, and Литрес to speed up issue resolution and reduce downtime. Follow us for more insights on Android development best practices and performance optimization strategies.