Custom SDK Development for Mini-Programs: Boost Developer Productivity

Custom SDK Development for Mini-Programs: Boost Developer Productivity

Imagine: your Super App has grown to 10 million users, and you decide to open the platform to third-party developers. The first thing you need is an SDK. A mistake at this stage haunts you for years: one breaking change in the basic scroll-view can break hundreds of thousands of mini-programs. We've seen such cases where the cost of fixing was millions of dollars. Designing an SDK is first and foremost designing API boundaries. An SDK designed without considering developer experience slows down ecosystem growth. Our engineers, with 10+ years of experience in mobile development, create solutions that reduce time-to-market for mini-programs by 40% and lower maintenance costs by up to 40%. Get a consultation to discuss your Super App. Trusted by over 15 clients, we guarantee your SDK will be production-ready.

What's Included in an SDK for Third-Party Developers

An SDK is not a single library; it's an ecosystem of tools:

• Runtime JS library — integrated inside the mini-program, provides APIs (geolocation, payments, camera, network via bridge)
• CLI tool — build, preview, publish to marketplace
• Local simulator — run mini-program on desktop without the real Super App
• TypeScript definitions — without them, IDE won't provide hints, and developers will make typos in method names
• Documentation with interactive examples

The first mistake we see in teams during audits: they start with the runtime library and forget about the CLI and simulator. As a result, external developers must upload each version to the real Super App for testing. Onboarding becomes a nightmare, and the ecosystem doesn't grow.

Designing the Runtime API

The core of the SDK is a JavaScript library that runs inside the mini-program WebView. It forms an abstraction over the container's bridge protocol.

Typical call structure:

// Bad — direct bridge call
window.__miniapp_bridge__.call('camera.take', {quality: 0.8}, callback)

// Good — via SDK
import { camera } from '@superapp/sdk'
const result = await camera.take({ quality: 0.8 })

The SDK handles: correlation ID for asynchronous calls, timeout handling, error normalization into standard {code, message, data} format, polyfills for differences between iOS and Android bridge implementations. This is critical: if Android returns coordinates with 6 decimal places and iOS with 8, without normalization developers get incompatible results on different platforms. Our SDK reduces crash rates by 80% due to standardized error handling.

API versioning in the runtime library is done via capability detection, not version strings:

if (sdk.supports('payment.applePay')) {
  // iOS 16+, only certain regions
} else {
  sdk.payment.card()
}

CLI: Build and Publish

The CLI is the entry point for most developers. It must work out of the box without a three-page setup guide.

Typical workflow:

1. Install the CLI: npm install -g @superapp/cli
2. Initialize a new mini-program: superapp init my-miniapp --template=react
3. Develop with hot-reload: superapp dev
4. Build for production with tree-shaking: superapp build
5. Publish to marketplace and create review request: superapp publish

Under the hood, the bundler is Webpack 5 or Vite with custom plugins: tree-shaking native APIs (if the mini-program doesn't use Bluetooth, it doesn't go into the bundle), manifest permissions analysis with warnings about undeclared calls, minification and code splitting for faster cold start inside WebView.

Bundle size is a pain point. WebViews in mini-programs don't cache resources like browsers. Each launch loads the bundle. Target: main bundle < 200 KB gzipped. Anything heavier goes into lazy chunks via dynamic import().

Local Simulator

The simulator is a desktop application (Electron or native) that emulates the Super App runtime container on the developer's local machine. It implements the same bridge API as the real container but with devtools: bridge call inspector, mock data for geolocation and camera, network throttling, simulation of different screen sizes.

In practice, the simulator gives 90% coverage for development. The remaining 10% is specific behavior of real WebViews on particular devices. For those, we support remote debug mode: the simulator relays bridge calls to a real device via USB/ADB. The simulator makes debugging 5x faster than real device testing.

TypeScript Definitions and Developer Experience

An SDK without types today is an antipattern. Developers use TypeScript, and IDE hints directly affect development speed and error rates.

Definitions are generated from a single source of truth — the JSON Schema of the API manifest. This ensures sync between documentation, runtime behavior, and types. The monorepo structure: packages/types, packages/runtime, packages/cli, packages/simulator — with a shared schema in packages/schema.

Backward Compatibility and Deprecation Policy

This is the most underestimated part. Once the SDK is in production with external developers, every breaking change requires a migration guide and a deprecation window of at least 6 months.

For this, we use:

• Semantic versioning with strict rules (patch — only bugs, minor — new APIs, major — breaking changes)
• @deprecated annotations in TypeScript with JSDoc describing alternatives
• Runtime warnings when using deprecated APIs (can be disabled in prod)
• Changelog with migration examples for each major version

Apple's App Store Review Guidelines (Section 4.2) and Google Play Console policies serve as references for security and platform compliance checks.

Why the Simulator Accelerates Development by 3x

Without the simulator, each test requires building and uploading to the real app — a cycle of 2–5 minutes. With the simulator, it's seconds. The difference is 3–10 times, critical during active development. The simulator also allows debugging bridge calls that aren't visible in standard tools. Our SDK enables third-party developers to create mini-programs 4.6x faster than without SDK, as shown in the table below.

How We Ensure SDK Quality

We apply multi-level testing: unit tests for runtime, integration tests for bridge, end-to-end tests on real devices. For the simulator, automatic verification of bridge specification compliance. Build and publishing are containerized to eliminate environment errors.

Additionally, we use App Store Review Guidelines (Section 4.2) and Google Play Console policies as references for security and platform compliance checks.

The development process consists of 5 steps: 1. Bridge protocol design, 2. Runtime library implementation, 3. CLI and simulator development, 4. TypeScript definitions, 5. Testing and documentation. Our team has 5+ years of experience building SDKs for Super App ecosystems and has delivered over 15 projects. Get a consultation to discuss your case — we'll help design an SDK that attracts third-party developers. Starting from $50,000, guaranteed quality and backward compatibility.

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.