Yalantis: iOS, Android And Web App Development Company

4 MBaaS Platforms Comparison

Remember our article about what Parse is stuffed with? What happened after I published it, was a technical research in such kind of cloud services done by our Android developer, Oleksii Shliama.

We just wondered what else there was in the field of MBaaS (mobile backend-as-a-service) world and whether Parse is really the most worthwhile solution for the case when you do not have your own server. Having analysed five BaaS platforms, namely Parse, Appcelerator, Applicasa, Kinvey and Kumulos, we came to very interesting conclusions that I am sure will help make a decision about what cloud backend service to entrust your project to. So let’s compare some MBaaS platforms.

BaaS platforms comparison for Android

BaaS. What is this?

Platforms that perform the role of BaaS are prepared cloud server infrastructures that offer their backend job for most types of applications. This allows developers, startups and large companies to win time and money and instead of developing a server, focus more on the app’s functionality, its promotion and improvement of the user experience. What exactly looks attractive in BaaS:

  • custom objects and relations between them
  • file storage 
  • standard ready made requests to the data
  • registration out of the box + integration with Google+, Twitter, Facebook, etc.
  • push notifications
  • in-app purchases
  • integration with multiple operation systems
  • geolocation
  • analytics
  • subscription upgrade when the app grows (no need to buy extra hardware)
  • you spend 2-3 days to figure out the documentation and screw the whole thing to the app.

For the record

As I have already mentioned, in the scope of our technical research were five bright representatives of MBaaS, but...while we were experimenting, Applicasa decided to shift its focus and become something we, as an app development company, cannot take advantage of. Specifically, they are now targeting game developers. Are you a game developer?

I bet Applicasa can provide everything that can make you happy. Unfortunately, it does not concern us as we do not provide game apps development services. Applicasa must have changed for the reason of profitability and growing competition in the BaaS market, which makes it hard to keep being in the first rows.

As Ty Amell, the CEO of StackMob (another cloud service that learned BaaS hard way) said, when they switched their platform to a marketplace targeted toward enterprise customers: «The dirty secret with backends-as-a-service is that it takes a lot of time and money, especially when you’re talking about enterprise. It takes a lot of time to become profitable.»

PayPal bought StackMob assuming with BaaS team they «...will move even faster in creating, testing and deploying products that aim to transform payments for customers around the world». This means StackMob is going to keep being focused on developers, but only those interested in creating payment solutions.

Read also: Real estate mobile applications development

MBaaS cloud platforms comparison

Even though Applicasa and StackMob are not going to be covered in this article, Parse, Appcelerator, Kinvey and Kumulos still have stuff to compare and analyse. So here are the results of Oleksii’s work:

Documentation intelligibility

Just at the first sight at those four platforms, I can say that they all have similarly built admin panels — pretty convenient and easily understandable. As for documentation, Parse is absolutely the winner, while Kumulos is the opposite. Scarce one page documentation is not something called to simplify developer’s life and speed up the development — just what BaaS solution implies. As for Appcelerator and Kinvey, they have good enough documentation but still not as good as Parse.

How to connect an app to the MBaaS services

Parse and Kinvey offer the easiest way to connect their services. All you need to do is register and create a backend. With easy graphic interface, backend creation comes down to making the tables you need and identifying the type of the data stored. Then you download the library, connect it to the app and initialize the operation with one line, passing there the application context and keys taken from the admin panel (unique for each app).

NOTE: With Parse you also need to initialize each table you create in the backend.

I created an object Toy that contains a picture and a name for all the four backends. Here ya go:

/** Parse */

Parse.initialize(getApplicationContext(), "7iKM0tZLPedawdawdCQkYt83038qrLS0U1weO5tL", "ntJt77xNVuBB70fUpWVjUqOe1xDcyZawdwd7NZ");
/** Kinvey */
Client kinveyClient = new Client.Builder("kid_TVMdaWN529", "b0d33288a9a54e1awd92779eab4d4ff9", getApplicationContext()).build();
/** Appcelerator */

ACSClient acs = new ACSClient("wKBtVPCRjkfaoawdxPfzzADOZx8gdM3fj", getApplicationContext());
/** Kumulos */
Kumulos.initWithAPIKeyAndSecretKey("wd5mp6807sjw8qadwd5cpds0jqrn7kb", "5h1yawdwk", getApplicationContext());

User Registration

Parse and Kinvey are pretty similar in this relation. User registration with these services goes like clockwork without any troubles. We create a user by passing name, password, email, etc. to the appropriate method and specify the Callback that will return Success or Failure. Login and logout is implemented the same way — we pass required user data and receive the response.

Here is an example of Parse login:

User.loginUser(login, password, new LiCallback.LiCallbackUser() {
           public void onSuccessfull(LiRequestConst.RequestAction action) {
               // success
           public void onFailure(LiRequestConst.RequestAction action, LiErrorHandler error) {
              // failure

Appcelerator has many functions and a huge documentation, which can beat your brain out. The thing is, Appcelerator was created especially for working with Titanium SDK and in order to use it on pure Android you will need to do some hand work. For example, they don’t have asynchronous work implemented and you will have to do it yourself. In contrast, other services have Callbacks and you don’t even think about asynchronous issues. Here is a piece of code that registers a user (not asynchronous, i.e. it blocks UI):

HashMap<String, Object> dataMap = new HashMap<>();
dataMap.put("username", login);
dataMap.put("password", password);
dataMap.put("password_confirmation", password);
try {
   CCResponse response = App.acs.sendRequest("users/create.json", CCRequestMethod.POST, dataMap, false);
   if (response.getMeta().getCode() == 200) {// HTTP status codes
       // success
   } else {}
       // error
} catch (ACSClientError | IOException e) {

With Kumulos you have to create not only models / tables yourself, but also methods to manage them. In other words, take your coding machine and write registration, login logic and the rest using your own hands.

NOTE: It is not that difficult! Everything has graphic interface and clear descriptions of what to do and how. But the more complicated the logic is, the more time you will need to spend to figure everything out. Kumulos competitors have already put all frequently used methods into the standard stack. So why reinvent a wheel?

Here is a piece of code for Kumulos that describes how you create a user (the method itself and its logic are written on the server):

HashMap<String, String> params = new HashMap<>(); // this is what we send to server
params.put("username", login);
params.put("password", password);
params.put("email", email);
// registerUser - name of the created method
Kumulos.call("registerUser", params, new ResponseHandler() {
   public void didCompleteWithResult(Object result) {
       LinkedHashMap<String, Object> resultArray = (LinkedHashMap<String, Object>) response;
// meanings of different responseCodes are on the website (if you find it)
       if (resultArray.get("responseCode") == 1) {
// success
       }   else {
          // failure



Working with objects (upload, download, delete from the server)

We are going to have two scenarios here. With Parse and Kinvey you create an object and initiate file upload (pictures in our case) to the server (asynchronously). When the upload is complete you can attach the picture (I mean the link to the picture already uploaded to the server) to our object and save the object itself on the server. This is convenient, because in case you properly divide the logic of the upload into large files and just some information, you can reach the effect of «instantaneous upload».

This is exactly what happens in Instagram — while you are writing a description, specifying your location to the picture, it is getting uploaded in the background. So when you click «send», the content that gets sent to the server is only the stuff you have written to attach to your picture, whereas a user thinks Instagram can seriously upload the pics instantaneously.

When you download an object, it’s the same story, only visa versa. You download the object without any files (just links to them) and in case you need the file, it can be downloaded separately, which is also very convenient.

Here is an example of downloading an object according to its id with Kinvey:

AsyncAppData<KinveyToy> myToys = App.kinveyClient.appData("toys", KinveyToy.class);
myToys.getEntity(data.getStringExtra("id"), new KinveyClientCallback<KinveyToy>() {
   public void onSuccess(KinveyToy result) {
       currentToy = result;
       try {
           fos = new FileOutputStream(getTarget());
       } catch (FileNotFoundException e) {

       FileMetaData metaData = new FileMetaData();
       App.kinveyClient.file().download(metaData, fos, new DownloaderProgressListener() {
           public void onSuccess(Void result) {
               Log.i("Kinvey", "successfully downloaded file");
               BitmapFactory.Options options = new BitmapFactory.Options();
               options.inPreferredConfig = Bitmap.Config.ARGB_8888;
               Bitmap toyImage = BitmapFactory.decodeFile(getTarget().getPath(), options);


           public void onFailure(Throwable error) {
               Log.e("Kinvey", "failed to downloaded file.", error);

           public void progressChanged(MediaHttpDownloader downloader) throws IOException {
               Log.i("Kinvey", "progress updated: " + downloader.getDownloadState());
               // any updates to UI widgets must be done on the UI thread

public void onFailure(Throwable error) {
       Toast.makeText(getApplicationContext(), "Error getting toy :c ", Toast.LENGTH_SHORT).show();


Appcelerator and Kumulos have simultaneous upload / download of all the data. With Appcelerator you need to pass the download to a separate flow in order not to block the app performance. For Kumulos you have to encode the picture into the Base64.

Here is an example of uploading an object to the server with Kumulos:

HashMap<String, String> params = new HashMap<>();
       params.put("title", title);
       String base64Photo = Base64.encodeToString(imageData, Base64.DEFAULT); // imageData is byte[] array
       params.put("photo", base64Photo);
       Kumulos.call("createToy", params, new ResponseHandler() {
           public void didCompleteWithResult(Object result) {
               LinkedHashMap<String, Object> resultArray = (LinkedHashMap<String, Object>) response;
               if (resultArray.get("responseCode") == 1) {
                   // success
               }  else {
                   // failure


MBaaS platforms pricing plans

All the services have different packages and free plans limitations:

  • Parse has recently changed its free plan to a more friendly for a developer direction. Now it has unlimited API calls (30req / sec, before it was 1M total), 1M pushes with $0,05 per 1,000 recipients extra and free analytics.
  • With Appcelerator you get up to 250,000 API calls per day, 5M API calls per month, 20 GB of storage for free.
  • Kumulos offers you to pay only $10 per month when your app goes live.
  • And Kinvey free plan includes first 100 active users ($7 for each additional 1k), 5M push notifications per month and 2 GB of storage ($10 for each additional storage 10 GB).

All in all, it’s up to you to decide which plan looks more attractive!

Shall I conclude?

The results of my analysis showed that Parse beats all MBaaS services I chose for my research. Just my vision, do not take it for granted. I awarded Kinvey the second place and Appcelerator is not very far behind. Kumulos, unfortunately looks the worst. The funny thing is, Applicasa, which has been allured by game apps lately, according to my research happened to be very close to Parse in getting the first prize. I mean, it was an absolutely great service for mobile apps! What else can I add?

Choosing the right cloud service may depend on your particular type of an app, operation system (I checked the services for Android specifically), pricing plans and your goals. Let’s say, MVP is a perfect case to play with BaaS but if you have far going plans, it might be a better idea to hire a backend developer and create a sustainable server you can fully trust.

Read also: Event app development in UK