4MBaaS Platforms Comparison

Having analyzed five BaaS platforms, namely Parse, Appcelerator, Applicasa, Kinvey, and Kumulos, we came to very interesting conclusions that will help you in choosing the right MBaaS. So let’s compare the five best MBaaS platforms that help a lot with backend development.

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
• files torage
• 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
• geo location
• 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 we have already mentioned, in the scope of our technical research were five bright representatives of MBaaS, but Applicasa decided to shift its focus and become something that 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. 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.

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.

Documentation intelligibility

Just at the first sight at those four platforms, we 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 web 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.

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

/** Parse */

ParseObject.registerSubclass(Toy.class);

Parse.initialize(getApplicationContext(), “7iKM0tZLPedawdawdCQkYt83038qrLS0U1weO5tL”, “ntJt77xNVuBB70fUpWVjUqOe1xDcyZawdwd7NZ”);

/** Kinvey */

Client kinveyClient = newClient.Builder(“kid_TVMdaWN529”, “b0d33288a9a54e1awd92779eab4d4ff9”, getApplicationContext()).build();

/** Appcelerator */

 

ACSClientacs = newACSClient(“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, newLiCallback.LiCallbackUser() {

publicvoidonSuccessfull(LiRequestConst.RequestAction action) {

// success

}

publicvoidonFailure(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 = newHashMap<>();

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) {

e.printStackTrace();

}

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 = newHashMap<>(); // 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, newResponseHandler() {

@Override

publicvoiddidCompleteWithResult(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”), newKinveyClientCallback<KinveyToy>() {

@Override

publicvoidonSuccess(KinveyToy result) {

currentToy = result;

toyTitle.setText(currentToy.getTitle());

try {

fos = newFileOutputStream(getTarget());

} catch (FileNotFoundException e) {

e.printStackTrace();

}

FileMetaDatametaData = newFileMetaData();

metaData.setId(currentToy.getPhoto());

App.kinveyClient.file().download(metaData, fos, newDownloaderProgressListener() {

@Override

publicvoidonSuccess(Void result) {

Log.i(“Kinvey”, “successfully downloaded file”);

BitmapFactory.Options options = newBitmapFactory.Options();

options.inPreferredConfig = Bitmap.Config.ARGB_8888;

Bitmap toyImage = BitmapFactory.decodeFile(getTarget().getPath(), options);

toyPhoto.setImageBitmap(toyImage);

}

@Override

publicvoidonFailure(Throwable error) {

Log.e(“Kinvey”, “failed to downloaded file.”, error);

}

@Override

publicvoidprogressChanged(MediaHttpDownloader downloader)throwsIOException {

Log.i(“Kinvey”, “progress updated: ” + downloader.getDownloadState());

// any updates to UI widgets must be done on the UI thread

}

});

}

 

@Override

publicvoidonFailure(Throwable error) {

Toast.makeText(getApplicationContext(), “Error getting toy :c “, Toast.LENGTH_SHORT).show();

error.printStackTrace();

}

});

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 = newHashMap<>();

params.put(“title”, title);

String base64Photo = Base64.encodeToString(imageData, Base64.DEFAULT); // imageData is byte[] array

params.put(“photo”, base64Photo);

Kumulos.call(“createToy”, params, newResponseHandler() {

@Override

publicvoiddidCompleteWithResult(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.
• AndKinvey 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!

Conclusion

The results of our analysis showed that Parse beats all MBaaS services we chose for this research. We 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 our research happened to be very close to Parse in getting the first prize. It is an absolutely great service for mobile apps!

Choosing the right cloud service may depend on your particular type of an app, operation system (we 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.