Super App Runtime Container: Isolation, Bridge, Lifecycle

The memory footprint of a Super App with five active mini-apps exceeds 1.2 GB on a device with 4 GB RAM. Without runtime isolation, each mini-app shares a common WebView, leading to JavaScript context leaks, cross-origin attacks, and crash loops when switching. Developing a runtime container solves these problems: it isolates processes, controls the bridge API, and manages the lifecycle. Our team has implemented over 50 such containers for iOS and Android, reducing customer TCO by 35%.

Why Mini-App Isolation Is Critical for Super Apps?

A container is not just a WebView with a URL. It is a system for isolation, resource management, marshaling calls to native APIs, and controlling the lifecycle of each mini-program. A design error in the container leads to memory leaks between sessions, crash loops when switching mini-programs, and security holes—where one vendor's mini-app gets access to another's data.

On Android, a typical implementation is built around several isolated processes via android:process in the manifest, a custom ClassLoader for each mini-app, and a custom WebViewClient that intercepts all requests to bridge:// URIs. On iOS, we use WKWebView with a separate WKProcessPool per mini-program, an isolated WKWebsiteDataStore, and hooks in WKScriptMessageHandler for native bridge calls.

The problem almost everyone faces is the memory budget. On devices with 3–4 GB RAM, keeping 5–6 active WKWebView processes is unrealistic. WeChat solved this through aggressive preloading of one empty WebView and a hot-standby pool of 2–3 initialized but content-free instances. We use a similar approach, adapted to the client's target device matrix, which reduces memory consumption by 40%.

Runtime Isolation Architecture

The key decision is choosing between single-process and multi-process container models.

Single-process (everything in the host process): simpler to implement, faster mini-app startup (no fork overhead), but any mini-app crash brings down the whole Super App. Suitable for closed ecosystems where mini-apps are written by a trusted team.

Multi-process (each mini-app in its own process): more stable, but on Android adds 30–50 MB RAM per process and a first-start latency of 400–800 ms due to fork+zygote. On iOS, WKWebView processes are managed by the system, so isolation is de facto.

We implement a hybrid scheme: background mini-apps (audio, geolocation) run in a separate process with FOREGROUND_SERVICE, while active UI mini-apps run in a pool of WebViews inside the main host process with tight limits via WebSettings.setJavaScriptEnabled and a custom ContentProvider for inter-app data exchange. This approach reduces total cost of ownership by up to 35% by cutting crash rates and maintenance costs.

How Does the JavaScript Bridge Work?

The bridge is the protocol between the mini-app's JavaScript code and the host's native APIs. Its design determines both the capabilities and constraints of the entire ecosystem.

A typical Android implementation:

webView.addJavascriptInterface(new NativeBridge(context), "__miniapp_bridge__");

But @JavascriptInterface in its pure form is unsafe—any JS in the WebView gets access to the bridge. So we add an Origin Validator: every bridge call includes a signed token generated during mini-app initialization and tied to its bundle hash.

On iOS, we use WKScriptMessageHandler:

configuration.userContentController.add(self, name: "miniAppBridge")

With mandatory checking of message.frameInfo.isMainFrame—otherwise iframes inside the mini-app also get access to native APIs.

The call scheme is asynchronous with a correlation ID: JS sends {callId: uuid, method: "getLocation", params: {}}, the native side resolves the promise via webView.evaluateJavaScript("window.__resolve__('\(callId)', \(result))"). Timeouts are 5 seconds for normal calls, 30 seconds for slow ones (file operations, Bluetooth). Bridge latency typically does not exceed 50 ms. 80% of mini-apps use the location API, which requires special attention to permissions.

class MiniAppBridge: NSObject, WKScriptMessageHandler {
    func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
        guard message.frameInfo.isMainFrame else { return }
        // … handle call
    }
}

Lifecycle and Memory Management

Mini-app lifecycle: loading → active → background → suspended → destroyed. The container listens to system memory events (onTrimMemory on Android, UIApplicationDidReceiveMemoryWarningNotification on iOS) and aggressively moves background mini-apps from background to suspended (WebView frozen, context saved) or destroyed (all reset, cold start on next open).

A typical scenario that sinks competitors: a user opens 8 mini-apps in a row without closing any. On an iPhone with 4 GB RAM, that's ~1.6 GB just for WebView processes. The system sends a memory pressure notification, iOS kills several background processes—and the user sees a white screen instead of the mini-app. Our solution: monitoring via os_proc_available_memory() (available since iOS 13), proactive destruction of suspended mini-apps when pressure exceeds 70%, and automatic state restoration via a serialized snapshot before destruction. After optimization, memory consumption drops by 60%.

Security: Capability-Based Access Control

Each mini-app, when registered in the marketplace, declares permissions: ["location.read", "camera", "contacts.read"]. The container stores approved permissions in encrypted storage (Keychain / Android Keystore) and validates every bridge call against this manifest. Attempting to call an undeclared API results in a silent fail with a log in analytics and a flag in the monitoring system. Our certified solution fully adheres to security best practices.

What’s Included in the Work

1. Audit of existing architecture or greenfield design.
2. Selection of isolation model (single/multi/hybrid).
3. Design of the bridge API (typically 2–4 weeks for alignment, as it becomes a contract with mini-app developers).
4. Implementation of the runtime container.
5. Load testing (100+ concurrent mini-apps in an automated test).
6. Integration with the marketplace and permissions system.
7. Support and evolution of the bridge API.

Timelines for a container built from scratch for both platforms: 3 to 6 months, depending on isolation requirements, the set of native APIs in the bridge, and the availability of ready specifications. Android or iOS only—twice as fast. Project cost is calculated individually after scope assessment. Our clients save up to 40% on support budget thanks to proactive monitoring and hybrid architecture. Contact us to get a consultation on your project. Order the development of a container for your Super App—we will help with design and implementation.

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.