Search
Find anything.
Search across posts, apps, projects, case studies, tools, and key site pages.
Showing 24 results
Leveraging MCP Servers to Supercharge My Android Development Routine
I explain how I integrate a local MCP server into my Android workflow for instant code suggestions, automated test generation, and seamless CI/CD triggers, showing concrete Kotlin examples and performance gains.
Building A Local-First AI Memory Agent In Rust
How RustMarrow stores personal work context locally with SQLite, provider pullers, Obsidian mirroring, Claude queries, and JSON backup or restore.
My Android Release Checklist: Zero Bad Releases in 2 Years
A detailed, battle-tested checklist for solo Android developers to ensure stable, secure, and high-performance releases. Covers automated testing, CI/CD, performance monitoring, and final sanity checks.
Mastering Room Database in Production: 7 Battle-Tested Practices for Android Apps
This post shares 7 critical Room Database practices I've refined over 13 years of QA and building 22+ apps at SudarshanTechLabs. Focused on avoiding crashes, data loss, and performance pitfalls in production.
Fire OS Is Not Android: The Behavioral Differences That Break Your App
Amazon's Fire OS shares Android's codebase but diverges in ways that will surprise you. These are the specific behavioral differences — background restrictions, JavaScript timers, WebView versions, permission models — that break apps built for Android and deployed on Fire OS devices.
Android In-App Purchases With Play Billing: A Practical Guide
Monetizing with in-app purchases requires more than integrating the Play Billing Library. Here's how to handle purchase flows, verify purchases securely, restore purchases, and avoid the common mistakes that cause rejected apps and failed payments.
Securely Storing Secrets in Android Keystore
Learn how to use Android Keystore to protect API keys, tokens, and passwords in your Kotlin apps, with step‑by‑step code, best‑practice patterns, and common pitfalls to avoid.
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.