Search
Find anything.
Search across posts, apps, projects, case studies, tools, and key site pages.
Showing 24 results
Paging 3 in Android: Efficient List Loading at Scale
Loading a thousand-item list all at once is how apps run out of memory and feel sluggish. Paging 3 loads data in chunks as the user scrolls. Here's how it fits together with Compose, Room, and a network source.
Android App Theming With Material You and Dynamic Color
Material You lets your app adopt colors from the user's wallpaper while still keeping a brand identity. Here's how dynamic color works in Compose, how to support it without losing your brand, and the dark-theme details that matter.
Building an Android Widget With Jetpack Glance
Jetpack Glance lets you build home-screen widgets with a Compose-like API instead of clunky RemoteViews. Here's how it works, the constraints that make widgets different from app UI, and how to keep them updated efficiently.
Android Accessibility: Making Apps Work for Everyone
Accessibility isn't a feature you bolt on at the end — it's a set of small habits during development. Here's how I make Compose apps work with TalkBack, large fonts, and switch access without much extra effort.
Ktor Client in Android: REST API Calls the Modern Way
Ktor is a clean, coroutine-native HTTP client that shines especially in Kotlin Multiplatform projects. Here's how I set it up for Android — serialization, auth, retries, and error handling — and when I'd still pick Retrofit.
Jetpack Compose Custom Layouts and Modifiers Deep Dive
When Row, Column, and Box can't express your design, Compose's Layout composable and custom modifiers let you measure and place children yourself. Here's how the measure-and-place model works and when to reach for it.
Firebase App Distribution: Beta Testing Without the Play Store
Getting a build into testers' hands shouldn't require the Play Store review queue. Here's how I use Firebase App Distribution for fast beta cycles, how it compares to Play's internal testing, and when to use each.
Kotlin Multiplatform Mobile: Sharing Code Between Android and iOS
KMP lets you share business logic between Android and iOS while keeping native UI on each. Here's what's actually worth sharing, what to leave native, and the realistic trade-offs from shipping it.
Detecting Root and Tamper in Android Apps
Root and tamper detection raises the cost of attacking your app, but it's a deterrent, not a wall. Here's a realistic look at what to check, how to respond proportionally, and why Play Integrity beats DIY checks.
Handling API Keys Safely in Android Apps
Any API key you ship in an APK can be extracted — full stop. Here's how I actually handle keys in Android: which ones can live in the app, which must go behind a backend, and how to keep them out of git either way.
ProGuard and R8 for Security: Obfuscating Sensitive Code
R8's obfuscation won't stop a determined reverse engineer, but it removes the easy wins and raises the cost of attacking your app. Here's what it actually protects, its limits, and how to configure it without breaking your build.
Certificate Pinning in Android: When and How
Certificate pinning hardens your app against man-in-the-middle attacks, but done wrong it can brick your app on a cert rotation. Here's when it's worth it, how to implement it safely, and the backup-pin discipline that prevents outages.
Securing Android SharedPreferences and DataStore
SharedPreferences and DataStore are where small but sensitive values quietly accumulate. Here's how I keep that local storage secure — what to encrypt, what to keep in the Keystore, and what not to store at all.
Android App Security: Preventing Common Vulnerabilities
The Android vulnerabilities I see most often in real apps aren't exotic — they're exported components, insecure storage, and sloppy intents. Here's how to prevent the common ones before they ship.
Google Maps in Jetpack Compose: The Complete Guide
Adding Google Maps to a Compose app is straightforward once you know the Maps Compose library — markers, camera control, custom styling, and the performance and lifecycle gotchas that bite people first.
How I Use Firebase in Production Without the Bloat
Firebase can run your whole backend or quietly balloon your app and your bill. Here's the lean subset I actually use across production Android apps, and the services I deliberately leave out.
Why I Build Focused Apps Instead of Super Apps
The pull toward cramming every feature into one app is strong, especially solo. Here's why I deliberately build small, focused apps instead — what it costs, what it buys, and how it shapes a sustainable portfolio.
Solo Dev Monetization: What Actually Works in 2026
An honest look at how a solo Android developer makes money from small apps in 2026 — the models that work, the ones that quietly don't, and how to pick one without alienating the users you worked to earn.
How to Respond to 1-Star Reviews and Win Users Back
One-star reviews feel personal, but they're the cheapest product feedback and PR you'll ever get. Here's how I respond to turn angry users around, lift my rating, and reassure everyone reading the reviews later.
Writing Tests for Jetpack Compose: A Practical Guide
How I test Compose UIs without the suite turning brittle — what to assert, how the testing APIs work, the synchronization model that makes flakiness rare, and where UI tests stop earning their keep.
Hilt Dependency Injection: Everything You Need to Know
A from-the-ground-up guide to Hilt on Android — what dependency injection actually buys you, the core annotations, how to provide and scope dependencies, and the small set of rules that keep DI from turning into a maze.
From Idea to Play Store in Two Weeks: My Process
The repeatable process I use to take a small Android app from idea to a live Play Store listing in about two weeks, solo — what I build, what I deliberately skip, and where the time actually goes.
Play Store ASO: What Actually Moves the Needle
After publishing 20+ Android apps, most ASO advice is noise. These are the few levers that genuinely changed installs for me — title and first screenshots — and the ones that didn't.
Debugging Memory Leaks in Android With LeakCanary
Memory leaks rarely crash on the first screen — they crash users three navigations deep. Here's the LeakCanary workflow I use to catch the common Android leak sources before they hit production.