⚙️ Advanced Android Engineering and Emerging Technology

Real-World Engineering Trade-offs in Android Development

There's rarely a best architecture, library or approach, only trade-offs that fit a context. Senior engineers are distinguished less by knowing more patterns than by choosing wisely and explaining why. Here are the common Android trade-offs and a framework for deciding.

✍️ Yunok Tech 📅 Updated ⏱ 3 min read 🎯 Advanced
On this page
  1. A decision framework
  2. The forces that usually matter
  3. Common Android trade-offs
  4. Worked example: should we add a domain layer?
  5. Record decisions
  6. Reasoning pitfalls
  7. In interviews
  8. Frequently asked questions
  9. Conclusion

"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

Trade-off decision process Clarify the goal and constraints, list realistic options, compare them on the forces that matter such as user impact, team skills, cost, time and reversibility, decide and record why, then revisit when the context changes. Goal +constraints Options2–3 real ones Compareon forces Decide+ record why Revisitwhen context changes
Reversibility matters: decide cheap-to-change things fast, and expensive-to-change things carefully.

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

DecisionOption A favours…Option B favours…
Native vs cross-platform (KMP/CMP, Flutter)Native: platform UX, newest APIs, performanceShared: one team, faster parity
Single module vs modularizationSingle: simplicity for small teamsModules: build speed, ownership at scale
Offline-first vs online-onlyOffline: resilience, speedOnline: simplicity, no sync conflicts
MVVM vs MVIMVVM: less ceremonyMVI: predictable complex state
On-device vs cloud AIOn-device: privacy, offline, no per-call costCloud: capability, device coverage
Build vs buy (auth, analytics, chat)Build: control, no vendor lock-inBuy: speed, maintained by experts
Testing depthMore tests: confidence, refactor safetyFewer: speed early on (with risk)
Domain layer everywhereConsistency, reuseSkipping: 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

docs/adr/0007-selective-domain-layer.mdText
# 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.

See all our apps →

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.

Share: LinkedIn X / Twitter WhatsApp