We build high-performance, privacy-compliant Mobile SDKs that developers actually want to integrate. Cross-platform logic via Kotlin Multiplatform, on-device AI with Gemini Nano and LiteRT, and audit-ready compliance documentation. We handle the full lifecycle: architecture, development, and distribution on SPM and Maven Central, plus CocoaPods for existing integrations (the CocoaPods trunk stops accepting new releases on 2 December 2026).
50+ apps shipped since 2017
Foresight Mobile engineers enterprise-grade SDKs using Kotlin Multiplatform (KMP) for shared business logic with native binary interfaces, as well as dedicated SDKs for Flutter, React Native, iOS (Swift Package Manager, with CocoaPods kept for existing integrations) and Android (Maven Central via the Central Publisher Portal & Gradle).
For SDKs that need to behave the same on iOS and Android, we usually recommend Kotlin Multiplatform. Unlike full cross-platform frameworks, KMP compiles shared Kotlin code into standard native binaries (XCFrameworks for iOS and AARs for Android), so Swift and Kotlin developers integrate it like any other native library. React Native and Flutter apps use the same binaries through a plugin.
If you already have native SDKs for iOS and Android, we can cost-effectively wrap your existing libraries to expand into the cross-platform market. If you're providing a web or REST-based service, we can bring your products to mobile using our SDK development best practices.
More SDKs now use the device's Neural Processing Unit (NPU) to run AI features offline. We integrate Small Language Models (SLMs) and specialised neural networks directly into SDKs using LiteRT (TensorFlow Lite), Core ML, and ExecuTorch. This enables real-time inference, on-device RAG, and privacy-preserving analytics without cloud dependency.
We can build automated Software Bill of Materials (SBOM) generation (CycloneDX or SPDX) into your SDK's release process, along with iOS Privacy Manifests and security hardening such as certificate pinning and obfuscation. That helps with the EU Cyber Resilience Act, whose vulnerability-reporting duties have applied since 11 September 2026 and whose main requirements, including an SBOM, apply from 11 December 2027.
When distributing iOS SDKs, developers need to understand Apple's distribution requirements. Our iOS app distribution guide covers everything from TestFlight beta testing to App Store distribution for SDK developers.
We publish our own open source packages. See some of our Flutter packages on pub.dev.
A four-week plan with clear deliverables and a fixed price of £3,500, credited against your first development sprint.
Total client time commitment: 5-7 hours across 4 weeks
We meet with your key stakeholders to understand your business goals, user needs, and technical constraints. You'll share any existing research, designs, or documentation you have.
Our engineering team assesses the technical feasibility, identifies integration points with your existing systems, and evaluates architecture options.
We determine whether Flutter, native development, or another approach makes the most sense for your specific requirements.
We create clickable prototypes so you can experience your app before it's built. You'll test navigation flows, validate the user experience, and gather feedback from stakeholders.
Alongside this, we prioritise features based on business value and technical complexity, mapping out a phased delivery plan with a detailed cost estimate.
You receive your complete Gameplan pack, plus a presentation walkthrough with Q&A. Your team walks away with everything needed to make a confident decision.
Enterprise SDK engineering with native distribution to Swift Package Manager, Maven Central, Gradle, npm, and CocoaPods (in maintenance mode)

High-value customers adopt your SDK faster with hands-on integration support. From white-label SDK customisation to technical assistance alongside your developer advocates, the goal is accelerating adoption and reducing time-to-value.

Secure, offline-resilient telemetry for MAU, session, or event-based billing, designed into the architecture from day one. From usage-based pricing infrastructure to Open Core strategies, the boundary between community and enterprise features is clearly defined.
Developers champion SDKs that feel native. Idiomatic APIs with native-feeling syntax for Swift and Kotlin, AI-optimised design for smooth integration with GitHub Copilot, Cursor, and Claude Code, thorough documentation with copy-paste ready snippets, and distribution via Swift Package Manager, Maven Central, and npm.
The EU Cyber Resilience Act's duty to report actively exploited vulnerabilities has applied since 11 September 2026, and we help you set up the process and the evidence for it. We can also build automated SBOM generation (CycloneDX or SPDX), iOS Privacy Manifests and VEX documentation into every release, ready for the CRA's SBOM requirement from 11 December 2027, along with certificate pinning, obfuscation and tamper detection.
Offline AI features built into your SDK, so personal data can stay on the device. Models run through Core ML on iOS, LiteRT on both platforms, and Gemini Nano on supported Android devices through Google's ML Kit GenAI APIs, for real-time inference, on-device search and predictive analytics.
Write the business logic once in Kotlin Multiplatform (KMP) and ship it as native XCFrameworks and AARs, with platform-specific code only where iOS and Android genuinely differ. Swift and Kotlin developers get an idiomatic API, and React Native and Flutter developers get a plugin over the same core. The Kotlin/Native runtime adds some size to the iOS framework, so we measure it against your customers' size budget.
A Software Bill of Materials (SBOM) is a formal inventory of every component, library, and dependency in your SDK. The EU Cyber Resilience Act requires manufacturers of products with digital elements to draw one up from 11 December 2027, and its vulnerability-reporting duties have applied since 11 September 2026.
Enterprise customers demand SBOMs (in CycloneDX or SPDX format) to manage security risks. They need to know immediately if a vulnerability like Log4j, or a compromised dependency like the malicious axios releases published to npm in March 2026, affects their applications. We also provide VEX (Vulnerability Exploitability eXchange) documents that clarify whether flagged vulnerabilities actually impact your SDK, reducing false positives for your customers' security teams.
iOS Privacy Manifests (PrivacyInfo.xcprivacy) are declaration files that Apple requires for every SDK on its list of commonly used third-party SDKs, with a signature when the SDK ships as a binary. They explicitly declare what data the SDK collects (contact info, location, identifiers) and which "Required Reason APIs" it accesses (disk space, boot time, user defaults).
Apple requires the manifest when an app that includes a listed SDK is submitted. Even if your SDK isn't on the list, the apps that use it still have to declare the Required Reason APIs it calls, so we include a privacy manifest in every SDK release we build.
Kotlin Multiplatform (KMP) is a technology that allows SDK developers to write business logic once in Kotlin and compile it to native binaries for multiple platforms. Unlike Flutter or React Native, KMP produces standard XCFrameworks for iOS and AARs for Android, so developers integrate them like any other native library.
For SDK development, KMP solves a critical problem: your iOS customers expect a Swift interface, while Android customers expect Kotlin. KMP delivers both from one shared codebase, so behaviour stays consistent across platforms and one fix covers both. The trade-off is that the Kotlin/Native runtime, including its own garbage collector, is built into the iOS framework and adds to its size, which we measure before release.
An API defines how two systems talk to each other, for example over HTTP with REST or GraphQL.
An SDK (Software Development Kit) is a complete toolkit that wraps the API with type-safe libraries, authentication handlers, error management, offline caching, and platform-native interfaces. Modern SDKs are designed for AI-assisted development, with idiomatic naming conventions that help GitHub Copilot, Cursor, and Claude Code predict correct usage. While APIs define what is possible, SDKs abstract complexity and accelerate integration. For example, Stripe's mobile SDKs handle card collection, retries and Strong Customer Authentication, which would take a lot of hand-written code against the raw API.
Common types of mobile SDK:
• Edge AI/ML SDKs: LiteRT (TensorFlow Lite), Core ML, ExecuTorch, MediaPipe for on-device intelligence and SLM deployment
• Analytics SDKs: Google Analytics 4, Mixpanel, Amplitude
• Payment SDKs: Stripe, Square, Adyen with strong customer authentication (SCA)
• Cloud SDKs: AWS Mobile, Google Cloud, Azure with offline-first sync
• AR/VR SDKs: ARCore, ARKit, RealityKit for spatial computing
• Authentication SDKs: Auth0, Firebase Auth, Okta with passkey support
• Messaging SDKs: Twilio, Sendbird, Stream for real-time chat
• Identity Verification: Onfido, Jumio, Veriff for KYC/AML compliance
• Crash Reporting: Crashlytics, Sentry, Bugsnag
• Push Notifications: OneSignal, Firebase Cloud Messaging, Airship
A Mobile SDK (Software Development Kit) is a complete toolkit that enables developers to integrate specific functionality into their apps without building from scratch. In 2026, enterprise-grade SDKs go far beyond basic libraries. They include on-device AI capabilities, automated compliance documentation, and "native-feeling" APIs for every platform.
Modern SDKs provide access to device capabilities (camera, GPS, biometrics, NPU), handle complex operations (payments, authentication, analytics), and ensure regulatory compliance. Built with Kotlin Multiplatform for shared logic, they produce native XCFrameworks and AARs that slot directly into any tech stack. Key features include modular architecture for minimal binary size, privacy-preserving on-device processing, and automatic iOS Privacy Manifest generation.
We quote SDK work after discovery, once we know what the SDK has to do and who will integrate it.
Key cost factors include: platform coverage (iOS, Android, Flutter, React Native), on-device AI integration (model optimisation, NPU targeting), compliance requirements (SBOM, VEX, Privacy Manifests), documentation quality, sample applications, and ongoing maintenance. Kotlin Multiplatform usually costs less than building and maintaining separate iOS and Android SDKs, because the core logic is written and fixed once.
You'll always know where your project stands.
Building a mobile app that people actually use takes more than good code. It takes a clear scope, decisions made with the right data, and a team that tells you what's going wrong before it's a problem. That's how we've delivered 50+ apps across Flutter, Swift, Kotlin, and React Native, from lean MVPs to enterprise-grade platforms.
Ready to talk through your idea?
We map your user journeys, define the core feature set, and agree on a technical architecture before a line of code is written. You get a written scope document, a prioritised backlog, and a fixed-price proposal. We use Miro for journey mapping and Figma for early wireframes, so you can review everything before committing to a sprint.
Our designers work in Figma, producing high-fidelity screens tested against real platform guidelines: Apple's Human Interface Guidelines for iOS and Material Design 3 for Android. You test the prototype on your own device, gather feedback from real users if you choose, and sign off each screen. Changes at this stage cost hours, not sprints.
Development runs in two-week sprints with a working build available on TestFlight (iOS) or Firebase App Distribution (Android) at the end of each one. Every release goes through automated unit and integration tests, manual QA on physical devices across the current and previous major versions of iOS and Android, and accessibility checks against WCAG 2.2. You see progress every fortnight.
We handle App Store Connect and Google Play submission, including metadata, screenshots, and privacy questionnaires. We look for anything likely to be rejected at the start of the engagement. Using our experience, current legislation and the App Store and Google Play review guidelines, we tell you early about features that are contentious or at risk of rejection, while there's still time to change the plan. After launch, your app moves to our App Care programme: OS update monitoring, crash triage via Crashlytics, and a dedicated Slack channel for critical issues.
Your app, your way. Here's how we make it happen
Fixed price agreed upfront, with clear API contracts documented before we write a line of code. No scope creep, no surprise breaking changes at release.
SDK distribution is only the start. We offer ongoing maintenance to handle version management, deprecation cycles, and breaking change communication so your developer integrators stay up to date without pain.
Real developers from your target audience test SDK integration throughout development, not just at the end. Their friction points shape the API surface before it ships and before those decisions become permanent.
You know what your platform needs to expose. We know how to wrap it in an API that developers actually want to use. The two together is how SDKs go from "technically works" to "widely adopted."
We've built and maintained SDKs used by other companies' developers on iOS, Android and Flutter. In our experience, the hardest part of SDK development isn't the functionality: it's the API surface. We've iterated enough broken SDKs to know what makes a good one from day one.
We've built and shipped SDKs for other companies' developers, including iOS, Android, and Flutter packages on pub.dev and Maven Central. Our SDK design process starts with API drafts shown to real developer integrators before code is written, because the hardest SDKs to fix are the ones with breaking changes already shipped in other companies' apps. We're based in Manchester with offices in London and Birmingham.