My Full App Development Tech Stack In 2026

Main topic

The video explains the creator’s complete mobile app development tech stack (aimed at 2026), centered around Kotlin Multiplatform (KMP) and a modern Android/iOS architecture.

A running example is a real-time chat app: “Chirp.”

Product / project example

• Chirp (real-time chat app)
  • Core features:
    • Group chat creation
    • Real-time message exchange
  • Also included:
    • Pagination
    • Custom authentication
    • Modular architecture
  • Serves as the reference implementation for many of the stack recommendations.

Stack components and key recommendations

1) Language & platform sharing

• Kotlin Multiplatform (KMP) is the default choice (used for ~90% of new apps).
• Trade-off guidance:
  • If most of the code can be shared, KMP is preferred.
  • If there are many platform-specific native behaviors/implementations, maintaining separate iOS (Swift) and Android codebases can be simpler.
• Even with KMP, the creator recommends selectively implementing some native functions when needed.

2) Data storage & settings

• Room for local database
  • Described as “conservative” and a good fit for Android + KMP.
• DataStore for local settings.

3) Networking & JSON

• Ktor for network queries (works in KMP and Android).
• Kotlinx Serialization for JSON parsing.
  • Explicit recommendation: do not use Gson
    • Reasons: reflection-based issues, Kotlin/Java mismatch concerns, and KMP incompatibility concerns.

4) Architecture (modules + patterns)

• Clean modular structure:
  • presentation / domain / data / core style modules
  • Example: chat database belongs in chat data because it’s only needed there.
• Presentation layer:
  • MVI (Model–View–Intent) for screens
  • ViewModel uses state data classes, updated via copy
  • Mentions handling one-time events via a pipeline approach

5) Reactive + parallel programming

• Coroutines and Flows are the reactive foundation (especially in KMP).
• Stream combination patterns include merging:
  • current UI state
  • repository chat streams
  • authentication/login state (e.g., hide chats when logged out)

6) UI approach (Compose vs native)

• Compose Multiplatform is used to share UI composables in commonMain.
• UI strategy trade-offs:
  • If UI is largely custom and shared, Compose Multiplatform is beneficial.
  • If the UI depends heavily on native components and you want identical structure but native look/feel:
    • build UI natively on both platforms
    • keep domain/data/business logic shared
• Notes generative agents may help translate code between Compose and SwiftUI.

7) Dependency Injection

• Uses Koin.
• Initial preference: a “more dynamic” setup (avoid annotation processing at first).
• Shift with agent-based generation:
  • With heavy agent-based generation, Koin annotations become more appealing because failures happen earlier (compile/build time) if dependencies aren’t registered.
  • Motivation: agents may forget to register components (e.g., ViewModels); annotations reduce runtime crashes.

8) Build & CI/CD tooling

• Build system: Gradle
  • Mentions JetBrains’ Amper as an early-stage Gradle layer.
• CI/CD:
  • Prefers Bitrise for mobile CI/CD (cloud emulators and mobile-specific nuances handled for you)
  • Mentions GitHub Actions, but finds it more painful for mobile instrumentation testing due to emulator setup complexity.

9) Observability / logging

• Recommended observability tools (not specific to the demo codebase):
  • Firebase Analytics
  • Crashlytics
  • Sentry
• Logging:
  • Kermit logger for KMP
    • supports turning logging on/off
    • avoids printLine

Testing stack (and why)

• Assertions: assertK
• Coroutines testing:
  • official coroutine test utilities (e.g., runTest, advanceUntilIdle)
• Flow/stream testing:
  • Turbine
    • useful for sequential emissions and waiting for the next item (awaitItem)
• Test doubles:
  • Prefer fakes over mocks to avoid brittleness and slow tests at scale
  • Mocking tools like MockK are discouraged unless testing legacy/unowned code

Missing/extra modules mentioned

• Navigation
  • Recommends Navigation 3 for navigation in Compose (Compose Multiplatform or native Android Compose)
  • Notes earlier limitations (e.g., deep links) have improved
• Image loading
  • Coil for Compose Multiplatform image loading + caching

Course / learning references (guide/tutorial angle)

• Promotes a course bundle focused on:
  • Building the mobile system using the chat app as an example
  • Learning backend architecture for scalable Spring Boot systems
• Emphasizes “learn by writing code,” not only reading materials or relying on AI prompts.

Main speakers/sources

• Primary speaker: the course creator/app developer Philip (introduced by name in the opening: “Philip, what technology stack…?”).