On this page
"It depends" is the honest answer to most engineering questions, but it's only useful when followed by "on what". This article names the forces behind common Android decisions so you can reason about them explicitly.
A decision framework
The forces that usually matter
- User impact: performance, reliability, UX quality.
- Team: size, skills, hiring market.
- Time and cost: to build, to maintain, infrastructure.
- Risk and reversibility: how hard to undo.
- Product horizon: prototype, growth or long-lived product.
Common Android trade-offs
| Decision | Option A favours… | Option B favours… |
|---|---|---|
| Native vs cross-platform (KMP/CMP, Flutter) | Native: platform UX, newest APIs, performance | Shared: one team, faster parity |
| Single module vs modularization | Single: simplicity for small teams | Modules: build speed, ownership at scale |
| Offline-first vs online-only | Offline: resilience, speed | Online: simplicity, no sync conflicts |
| MVVM vs MVI | MVVM: less ceremony | MVI: predictable complex state |
| On-device vs cloud AI | On-device: privacy, offline, no per-call cost | Cloud: capability, device coverage |
| Build vs buy (auth, analytics, chat) | Build: control, no vendor lock-in | Buy: speed, maintained by experts |
| Testing depth | More tests: confidence, refactor safety | Fewer: speed early on (with risk) |
| Domain layer everywhere | Consistency, reuse | Skipping: less indirection for simple screens |
Worked example: should we add a domain layer?
- Context: 6 developers, a growing app, business rules duplicated in 3 ViewModels.
- Options: (1) keep as is; (2) use cases only where logic is shared or complex; (3) mandatory domain layer.
- Forces: duplication causes bugs (user impact), the team knows the pattern, and adding use cases selectively is cheap and reversible.
- Decision: option 2, recorded in an ADR with a rule for when to add a use case.
Record decisions
# 7. Use cases only for shared or complex business logic
Status: Accepted (2026-10)
Context: Pricing rules duplicated across Cart, Checkout and Orders ViewModels; bugs from drift.
Decision: Add use cases when logic is reused by 2+ ViewModels or combines 2+ repositories.
Simple screens call repositories directly.
Consequences: Less duplication; slight indirection; reviewers check the rule in PRs.
Revisit: If team grows past ~15 devs or we adopt KMP shared logic.Reasoning pitfalls
Resume-driven development
Choosing tech because it's exciting rather than because it fits.
Copying big tech
Their scale problems aren't yours. Patterns for 500 engineers can slow a team of 5.
Ignoring reversibility
Agonising over easily changed choices, while rushing hard-to-undo ones.
In interviews
System design and senior interviews reward naming options, forces and a justified choice, plus what you'd monitor and when you'd revisit. See System Design Interview.
Frequently asked questions
How do I get better at trade-offs?
Write down decisions and their expected consequences, then review them months later. Read others' ADRs and post-mortems.
What if the team disagrees?
Agree on the forces and their priority first, run a small spike if facts are missing, then decide and commit, with a revisit date.
Conclusion
Good engineering decisions come from clarifying goals and constraints, comparing realistic options on the forces that matter, weighting reversibility, and recording why, so the team can revisit when context changes.
Next step: apply this thinking to AI features with LLMs vs Traditional Machine Learning.
Official references
📱 Apps built by Yunok Tech
Real Android apps on Google Play, free to download.
Walzi4K wallpapers for lock and home screenGet it ▸
NotiVaultNotification history: recover dismissed notificationsGet it ▸
Ready to build real Android applications?
Architecture makes the most sense when you apply it to a real project and see why each boundary exists. Learn how maintainable Android applications are designed by building one.
Move beyond theory and strengthen your Android development skills with Yunoktech's Android course. Learn core concepts, practical implementation, modern Android development techniques, and the reasoning behind building maintainable applications.
Explore the Android course and take your next step as an Android developer.