We’ve all been there — learning things the hard way.

I Interviewed 10 Android Developers — Here’s What They Wish They Knew Earlier

Avoid years of trial-and-error. These real-world lessons from Android developers can save you time, bugs, and burnout.

Photo by NEOM on Unsplash

Not a Medium Member? “Read for Free”

As Android developers, we often look back and think, “I wish I knew that earlier.” So I decided to ask 10 experienced Android developers a simple question:

“What’s something you wish you knew earlier in your career?”

The answers were honest, practical, and incredibly insightful — touching everything from architecture mistakes to misunderstood tools and overlooked best practices. Whether you’re a beginner or mid-level developer, this post will give you a peek into the collective wisdom of real people who’ve shipped real apps (and made real mistakes).

layout Modifier in Jetpack Compose: Custom Layouts Made Simple

Let’s jump in.

1. “ViewModels Aren’t God Objects”

Several developers admitted they used ViewModels as catch-all classes — doing everything from API calls to complex business logic to UI formatting.

What they wish they knew:

• Keep your ViewModel lean.
• Offload responsibilities to use cases or repositories.
• ViewModel = UI state + events only.

Tip: Using Hilt’s ViewModel injection makes this separation cleaner.

2. “Don’t Underestimate ProGuard”

Many devs said they ignored ProGuard rules — until a release crash taught them a painful lesson.

What they wish they knew:

• ProGuard isn’t just about shrinking — it obfuscates and optimizes too.
• You must write rules for libraries like Gson, Retrofit, and Dagger/Hilt to prevent runtime issues.
• Always test release builds with minifyEnabled = true.

Tip: Learn how to write ProGuard rules early and save yourself from mysterious release-time bugs.

Write Proguard Rules For Your Android App

3. “Jetpack Compose Isn’t Magic — Learn the Fundamentals”

With Compose now mainstream, developers jumped in but didn’t always understand how it works under the hood.

What they wish they knew:

• Recomposition rules, remember, derivedStateOf, and side-effect APIs (LaunchedEffect, rememberUpdatedState) are crucial.
• State hoisting is not just a pattern — it’s a necessity for clean Compose architecture.
• Compose previews are great, but not a substitute for real device testing.

Recommended: Read through the official Compose thinking docs and follow real-world GitHub projects.

GitHub - nameisjayant/composeOneScreens: Aim of this repository is to design single screen page UIS…

4. “Testing Is a Superpower, Not a Burden”

Many admitted skipping tests until their app broke… badly.

What they wish they knew:

• Start small with unit tests — especially for ViewModels and use cases.
• Use libraries like Turbine to test Kotlin Flows.
• Jetpack Compose has excellent testing support using composeTestRule and semantics.

Advice: Set up a small CI pipeline with GitHub Actions early in your project. It pays off quickly.

UI Testing In Jetpack Compose Using Semantics

5. “Build Gradle Is More Than a File — It’s a Tool”

Almost all devs admitted to just copying build.gradle blocks without understanding them.

What they wish they knew:

• Understanding Gradle’s plugin lifecycle helps when debugging builds.
• Features like buildSrc, custom tasks, and version catalogs make your build maintainable at scale.
• Learn the difference between implementation and api.

6. “Overengineering Is Real ”

Too many layers. Abstract factories. MVI for a simple counter app.

What they wish they knew:

• Use clean architecture only when it fits your problem.
• Avoid premature abstraction. Code should evolve — not start fully “enterprisey.”
• Write the dumb version first — refactor later.

Just because you can doesn’t mean you should.

7. “Learn Kotlin Deeply”

Kotlin is powerful. But many devs used it like Java.

What they wish they knew:

• sealed classes + when = awesome for UI state.
• Use Flow and StateFlow for reactive streams.
• Learn extension functions, apply, let, run, and with properly.

Tip: Follow Kotlin’s style guide.

Conclusion

The beauty of our developer community is this: we don’t have to make all the mistakes ourselves.

These 10 developers generously shared their “I wish I knew” moments to save you time and frustration. Whether it’s improving architecture, mastering Compose, or avoiding release nightmares — you now have a head start.

What’s something you wish you knew earlier in your Android journey?
Drop it in the comments — let’s learn from each other.

Don’t Make Your ViewModels Do Everything — There’s a Better Way