Mobile App Modularization: Architecture and Implementation

Problems Solved by Modular Architecture

A monolith app with 50+ screens where everything lives in one module — that's a story of an 8-developer team waiting 4 minutes for a full build on every change, and how one team's feature breaks another's tests because both import the same singleton. Modular architecture solves these exact problems. We help teams modularize applications from 20 to 200 screens, based on Apple Human Interface Guidelines and over 10 years of experience. Our modularization service costs between $15,000 and $100,000 depending on project size, and can save you over $100,000 annually. The service includes modular scheme design, core-module implementation, feature migration, and build configuration.

• Build speed. Changing one file in a feature module triggers a rebuild only for that module. Modularization cuts incremental build time by 3–5x — from 7–11 minutes to 45–90 seconds (real case).
• Merge conflicts. When multiple teams work in the same .pbxproj or build.gradle, conflicts are inevitable. Modules isolate code: feature branches rarely collide.
• Test isolation. Tests of one module don't depend on changes in another. You can run only the affected module's tests.

How We Do It: Stack and Practices

Module Separation

The standard approach is feature-based division with a shared core layer:

:app                    — entry point, DI graph, navigation
:core:network           — HTTP client, interceptors
:core:storage           — DB, SharedPreferences/DataStore
:core:ui                — common components, theme
:core:auth              — tokens, AuthInterceptor
:feature:profile        — user profile
:feature:catalog        — product catalog
:feature:checkout       — checkout flow
:feature:orders         — order history

Each :feature:* module depends only on :core:* and knows nothing about other features. Navigation between features is done via abstraction: a NavigationManager in :core used by each feature for transitions without directly importing another feature module. On Android — Navigation Component with NavGraph at :app level, deep links registered in module manifests. On iOS — Coordinator pattern or Router with protocol-based navigation.

Android. Each :feature:* is a separate Gradle module (:feature:catalog → catalog/build.gradle.kts). Gradle Configuration Cache + Build Cache (~/.gradle/caches) radically cut rebuild time: change only :feature:checkout — it alone is rebuilt. --configuration-cache in Gradle 8 is stable. Kapt → KSP: migrating annotation processors from Kapt to KSP (Kotlin Symbol Processing) yields +30–50% in code generation speed.

iOS. Modules are implemented via Swift Package Manager (local) or as Framework targets in an Xcode workspace. Swift Package Manager supports local packages via path: in Package.swift. Workspaces with multiple projects (Feature1.xcodeproj, Feature2.xcodeproj) are legacy; the modern approach is a monorepo with local SPM packages + one main .xcodeproj. Tuist or XcodeGen auto-generate .xcodeproj from config files, eliminating merge conflicts in .pbxproj.

DI in Modular Architecture

The DI graph should not be monolithic. On Android — Hilt with @InstallIn(SingletonComponent::class) for core dependencies and @InstallIn(ViewModelComponent::class) for feature-specific ones. Each feature module declares its own @Module classes; Hilt assembles the graph at compile time. This means: if :feature:catalog is not included in :app, its DI module is not compiled and does not affect the build.

On iOS — manual DI via Resolver/Swinject, or a pure factory pattern without a DI framework. In a modular app, a DI framework on Swift is less critical: dependencies are passed through initializers, and the Composition Root in :app assembles everything.

Why Modular Architecture Is Better Than a Monolith?

A modular app saves up to 40% of the development budget in the long term (based on our experience). Compare: in a monolith, one error in shared code can paralyze an entire team for a day, while in a modular app the problem is localized. Google I/O demonstrated that Play Feature Delivery can reduce the base APK size by 30–50%.

Dynamic Delivery and Optional Modules

Android allows delivering feature modules on demand via Play Feature Delivery (formerly Dynamic Delivery). The user downloads the base app; heavy features (AR try-on, offline maps) download on first use. SplitInstallManager controls downloads, SplitCompatActivity handles activation. iOS has no direct equivalent — App Clips cover a different niche.

Case study. Retail app: 6 teams, 80+ screens, Android + iOS. Before modularization: full Android build — 7 minutes, iOS — 11 minutes. After splitting into 14 modules with Build Cache configured: incremental build when changing one feature module — 45–90 seconds. Merge conflicts in shared code dropped roughly threefold. Parallel feature development without team blocking. Time savings estimated at 30–50% over the long haul. Average modularization budget depends on project complexity and is determined after an audit. For a typical 50-screen app, modularization costs $30,000–50,000, yielding annual savings of $100,000 in reduced merge conflict resolution and faster builds. The investment typically pays for itself within 6 months.

What’s Included (Deliverables)

Our deliverables include:

We provide detailed documentation, repository access, team training, and post-release support.

How Modularization Works: Step by Step

1. Analyze current architecture — identify dependencies and cycles.
2. Design modular scheme — module diagram and interfaces.
3. Implement core modules — core layers (network, storage, ui).
4. Migrate features — each feature becomes its own module.
5. Configure build — Build Cache, Configuration Cache, CI/CD.
6. Test and document — module tests, navigation schema, README.
7. Support and train team — code reviews, workshops on modular development.

Timelines and Cost

Cost is calculated individually after an audit of the architecture and existing code dependencies. Order an audit — we will assess your project and propose an optimal modularization plan. Call or write to us to discuss details. Find out how modularization can accelerate your development — get a consultation today.

Common Mistakes in DIY Modularization

Circular dependencies. :feature:profile imports :feature:orders, :feature:orders imports :feature:profile. Gradle won't build — circular dependency. Solution: extract shared models to :core:domain or :shared:models; both features depend only on that.

Too granular modules. :core:extensions with 5 extension functions — overhead without benefit. A rational minimum: a module is justified if it can be changed independently and does not depend on modules that change more often.

Resource ID conflicts. On Android, merging resources from multiple modules causes name collisions. Convention: module prefix for all resources (catalog_item_card_background, not just item_card_background). R class isolation via android.nonTransitiveRClass=true in gradle.properties is mandatory for large projects.

Why Entrust Modularization to Professionals?

We have over 10 years of experience in mobile development and have completed more than 40 projects with modular architecture. We guarantee a smooth transition without team downtime. Apple Developer and Google Associate Android Developer certifications validate our expertise. Contact us for a consultation — we will help you accelerate development and reduce cost of change.

Mobile App Architecture

The app is built in a single ViewController with 2000 lines. Network calls, business logic, UI updates—all in one place. Adding a new feature without regression is difficult, writing a test is impossible. This isn’t “bad code”—it’s a lack of architecture. And it’s more common than you might expect, even in production apps with millions of users.

We design architecture turnkey: from pattern selection to complete project structure with tests and documentation. In 7–10 days you get clean, modular code ready for scaling.

Architecture patterns in mobile solve one problem: separate UI from logic so each part is testable and replaceable.

MVVM: Basic Pattern

Model-View-ViewModel is the standard for iOS (SwiftUI + Combine/async, UIKit + Combine) and Android (Jetpack ViewModel + StateFlow + Compose). The ViewModel holds UI state and business logic. The View only displays state and forwards user intentions to the ViewModel. The Model represents data and its source.

Key rule: ViewModel knows nothing about UIKit or Android View classes. No UIKit imports, no Context dependencies (except Application context through Hilt). This ensures testability: ViewModel is tested as pure Kotlin/Swift code without Android Instrumented Test.

MVVM covers 70% of needs. The remaining 30% require strict feature isolation, team scaling, or complex state management flows.

Clean Architecture: When MVVM Isn’t Enough

Adds layers on top of MVVM:

• Domain layer — business logic, platform-independent. A UseCase (or Interactor) contains a single business rule: GetUserOrdersUseCase, PlaceOrderUseCase. Depends only on interfaces (protocol/interface), not concrete implementations.
• Data layer — repository implementations. OrderRepositoryImpl implements OrderRepository from domain. Knows about Retrofit, Room, UserDefaults. The ViewModel doesn’t know where data comes from—network or cache.
• Presentation layer — ViewModel + View. Knows about Domain, not Data.

Dependency rule: dependencies point inward only. Domain depends on nothing. Data and Presentation depend on Domain.

Presentation → Domain ← Data

This allows swapping implementations: tests use an in-memory repository instead of network, the interface remains the same.

Practical caveat: Clean Architecture adds files and layers. For small apps, this is overhead. It’s justified starting from ~15 features and teams of 3+ developers.

BLoC for Flutter: Predictable State Flow

BLoC (Business Logic Component) is the standard pattern in the Flutter community. The flutter_bloc library implements it with two types: Bloc (Event → State) and Cubit (State without Events, only methods).

Bloc processes Event and emits a new State via on<EventType> handlers. State is immutable—a new object for each change. BlocBuilder re-renders only the part of the tree where state changed.

// Event
abstract class CartEvent {}
class AddItemToCart extends CartEvent {
  final String productId;
  AddItemToCart(this.productId);
}

// State
abstract class CartState {}
class CartLoaded extends CartState {
  final List<CartItem> items;
  CartLoaded(this.items);
}

// Bloc
class CartBloc extends Bloc<CartEvent, CartState> {
  CartBloc(this._cartRepository) : super(CartLoaded([])) {
    on<AddItemToCart>(_onAddItem);
  }

  Future<void> _onAddItem(AddItemToCart event, Emitter<CartState> emit) async {
    final current = state as CartLoaded;
    final updated = await _cartRepository.addItem(event.productId);
    emit(CartLoaded(updated));
  }
}

The advantage of BLoC is testability. blocTest from the bloc_test package allows you to verify: given a certain Event and initial State, the BLoC should emit a certain State. No UI, no mocks for the Flutter framework.

VIPER: For Large iOS Projects

VIPER (View, Interactor, Presenter, Entity, Router) is the strictest separation of responsibilities for iOS. Each component has a protocol and concrete implementation.

• View — UI only, delegates everything to Presenter
• Interactor — business logic, network and data operations
• Presenter — mediator between View and Interactor, formats data for View
• Entity — data models (pure structures)
• Router — navigation between modules

Each module (screen or feature) is a separate VIPER module. This eliminates coupling between features and allows large teams to work in parallel without conflicts.

The cost: many files, many protocols. Boilerplate is generated via Sourcery or custom Xcode templates. VIPER is justified for apps with 10+ developers and 50+ screens.

TCA (The Composable Architecture)

TCA by Point-Free is a more modern alternative to VIPER for iOS/macOS. Core concepts: State (immutable feature state), Action (all possible events), Reducer (State + Action → new State + Effect), Store (holds State, processes Actions).

Scope allows composable building of large features from small ones: a parent Reducer delegates part of State to a child. Each feature is tested in isolation via TestStore with precise control over Effects.

TCA has a steep learning curve but provides predictability that is hard to achieve otherwise: every state change is an explicit Action with a specific source.

Which Pattern to Choose for Your Project?

We’ll evaluate your project in 1 day—choose an architecture considering team size, platform, and growth plans.

There is no universal answer. Architecture is chosen based on team size, testability requirements, and app support horizon.

What Components Are Included in Our Architecture Work?

• Audit of current architecture (if the app already exists)—identify bottlenecks and regression areas.
• Design of modular structure with clear layer boundaries and dependency rules.
• Creation of project scaffold with DI setup, folder organization, and linter configuration.
• Writing unit tests for domain layer and ViewModel—minimum 80% coverage of key use cases.
• Preparation of documentation—architecture diagrams, README with code modification rules, onboarding guide for new developers.
• Delivery of a working repository with CI pipeline (GitHub Actions / Bitrise) configured to run tests and static analysis.

All this is included in the design cost. Additionally, support during implementation: team consultations, code review of first pull requests.

How Does Lack of Architecture Affect Development Speed?

Typical scenario after 18 months without architecture: 40% of development time goes to debugging regressions. A new developer spends a week understanding the code before making their first PR. Tests aren’t written “because it’s hard to mock.” Adding a new feature requires understanding half the codebase.

Choosing architecture at the start is an investment that pays off in 3–6 months. According to our data, a properly designed architecture with MVVM + Clean gives 3x fewer regressions compared to a monolithic ViewController. And the cost of implementation is recouped in 2–3 sprints.

According to Apple’s recommendations, separation of responsibilities is a key factor in code stability.

Why Trust Our Team with Architecture?

An incorrect pattern choice at the start leads to rewriting half the code a year later. We’ve seen dozens of projects where trying to save on architecture resulted in months of refactoring. With over 10 years of commercial development experience and work on apps from 1 to 50 developers, we help avoid common mistakes:

• Overengineering for a simple MVP (we assign MVVM, not VIPER).
• Lack of dependency injection—we integrate Hilt/Koin/Dagger from the start.
• Ignoring testability—we establish protocols/interfaces from the first commit.

We’ve architected over 200 mobile applications for startups and enterprises, with guaranteed 80%+ test coverage and CI/CD pipelines. Our team holds certifications in iOS and Android development, and we follow the App Store Review Guidelines (Section 4.2/5.1) to ensure smooth store approvals.

Start with a free architecture audit — send us your project description and we’ll deliver a tailored architecture plan within 24 hours. Reach out via Telegram or email to get started.