7 Tips on how to incorporate SDKs into your app

App developers are always on the lookout for SDKs that best fit their applications. It could be to improve product quality, increase stability, or speed up application development. Whatever the reason, it has become quite the norm; just like how the common helper libraries (e.g momentjs) are included, SDKs (i.e libraries/frameworks that largely enhance your app) are just as important.

Firebase and MixPanel are just two examples of widely used SDKs to build mobile apps.

However, while SDKs do reduce our efforts tremendously, as application developers we should incorporate SDKs carefully.

Below are the top seven tips that are handy while integrating the next SDK.

7 Tips on how to incorporate SDKs into your app

1. The Extent of Dependency on the SDK

Arguably the most important point is to understand the extent to which your application is dependent on the SDK. Let’s take Firebase for instance, if your application is using Firebase Authentication (User Management) that means a very high dependency, however, if it is using its Cloud Messaging module that means a medium dependency

As you understand the level of dependency, you can architect and structure the technical implementation accordingly.

HighThe SDK is central to your app’s business goal(s). Without this SDK, your app would not work at all.
There are no alternatives to the SDK’s functionality, except for building it yourself.

e.g. User Management
MediumThe SDK augments your app’s business goal(s).
Without the SDK, your app still operates, but with reduced functionality or accuracy. 
There might be alternative SDKs out there, but also with reduced functionality or less accuracy.

e.g. Push Notifications
LowThe SDK’s functionality is more of an afterthought for the app. Its functions can still be important, but they don’t impact the core app functionality.
Good alternatives exist.

e.g Usage analytics
Dependency Guideline

Even before this point, it is important to understand and decide why you need an SDK in the first place. It usually comes down to enabling/allowing you to primarily focus on feature development and delegate the lower-level software to the domain experts instead.

2. UX Should Consider the SDK

While you should rely on the SDK to perform all the heavy lifting it is extremely important that your UX considers the states and output of the SDK and appropriately reflects that to the user. 

Examples (with the Sentiance SDK)

For instance, The Sentiance SDK requires the location permission to be granted in order to operate. Therefore the app’s UX should ensure that the user is presented with clear messaging. And could lead the user through an educational/clear workflow to enable permissions.

In another instance, say, the SDK failed to initialize properly (e.g. due to bad connectivity) it is equally important that the application displays relevant information to the user directing them how to resolve the issue.

Your application should consider the different messages the SDK emits to your application, and you should transform and display these to enhance your user experience.

3. Skim Through the API Documentation

While incorporating an SDK we have usually already decided on how we want to integrate it, and therefore will look for documentation only pertaining to functionalities we intend to use. However, it can be extremely helpful to have a quick skim through all the other features and capabilities that the SDK provides.

SDK developers are always looking to include the right amount of APIs that expose the complete strength of their software. They are also continuously looking at the data (analytics), talking to their clients, talking to application developers, running surveys, etc. to find out how to better their SDK. Chances are, you are using the SDK for the same reasons as most other companies are; which could mean you could learn about additional APIs that other application developers find useful and are using in their applications.

Always skim through the entire API documentation. You never know what you might find!

4. Design the Code Flow

At this point you understood the dependency, designed the right UX, and learned about the complete capabilities of the SDK. So it’s now time to look towards the code (the implementation)!

Think of the SDK as a module one of your teammates has written. You would imagine where to implement it, how much of it to expose to the rest of the codebase, what wrappers to write, how to manage its state, etc.

Ensure the abstractions are very clean in your codebase. Even though it is likely you won’t change the underlying SDK, you always want to do your best to avoid vendor lock-in.

Let’s take the example of Firebase’s Cloud Messaging module:

Example of Firebase’s Cloud Messaging module

Arguably the most important piece of the above diagram, is the block in orange – “Internal Message Interface”. On one side, this code/file-level separation, could expose the interfaces (messaging interfaces) in a manner that is coherent/relevant to the rest of the codebase, while on the other side it communicates with the external SDK using the SDKs APIs. This design provides many benefits, for instance to swap the SDK with another one at any time, while the rest of your codebase would require minimal (maybe none) changes.

5. Log Failures

When an SDK’s feature does not work as expected it will, by design, return an error object or throw an exception. Make sure you act on them appropriately (e.g display a “retry” button to the user), and also log them! 

Logging and going through these errors will give you a deeper understanding of the SDK and will further help you develop your application, and to rely on the SDK with that much more confidence. 

In case you need to go back to an SDK’s developer/owner when something is not working as expected, having logging information can greatly help them figure out the issue faster and get you going again.

End result – faster issue resolution, quicker turnaround in development in case of issues, observability on how the SDK & your app operates, etc.

6. Look for Newer Versions

What a beautiful world it would be if the SDK version you installed today works perfectly till the end of time! Unfortunately, that’s just not how the world works 🤷 SDKs developers are continuously updating the capabilities of the SDK, adapting to newer operating systems, keeping up-to-date with the latest security practices, etc. 

You should not lose out on that! Your application will benefit from it largely. 

You don’t have to read through every CHANGELOG update, but once in a while (say once a quarter maybe) run through the newer versions and see what’s new! 

Maybe keep an eye on the security updates that have been made available!

This leads us to the next and final topic…🥁

7. Feature Requests & Feedback

Never hesitate to ask for feature requests OR let the SDK developers know of a bug you have found. Chances are others developers have asked for similar changes as well. 

The SDK product managers are always looking for the best next set of changes to include in the development roadmap.


The above are some tips on how to best incorporate SDKs in your application development. Read more about the Sentiance SDK and tell us what you think, do you have other tips? 🤔


Sentiance is the most complete provider of motion insights based on mobile sensor data. Contact us to discover how our motion insights can power your application.

Topics:

Scroll to Top