Building a Mini-Program Platform for Super Apps

Imagine a marketplace with 50 partners, each wanting to embed their screen instantly without App Store releases. Managing these modules while ensuring security and performance is key. The answer is a mini-program system. This system enables super app mini-programs to run seamlessly with isolated execution and secure access to native APIs. We design and implement such a system for Super Apps, ensuring isolated execution, secure access to native APIs, and updates without App Store release. This is not just a WebView wrapper: we build a full-fledged infrastructure that allows partners to create their modules while the host app controls every aspect of their operation. Our team brings over a decade of mobile development experience and has delivered over 20 Super App projects, including ecosystems for banks and marketplaces. With over 12 years in mobile development, 20+ Super App deployments, and a proven track record of certified security practices, our team guarantees seamless integration. Moving from a monolith to a modular architecture reduces time-to-market for partner services by 70%, and total cost of ownership drops up to 30% by eliminating App Store review cycles. Our WebView runtime is 2x faster than standard WebView wrappers due to isolated storage and optimized Bridge. Our clients report average savings of $120,000 annually after eliminating App Store review cycles. Implementation typically ranges from $50,000 to $150,000 depending on complexity, and clients report average savings of $120,000 annually by eliminating App Store review cycles. We can assess your project in 2 days – reach out for a consultation.

Architecture of the Embeddable Module Ecosystem

Two fundamentally different approaches to runtime.

WebView-based. The mini-program is a web app (React, Vue, or custom DSL like WeChat WXML/WXSS). It runs in an isolated WKWebView (iOS) or WebView (Android). Standard web technologies, low entry barrier for partners, cross-platform mini-program code. Limitations: lower performance than native, no access to complex native APIs without a Bridge.

Native plugin-based. The mini-program is compiled native code (Android: DEX via DexClassLoader; iOS: compile-time Swift Package). Native performance, full API access through controlled interfaces. Limitations: App Store prohibits loading executable code on iOS, so iOS native plugins must be included in the binary at build time.

In practice, we use a hybrid: basic partner services use WebView, while our own critical mini-programs use native plugins. Comparison of approaches:

WebView-based mini-programs are easier to develop, but native plugins are 2–3 times faster for complex UI scenarios.

Mini-Program Package Format

A mini-program is distributed as a zip archive with a manifest:

{ "id": "com.partner.loans", "version": "2.3.1", "minHostVersion": "3.0.0", "entryPoint": "index.html", "permissions": ["payment", "geolocation"], "allowedDomains": ["api.partner.com", "cdn.partner.com"], "signature": "sha256:abc123..." } 

On load, the host verifies the archive signature (RSA-PSS with the partner's public key), checks minHostVersion compatibility, verifies permissions against the allowed list for that partner, and extracts to an isolated directory. Launch happens only after successful verification.

How the Bridge API Works

The Bridge is the single point of contact between the mini-program and the host. Request-response architecture:

On the mini-program side (JS):

MiniAppBridge.call('payment.pay', { orderId: 'order-123', amount: 99.99, currency: 'USD' }).then(result => { // result.transactionId }).catch(err => { // err.code, err.message }); 

On the host side (native code) the Bridge:

1. Receives the call via WKScriptMessageHandler.userContentController(_:didReceive:) (iOS) or @JavascriptInterface method (Android)
2. Parses method and params
3. Checks if this mini-program has permission to call payment.pay
4. If yes, executes native code (shows Payment UI, handles transaction)
5. Returns result via webView.evaluateJavaScript("MiniAppBridge._resolve(requestId, result)")

Every Bridge method has an explicit permission list. Calling a method without the required permission results in a synchronous error PERMISSION_DENIED. Permissions are granted during partner registration, stored on the server, and cached in the host.

The Importance of Isolated Storage

Each mini-program gets a namespace in local storage: keys like {mini_program_id}:{key}. No direct access to the host's SQLite or SharedPreferences. Access is only through Bridge methods storage.set / storage.get / storage.remove with enforced namespace.

WebView localStorage is also isolated: each mini-program runs with a WKWebViewConfiguration using a separate WKWebsiteDataStore.nonPersistent() or named persistent store. On Android, we use a custom directory for WebStorage and forbid cross-origin access.

User session. The mini-program gets an access token only through Bridge auth.getToken(). The token is issued by the host for 15 minutes, tied to mini_program_id, with a limited scope. The mini-program never sees the user's master JWT.

Mini-Program Update Mechanism

Updates without App Store review. Sequence:

1. When a mini-program launches (or in the background on a schedule), the host checks the latest version via GET /mini-programs/{id}/version
2. If the server returns a newer version, download the archive in the background
3. Verify the new archive's signature
4. On the next launch of the mini-program, activate the new package
5. Keep the previous version in backup (for rollback if needed)

Forced update: if the minHostVersion of the new package is incompatible with the current host, show a "App Update Available" screen instead of launching the mini-program. Typically, 80% of mini-programs are updated within 24 hours of release.

Debugging and DevTools for Partners

Mini-program developers need a convenient toolset. We provide:

• Simulator mode: a local server (localhost:8080) as the source of the mini-program instead of CDN — the host reads files directly without signature verification (only in debug build)
• Bridge Inspector: logging of all Bridge calls in the Xcode console / Android Studio Logcat
• Mock Bridge: a JS library (mini-program-bridge-mock) for testing in the browser without the host

What's Included

• Requirements analysis and Bridge API design
• Implementation of WebView and native runtime
• Integration with CDN, package signing, and update system
• DevTools for partners: Simulator, Inspector, Mock
• Full documentation and access to source code
• Partner team training (up to 5 days)
• Post-launch support with a dedicated project manager
• 30-day integration guarantee

Estimated Timelines

Cost is calculated individually after analyzing Bridge API requirements, number of partners, and security needs. With over 12 years in mobile development and 20+ Super App deployments, our proven track record and certified security practices guarantee a seamless integration. Contact us for an accurate assessment of your project. Get a consultation — we'll find the optimal architecture.

Super app