Back to all posts
SDKs & Integrations7 min read·October 25, 2026

What Should You Check Before Adding an App SDK?

TB
ThynkBlox Apps Team
App Engineering

Evaluate a third-party mobile SDK as an ongoing dependency with access to part of your app’s runtime: what it does while the app runs. Before adding it, check permissions, collected data, maintenance, app size, licence terms and how you would remove it. Compare it with a simpler integration, then test the candidate in a small build before committing.

Do you need an SDK for this feature?

An SDK, or software development kit, supplies code and tools for integrating a service or capability into your app. Start with the user’s need, rather than the supplier’s feature list.

Write one sentence describing the outcome: “Let a customer send a support request with an optional screenshot.” Then ask whether that needs an embedded support system, or whether a form connected to your server would be enough.

Compare the SDK with a direct service request, a browser-based flow or a built-in device feature. Ask what each option requires for authentication, error handling, accessibility and ongoing support. A smaller integration still needs careful design.

Use your app MVP scope to keep this decision focused. Features outside the agreed first release should not decide which dependency enters it.

What permissions and runtime access does it need?

Ask your developer to review what the SDK adds to the app’s configuration and what it accesses when running. Do not limit the review to permission prompts. The same review feeds your Google Play Data safety answers.

Request a written account of:

  • Permissions added, and which feature needs each one.
  • Access to files, identifiers, location, camera or microphone.
  • Work performed at startup or in the background.
  • Additional libraries included with the SDK.
  • Behaviour when a permission is denied or later withdrawn.

For each item, ask whether it is necessary for your chosen feature and whether it can be disabled.

Test the actual configuration you intend to release. If optional access cannot be switched off, decide whether that is acceptable before integration spreads through the app.

What data does it collect, and where does it go?

Request a data inventory for the exact SDK version and configuration under review. “Usage data” is too broad to make a useful decision.

Ask which fields leave the device, what triggers each transfer, where the information goes, how long it is kept and how deletion works. Include diagnostic reports and automatically recorded events in the questions.

Distinguish between data your team deliberately sends and data the SDK records by default. Request evidence for both, such as documentation and observed requests from a test build.

If collection depends on a user choice, test that choice before starting the SDK. Check first launch, refusal, withdrawal and the next app launch. Resolve unexplained collection before approval, and use the verified inventory when preparing user-facing privacy information.

How do you judge maintenance and support?

Read release notes for evidence of how the supplier handles fixes, compatibility changes and migrations. A recent release alone should not settle the decision.

Ask your developer to identify the supported mobile platforms and versions, known issues relevant to your app, and changes required for the next upgrade. For a cross-platform app, review both the wrapper your code uses and the underlying mobile libraries.

Give someone responsibility for reviewing updates after launch. Agree how urgent fixes will be assessed, who tests upgrades and what happens if support ends.

Include that work in your maintenance plan after launch. The decision should cover who keeps the integration working, as well as who adds it.

How should you measure app size and performance?

Compare otherwise equivalent release builds with and without the SDK. Record the build settings and devices used so the comparison can be repeated.

Measure the delivered app size for each supported platform, startup behaviour, memory use and responsiveness during the feature’s main flow. Test background activity and battery use where relevant to the proposed integration.

Set acceptance criteria before looking at results. Avoid a universal size or speed limit: decide what your app and its users can reasonably accept.

Include slow connections, offline use and service failures. Check whether the rest of the app remains usable when the integration cannot complete its work. Add these cases to your Android release testing.

What should you check in the licence and service terms?

Review the software licence and the connected service’s commercial terms separately. Record the versions of the terms you assessed.

Ask whoever reviews your agreements to check:

  • Whether your intended commercial use and distribution are permitted.
  • Required notices, attribution or source-sharing obligations.
  • Terms for bundled dependencies.
  • Usage limits, paid features and charging triggers.
  • Rights relating to submitted data, retention and export.
  • Termination, suspension and changes to the terms.

For any pricing tied to usage, model your own expected activity and a busier scenario. Include the ongoing work of operating and updating the integration.

If a term is unclear, get qualified advice before relying on it. Record the answer in plain language so the product owner understands the commitment.

Could you remove or replace it later?

Ask for a removal plan before approving the integration.

Identify every screen, stored record, account flow and server connection that would depend on the SDK. Decide what should happen to each if you switch suppliers or discontinue the feature.

Where practical, keep calls to the SDK behind a small interface controlled by your app. Request a demonstration that the integration can be disabled without breaking unrelated journeys.

If the service stores information you need, test an export and inspect its contents. Check whether records retain enough meaning to be useful elsewhere.

Define the fallback experience too. That might mean hiding an optional feature, offering another route or explaining clearly why an action is unavailable.

What should an approval checklist contain?

Use a short decision record that combines evidence, unresolved questions and responsibility.

AreaEvidence to requestApproval question
NeedFeature requirement and alternativesIs the SDK justified?
AccessConfiguration review and permission testsIs each access necessary?
DataField inventory and observed requestsIs collection understood and acceptable?
MaintenanceRelease history and upgrade reviewCan we support it?
Size and performanceComparable release-build resultsDoes it meet our criteria?
TermsLicence and commercial reviewAre the obligations acceptable?
ExitDisable, removal and export checksCan we leave safely?

For example, consider an app that needs customers to attach a photo to a support request. Compare a support SDK with a simple upload form. Approve the SDK only if its additional capabilities justify the access, data handling, cost and maintenance work. Record the reason for choosing either option.

What common mistakes should you avoid?

Approving from a demo alone. Require evidence from your own build and intended settings.

Reviewing only requested permissions. Include data transfers, automatic events and background behaviour.

Testing only a successful connection. Exercise denial, timeout, offline use and unavailable service responses.

Treating optional features as free additions. Ask whether their access and maintenance requirements belong in the current scope.

Leaving ownership with the original developer indefinitely. Assign a continuing owner for updates, supplier notices and removal decisions.

If evidence is missing, keep the decision open. An unanswered question should not quietly become an assumption.

Frequently asked questions

Is an SDK always better than a direct integration?

Choose through comparison. Ask what useful work the SDK handles and what responsibilities remain with your team. A direct integration may suit a narrow requirement; a more involved feature may justify an SDK.

Can we approve an SDK before development starts?

You can shortlist it and review documentation and terms. Keep final approval conditional on a small working integration, observed data behaviour and measurements from your app.

Should every update receive the same review?

Set review depth according to the change. Check release notes and changed dependencies, then repeat the relevant tests. Reassess permissions, collection, terms or removal assumptions whenever an update affects them.

What if the supplier will not answer a data question?

Treat the missing answer as an unresolved approval item. Seek verifiable documentation or consider an alternative that meets your requirements with clearer evidence.


Planning an app with external integrations? Explore our app development services or contact us to discuss the feature, its dependencies and ongoing support.

Ready when you are

Planning an app of your own?

Tell us where your project is today. We will help you work out the scope before you commit to a budget.