SuperNimbusKnowledge Base

Game Backends: Build vs. Buy (featuring brainCloud)

Introduction

As the games industry trends towards more live-service and multiplayer games, developers and studios are faced with the decision of whether to build their own backends or opt for an “off-the-shelf” game backend platform. In this article, we will discuss the questions and concerns that SuperNimbus’s customers typically present to us, and how we assist them in choosing the right platform for their game’s needs.

We will also highlight one platform in particular: brainCloud. We will examine how brainCloud addresses the features and concerns brought to us by our customers, and explain why we believe it’s a great solution for modern game backends.

Choosing The Right Game Backend

At SuperNimbus, our journey with customers often starts with deciding whether to build a backend from scratch or choose an off-the-shelf solution. Customers might prefer building their own backend as there is often a perceived reduction in cost, or for reasons such as control over code and features, and concerns about third-party services potentially shutting down or changing policies mid-game.

While these concerns are valid, they are usually outweighed by the complexity and scope of building a custom backend. Upon deeper examination of customer requirements, we frequently find that the full extent of creating a bespoke backend is underestimated. This often reveals hidden challenges behind the perceived benefits.

Operational Costs
Custom-built backends can be cheaper to operate because you have full control over the hardware and its deployment. However, this advantage comes with the need to hire specialized dev-ops staff to monitor and maintain your service.

Code & Features
Building from scratch lets you select and optimize features to meet your unique needs. However, you might spend time developing features that existing platforms have already perfected. Moreover, you won’t need to tackle security upgrades, load testing, and automated backups, which often demand more time and resources than expected.

Security & Scaling
Customers often express concerns about the security and scalability of game backend platforms, fearing that platforms serving many apps and players won’t focus on individual needs. However, more customers mean platforms prioritize security and quickly patch issues due to the broader impact potential. Regarding scaling, these platforms are equipped to handle unexpected player surges, as this can occur with any hosted game.

After discussion, most customers recognize that off-the-shelf solutions are advantageous, especially for smaller studios and indie projects, as they help keep costs down. Migration to a custom backend always remains an option later in development when funding is secured.

Backend Building Blocks

The next question to explore with customers is: what features does your game require from a backend? SuperNimbus outlines the following features as essential for a comprehensive game backend service:

Authentication
Authentication is the entry point to your game backend, so it’s vital to choose a service with various authentication options. At a minimum, you may require “device” or anonymous authentication and username/password login.

Anonymous authentication allows players to access your backend without prompting them to enter username, email or password. It’s crucial that the service lets you convert anonymous accounts to “named” ones to preserve player progression once they decide to register.

Additionally, it’s important for your backend to support third-party authentication. This typically includes accounts from platforms like Steam, PlayStation, Switch, or, for mobile games, Google, Meta, or Apple, enabling players to log in seamlessly.

Standard Backend Features
Standard backend features include monetization tools like in-app purchases, storefronts, item catalogs, soft and hard currencies. Meta-game and progression features might encompass leaderboards, achievements, XP, levels, and quests.

Depending on your game’s needs, segments, cohorts, and A/B testing can be crucial. Most backends allow player grouping and distinction, often based on purchasing behavior. With monetization’s significance in modern games, integrating these features into your backend streamlines purchase tracking from third-party platforms. Most backend products offer easy integration with services like Google, Apple, and Steam, facilitating transactions without custom code.

Social Features
Social features enable players to find and interact with each other. Key features include chat and team systems, which facilitate communications like team, lobby, or multiplayer session-specific chat.

Initially, many developers overlook these features for their requirements. However, we’ve found that most of our clients add them later, often due to demands from publishers or community managers.

Multiplayer Features
Multiplayer features can heavily impact the backend choice. For multiplayer titles, a networking solution is essential, whether it’s peer-to-peer (P2P), dedicated servers, or asynchronous networking for turn-based games.

While many backend products offer these solutions out of the box, customers often prefer integrating with dedicated services for networking. Therefore, a key requirement is having your backend efficiently group players into multiplayer sessions and seamlessly hand them over to your multiplayer solution. Matchmaking and lobbies are crucial here. Matchmaking randomly pairs players to start a session, while lobbies can be searched for, or created by players who can invite friends to custom sessions.

Cloud Saves
Saving player data to the backend may have various requirements. The most straightforward is saving player progression, which might involve directly uploading a save file to the backend or using more customized methods like updating JSON files in the database.

Many backends offer simpler options, such as saving player stats or configuration settings. These should work without custom configuration and are faster, and more scalable than database saves or file uploads/downloads.

It’s important to consider a variety of options, as project scope may change. Speed and scalability are crucial as an effective solution in development may underperform as your player base grows.

Configure, Combine & Customize
For SuperNimbus, one crucial aspect when assessing a backend is its ability to adapt to evolving game requirements. It’s uncommon for a product to satisfy all current feature needs and as the game evolves, simple features may become too complex for the existing backend capabilities.

Most backend platforms offer configuration and customization options, allowing for tweaking, extending functionality, and combining features for greater flexibility. Another key feature is the support for custom scripts. This allows you to create scripts that interact with existing features via APIs and access player data, enabling decision-making based on game-state or profiles. 

Even more powerful is the ability to work with the backend’s database so you can make queries to player data and load and manipulate player data to fit your needs.

We focus on flexibility in three areas:

If a backend meets most of the customer needs but lacks one crucial feature, the ability to create it with custom scripts can be decisive in making the decision on which platform to choose.

Pricing Structure

Game backend platforms vary in pricing models, often reflecting service delivery and customer expectations. Models include variations such as fixed monthly fees, usage tiers, revenue-share models and API-based pricing. Many platforms combine these models to offer better deals at different stages of a game’s lifecycle or based on usage levels.

Some platforms require contacting their sales team to determine pricing, and those offering various pricing structures may also provide enterprise options needing custom agreements. Given the complexity of these models and the importance of this aspect of the platform to our customers, SuperNimbus strives to clarify pricing for customers as much as possible, but ultimately we encourage them to contact the platform’s sales team to ensure the model fits their needs.

We’ll cover brainCloud’s specific pricing model in a dedicated section below.

Developer Support

Once customers are satisfied with the pricing, development costs, and features of the backend platforms they’re considering, the next consideration is the support offered to developers.

Support options, like pricing can be complex. Some platforms provide tiered models, with a basic free tier and higher tiers available as needed. Higher support levels might only be available with enterprise agreements, directing developers to documentation and public forums for queries instead.

This decision can be challenging as developers often don’t know what support level they need early on. Investing in higher tiers prematurely may incur extra costs. Starting with free support, if available, allows developers to gauge their needs and evaluate the value of moving to higher tiers later.

We will examine brainCloud’s support options in a dedicated section below.

Simplifying Backend Challenges

Having explored the typical features required from a backend product, we will now briefly discuss additional advantages an off-the-shelf backend offers to developers, studios, and publishers. These considerations are crucial when deciding whether to build your own backend or use a preexisting solution.

Cost Reduction & Accelerated Development Time
Using an off-the-shelf backend can significantly reduce costs and development time. It eliminates the need to develop, test, debug, and scale features internally, freeing up resources for enhancing the game’s fun factor. These platforms handle complex infrastructure deployment, integrate content delivery networks (CDNs) for images, DLC and other downloadable assets, and provide SDKs for secure client communication. The hidden costs of maintaining features such as automated backups, database selection, and customer support tools are significant time-sinks that off-the-shelf solutions address.

Documentation & Knowledge Share
For studios and publishers considering a backend for multiple titles, a key advantage of off-the-shelf platforms is their extensive onboarding preparation. These platforms offer comprehensive documentation for SDKs, tutorials, client APIs, and feature configurations, facilitating rapid onboarding for new developers and the initiation of new projects. This set up also allows for easy integration of existing code across projects that share the same backend.

Additionally, these platforms typically provide forums for developers to share solutions or address issues, along with developer support and guidance from platform engineers. This collaborative environment helps teams efficiently configure features and resolve challenges.

Get Started Quickly
At SuperNimbus, clients often request custom backends, even understanding the associated overheads and costs. In such cases, we sometimes recommend starting with an off-the-shelf product. With existing infrastructure and features, developers can focus on the game, ironing out backend needs with minimal upfront costs. Migration to a custom solution can occur later when ready.

This approach benefits studios with multiple products as well. Developers can begin with minimal costs, meeting current requirements, and adapt the backend as project scope evolves.

Working With brainCloud

Now that we’ve discussed the advantages of using an off-the-shelf product, we’ll dive into a specific solution we’ve worked with for years: brainCloud.

While brainCloud offers an extensive feature list, this article will focus on the basics of the essential features highlighted in the introduction. Detailed documentation is available for all features, and we will link to these resources for further reading where possible.

Getting Players Online

Connecting your players to brainCloud is straightforward and only takes a few minutes. You will first need to download the correct SDK for your client. There are tutorials for each SDK you are using and how to install them is outlined in these docs but also for beginners brainCloud “Bootcamp” video tutorial series for Unreal, Unity and Godot.

After integrating brainCloud with your client, the first step to getting your players online is player authentication. We’ll quickly explore the fastest method: Anonymous Authentication. Since set up varies by game engine and platform, we won’t provide specific instructions. However, once the brainCloud Wrapper has been initialized, you can authenticate with a simple call to the backend.

_bcWrapper.AuthenticateAnonymous(successCallback, failureCallback);

If you print the successCallback response text you will see a JSON payload containing basic information about your new player’s profile.

The brainCloud Portal

With our first player registered on brainCloud, let’s explore some features in the brainCloud Portal, starting by searching for the player we just created.

Exploring User Accounts
You can search for players by clicking on the “User” tab on the left-hand-side menu in your brainCloud Portal.

If you are using a completely new app for this example only one player will appear in the “Recently Active” tab. We have an app with some activity so we can see a list of users in the image below.

You can use the “Search” tab to find a player by username or profile ID. However, we’ll skip this part for now, as the same options are available when brainCloud returns search results that way.

If we click on any of those players it will show the player’s account summary on the right-hand side.

And if we click on the “Go To User” button in the right-hand corner we will be able to see a breakdown of all the player’s basic account information.

You can also see that we can login as this player from here. Once logged in as this player we can send requests to the backend on their behalf. This is especially useful for debugging issues that might be reported by players but only reproducible on a single account.

You will also see that there are some menus and drop-down which appear for this player on the left-hand side menu of the portal.

These menus contain all additional information about this player, for example, the currency gained and lost by the player over time.

There are also other useful player details like logs, statistics, files, inventory, transactions, etc, available in these menus which can help during development, debugging and for live-ops once the game has been launched.

Feature Configuration

Many of the features we outlined in the previous section first require some configuration and set up from the brainCloud Portal before players can interact with them. We do this from the “Design” tab of the Portal on the left-hand side menu.

You’ll notice that brainCloud’s features are organized into groups and sub-menus, with each group revealing additional features and sub-categories. To begin, we will configure a simple Leaderboard.

Select the “Leaderboards” sub-menu and then click on the “Leaderboard Configs” option, then click on the “New Leaderboard Config” button on the top right corner of the Portal and give your new Leaderboard an ID. We won’t go into detail about all these Leaderboard settings but you can read more about them here.

And that’s it!

We now have a Leaderboard set up to accept a player’s highest score (Leaderboards Type HIGH_LOW).

We will look at posting scores to this Leaderboard in another section below.

Combining Features

We’ve seen an example of how to set up a simple feature like a Leaderboard using the brainCloud Portal, but we can also do some more complicated configuration. To demonstrate this we create a player progress & reward system by combining the following out-of-the-box features:

Virtual Currency
We’ll start by creating our Virtual Currency. You’ll find the Virtual Currency configuration option under the “Marketplace” sub-menu.

The example game we are working with already has the three Virtual Currencies configured as shown above, but you can create any currencies you would like.

Achievements
Next we will create our Achievements. You can find the Achievements config in the “Gamification” sub-menu.

Click on the “Create” button in the top right corner of the portal to create a new Achievement.

Setting up Achievements is largely customizable, but for this example, we’ll create three achievements awarded to players at levels 2, 3, and 5.

You can also see that you may add images to Achievements in brainCloud, however, this is not necessary in order for the Achievement to work. You may also link these brainCloud Achievements with Achievements used for 3rd party integrations. Doing this will trigger the Achievement to be delivered to players on those platforms at the same time.

XP Levels
Now that our Achievements and Virtual Currencies are ready we can create our level progression tree by clicking on the “Gamification” sub-menu and selecting the “XP Levels” option.

First we will create our starting level with zero XP points. That will ensure that our players start at level 1 instead of level 0.

Now lets create the second level and add the Achievement and the reward.

For the rest of the level tree you can see how we set this up.

Notice that brainCloud visualizes the level progression for us here which is very useful for tweaking the level progression curve.

API Explorer

Now that we have our level progression curve configured, let’s see how we can test this.

Typically, players earn XP in-game by performing actions like defeating enemies or completing tasks. However, you can also test your setup from the Portal before writing any client-side code.

To do this, go to the “Cloud Code” sub-menu and click on the API Explorer option.

From here, we can test any APIs available using brainCloud. First, we need to authenticate a user on whose behalf we’re performing this request. The brainCloud Portal automatically fills out a JSON payload for this default authentication request, creating a test player based on our Portal login details.

Go ahead and click on the blue “Execute” button. You’ll see a JSON response with your player details.

In order to grant XP to our player we need to use the IncrementExperiencePoints API call from the PlayerStatistics Service.

We are going to test this by granting 999 XP to see what happens. Remember that the player won’t level up until they hit 1000 XP so for this first call, no rewards will be granted.

Execute the request and you should see the following response.

Next, change the “xp_points” parameter to 1 and execute the request again. You should see additional updates in the response JSON indicating that you were granted some Virtual Currency and an Achievement.

Perfect!
You can test the rest of the level progression yourself using the same API.

This example demonstrates how you can combine out-of-the-box features to create more complex systems for your game. Many brainCloud features can be integrated in various ways like this, so enjoy exploring the possibilities.

Note
In the example above, we explored creating a custom progress and reward system by combining existing brainCloud features through the portal. If this was helpful for your game, consider exploring brainCloud’s Items, Quests, Milestones and Statistics features. These features can be combined with what we just saw to create even deeper player progression and reward systems and we always find some use for them in the games we work on.

App Dashboard

We’ve explored some basics of using the brainCloud Portal to create and configure features your game might need. Before concluding our brief summary of the brainCloud Portal, let’s take a quick look at the statistics and analytics summaries that cover your app’s performance.

Above is an example of an app’s landing page, showing details about daily active users, API usage counts, DAU, and a history of connected users over the past three days. This dashboard provides a quick overview of your game’s activity. Additionally, there are other analytics and reporting dashboards available in the “Reports” menu on the left-hand side panel of the portal. By exploring the “Analytics” sub-menu, you can access dashboards for…

Breakdown of players by country.

Your game’s revenue from in-app purchases.

Store performance.

Player Retention Statistics.

The information for these dashboards is automatically collected by the brainCloud platform without any additional setup from developers, and it is provided for free, making it an extremely useful set of tools.

Client Side APIs

At the beginning of this section, we integrated brainCloud into our client and authenticated our first player. Let’s continue from there and explore how brainCloud Client APIs work.

brainCloud offers a comprehensive list of Client APIs linked to various platform features. Let’s examine how we can utilize some of the features previously mentioned as essential for a game backend platform.

Leaderboards
Although leaderboards are a standard feature for a game backend platform, developers often need significant flexibility to set them up according to their specific requirements. There is detailed information on how leaderboards function and the available APIs here.

To start with the basics, you can use the PostScoreToLeaderboard API call for your player to post a score to a Leaderboard. All you need for this is the leaderboard ID for the Leaderboard we created earlier and the score you want to post.

_brainCloudWrapper.LeaderboardService.PostScoreToLeaderboard(leaderboardId, score);

To verify that your leaderboard and client code are working, you can view all posts on your leaderboard from the brainCloud Portal. Navigate to the “Leaderboards” submenu, click on “Leaderboard Configs,” select your leaderboard, and then click the “View Scores” button in the top right corner of the Portal.

Since this is the first time a player has posted to this Leaderboard, you will only see a single rank listed.

The next thing you’ll want to do is get a list of all scores from the Leaderboard and view your player’s rank on the Leaderboard.

This is easily done by calling GetGlobalLeaderboardView using the leaderboard ID from earlier.


_brainCloudWrapper.LeaderboardService.GetGlobalLeaderboardView(leaderboardId, “HIGH_TO_LOW”, 0, 10);

The above request will return the player’s current rank at the top of the list and 10 ranks below them on the Leaderboard.

Asynchronous APIs

Most features and their client APIs in brainCloud use a synchronous request-response flow. However, certain features, like Chat and Matchmaking, may require input from other players or server events before returning the necessary information. In such cases, the client needs Real-Time Tech (RTT) enabled for their app. RTT supports various multiplayer features and incurs an additional cost.

Chat
Chat is a simple example where asynchronous APIs are beneficial. These systems let you post messages to the backend for others to see without constantly checking for new messages. Instead, you can “listen” for messages, receiving notifications asynchronously when new ones arrive.

With brainCloud, you can also listen to specific “Channels,” allowing you to receive updates for chosen chat channels such as public or private chats among friends or groups. In order to listen to a channel we first need to register the RTTChatCallback listener and then call the ChannelConnect API. Your client will automatically receive notifications as messages arrive.

Lobbies
Lobbies are also referred to as “Online Matchmaking” by brainCloud and these represent the standard matchmaking process you would be familiar with from multiplayer games, where players search and join matches with random players. However, brainCloud’s Lobbies also support alternative forms of matchmaking, such as team-based or friend-focused matchmaking/lobbies, and in addition, you can create custom filters to gain finer control over player matches.

To receive notifications for matchmaking progress, you must register the RTTLobbyCallback listener before you can receive notifications. You can then use APIs like FindOrCreateLobby to initiate online matchmaking. Notifications are automatically sent to your client when players join, leave, or when the match reaches capacity. More details on Lobbies and the matchmaking process can be found here.

Note
brainCloud also supports an “offline” matchmaking feature which does not need RTT to work. This kind of matchmaking is used for games like Clash of Clans and works synchronously.

Cloud Scripts

Now that we have taken a look at some of the things you can use out-of-the-box with brainCloud, let’s next take a look at how we might be able to create our own features using custom scripts.

In this example, we focus on a level progression and reward system similar to one we discussed earlier. At SuperNimbus, clients often request that we create a mechanism allowing players to see how much XP they need to reach the next level and what rewards await them. This feature can be used to track progress, trigger events, or visualize XP progression through a bar or similar UI element.

We will create a custom script which will first get the player’s current XP and then we’ll call another API internally to get the XP for the next level and return the difference.

We can begin by clicking on the “Cloud Code” sub-menu and selecting the “Scripts” option.

Click the plus button highlighted in the image above to create a new script. You can leave most settings as their default. If you’re interested in learning more about these options, you can read about writing custom scripts here. Ensure that your script is configured as shown in the image below and click “Create”.

Once the script has been created you will see some of the details of the script and a new window in the Portal where we can edit our code.

Cloud Code Bridge & Proxy Services

We can write our own code using custom scripts, but we also have access to internal brainCloud services using the brainCloud bridge. Using the bridge we then gain use of proxies for each of the service categories which brainCloud groups its APIs under. We’ve already seen this when testing out the API explorer and the client APIs, but there are also some APIs available through custom scripts that are otherwise not available.

The two proxy services we are going to use will be the Gamification proxy service and the Player Stats proxy service. You can see a list of all proxies available using the bridge here.

We can break the code down into the following steps:

1. Fetch Player’s Current XP

    1. Fetch the Gamification proxy service.
    2. Call ReadAllGamification API.
    3. Store player’s current XP.
    4. Handle errors.

2. Fetch XP & Rewards For Next Level

    1. Fetch the Player Statistics proxy service.
    2. Call GetNextExperianceLevel API.
    3. Calculate XP to the next level.
    4. Add data to the response.
    5. Handle errors.

3. Return response payload.

To test our script, click the “Debug” button at the top right of the script editor. Ensure you save your script before proceeding. Click the “Quick Auth” button to authenticate using the test user we used previously, and then click the green “Execute” button.

And that’s it!
We  can now return the XP needed to reach the next level, as well as the name of the level and the rewards.

This is just a simple example, but it hopefully demonstrates how we can use custom scripts and out-of-the-box APIs to create functionality that brainCloud doesn’t offer by default and how powerful that can be.

Before proceeding, let’s quickly explore some additional features related to custom scripts and cloud code.

API Hooks
API Hooks allow us to execute custom scripts before or after Client APIs, which can be very useful for extending the functionality of existing features in brainCloud. For instance, based on the level progression example we discussed earlier, you might want to return the XP needed to reach the next level immediately upon authentication, eliminating the need for an additional API call afterward.

By using the post-authentication API hook, we can run our GetXPToNextLevel script and, with slight modifications, add those level progression details to the default authentication response.

WebHooks
WebHooks allow you to trigger cloud code scripts from an external service. This is very important if you want to integrate brainCloud with existing 3rd party services.

API Blocking
Since brainCloud’s documentation is publicly accessible, many customers worry that unwanted APIs might be exposed. A key security feature of brainCloud is the ability to “Block” APIs that aren’t in use, thereby eliminating the risk of unauthorized or malicious use.

Multiplayer

As mentioned in the introduction, multiplayer networking features encompass a variety of services and technologies. brainCloud offers two types of native multiplayer services. The simplest is a Relay Server, which allows players to send and receive real-time messages without any server-side logic. Room Servers, on the other hand, enable you to launch server instances on-demand for session-based multiplayer games using Docker images, allowing for customized server logic.

A significant advantage of using brainCloud for multiplayer services is its capability to handle the launching and provisioning of resources. However, if your game requires more dedicated resources, or if you wish to retain control over your dedicated hosts while still utilizing brainCloud as your backend, brainCloud integrates with AWS GameLift and Edgegap solutions. It also supports integration with custom third-party server managers, offering endpoints for external servers to connect to your brainCloud backend.

These features can be configured from the “Servers” menu in the Portal, and you can learn more about them here.

The brainCloud Lobbies feature we mentioned in the previous section integrates with many of these multiplayer services allowing you to easily group players together into multiplayer sessions from within the brainCloud ecosystem.

brainCloud also has some excellent resources for monitoring some server-related components. The Server Monitor dashboard allows you to view the current usage of your server instances and their status. This is very useful for monitoring the health of your multiplayer hosts.

The Server Monitor dashboard allows you to view the current usage of your server instances and their status. This is very useful for monitoring the health of your multiplayer hosts.

The Matchmaking Monitor allows you to view statistics related to matchmaking and lobbies, highlighting the average matchmaking time. This insight is invaluable for developers of multiplayer games, as complex matchmaking filters or custom scripts can slow down the matchmaking during peak usage. Having detailed insight into matchmaking makes it easier to identify and debug such issues.

Other Features

This article covers only a small subset of the features available with brainCloud. Detailing each feature would take considerable time, but we want to briefly highlight some additional features brainCloud offers which we at SuperNimbus think are really useful and a little cool.

Store, Items, IAP & Promotions
As mentioned in the introduction, In-App Purchase (IAP) and monetization features are essential for any modern backend. While creating custom items, storefronts, and IAP integrations is never impossible, it can be quite complex. Therefore, at SuperNimbus, the most important factor is how these features integrate and interact to provide flexibility.

brainCloud provides extensive configurability for items and monetization. Items integrate with Item Catalogs, Products, Virtual Currencies and even a Promotions feature which allows Items to be marked for sale and enables producers to run campaigns and sales from within the brainCloud Portal. Additionally, out-of-the-box APIs are available for trading/gifting items and there is also Redemption Codes feature for external marketing campaigns.

Custom Entities
Custom Entities in brainCloud allow you to create your own MongoDB NoSQL collections. You can index and query them as desired to support the unique data models your custom features require. Custom Entities provide exceptional flexibility and scalability, especially when combined with custom scripts, allowing you to create exactly what you need.

In addition to Custom Entities, there are versions of this API for user-specific records (User Entities), group/team-specific records (Group Entities), and records accessible to all users (Global Entities). These non-custom entities are available at no extra cost, and often custom features can be implemented using these alternatives instead of Custom Entities.

CDN
SuperNimbus have worked on several projects where the customer required the ability to upload and download files from their backend. brainCloud has User Files which can be used for user-generated content, and Global Files for something like downloadable content.

Integrations
Something that sets brainCloud apart from other game backend platforms we work with is its wide range of options for integrating external tools and third-party services into your backend, if needed. In many cases, brainCloud has already established these integrations for you.

Under the integrations menu there are a number of services that you can work with out-of-the-box. Some of our favorites are:

No matter what project we start working on, it seems we always end up integrating these services at some point in the project, so having them available without any custom coding is a great help. You can read more about integrations here.

Pricing

As mentioned in the introduction, pricing is often a primary concern for our customers when choosing a game backend platform. In this section, we will explore brainCloud’s approach to pricing, the rationale behind their pricing model, and what it means for developers.

What Does “Pay For What You Use” Mean?

brainCloud employs a “Pay For What You Use” pricing model, where costs to developers align with their usage of the platform. This differs from flat fee or revenue-share models, as it aims to provide a fair price based on actual use.

This approach also underscores brainCloud’s commitment to the continuation of the platform. By ensuring that operational costs align with customer expenses, brainCloud can keep their platform operational and remain viable for as long as there are players playing without incurring infrastructure overheads becoming a burden on the platform. Paul Winterhalder, discusses this ethos in detail in an article posted back in 2015 here, and is worth reading to understand brainCloud’s perspective on pricing.

The main points of this pricing model can be summarized as follows:

Free Development
When you create a game on brainCloud, you gain access to all “Core Features” at no additional charge.

However, features like Hosting and Custom Entities are disabled by default and require enabling or a billing plan upgrade.

While these additional features aren’t available in free development, brainCloud offers a “Development Plus” plan, enabling them for a small monthly fee of $5 / month.

This allows you to explore these features during development with minimal cost and switch back to the free model if you find you don’t need those features before going live.

API Based Usage
While brainCloud offers “Pay For What You Use” pricing, we sometimes need to advise customers on the difference between the standard plan and other plans offered by brainCloud. 

The “Pay For What You Use” model monitors API usage; for instance, on the standard plan, you might pay ~$10 for 1 million API calls per month. However, this plan includes 6 million API calls monthly, so additional costs arise only if usage exceeds this.

The combination of monthly plans and “Pay For What You Use” ensures your game isn’t throttled if usage spikes unexpectedly, such as during promotions. You can increase your plan as needed, receiving more free API calls with each upgrade.

And the cost per million API goes down as usage goes up (see chart below).

Reducing Costs

Since brainCloud’s costs are tied to the number of API calls rather than the specific features used, you can design your backend to minimize costs. We encourage developers to consider API-based pricing during backend design.

Here are some considerations for optimizing your API usage:

1. Use Out-Of-The-Box APIs
Whenever possible, use Client APIs instead of custom scripts. While custom scripts offer flexibility and can be tidier for specific needs, each API call within a custom script adds to your total API usage. Client APIs are also optimized by brainCloud themselves so you can be sure they will perform at scale.

An example of this can be seen in the earlier cloud code section. Since there’s already a client API for GetNextExperienceLevel and current XP is returned upon authentication, do we really need a custom script here when the out-of-the-box API provides the necessary information? It might be convenient for the frontend developers in order to load the UI easily, but it is adding unnecessary cost.

2. Combine Features
Whenever possible, combine out-of-the-box features, such as using the level progress system to deliver achievements and rewards. This reduces the number of API calls from the client or custom code needed to integrate individual features. brainCloud support can assist you in advice optimizing this process.

3. Use Custom Scripts For Chatty Interactions
API calls from cloud code scripts cost ½ that from the client. So if your client needs to make 6 API calls at the end of a game session, making them from a script will only cost 3 API counts.

4. Optimize Custom Scripts
When custom scripts are necessary, avoid loading unnecessary data and be mindful of where important, frequently used data is stored. Minimize API calls in custom scripts, as each call counts ½ point toward your total API usage.

5.Don’t Re-invent The Wheel
Many backend developers view the option of a NoSQL database as a way to create a custom data model tailored to their needs. However, remember that Custom Entities incur additional usage costs and require custom scripts. Even with indexing, they may not be as optimized and battle-tested as brainCloud’s standard APIs.

Support

We’ve already discussed many components of brainCloud and its pricing structure. Lastly, let’s touch on brainCloud’s support offering. brainCloud maintains a straightforward support model: support is free for all Public BaaS customers!  (Note that tiers with additional costs and higher-level SLAs are available for private deployment licensees.) You can raise issues and questions with brainCloud directly in two ways:

  1. From the Portal, using the icon located in the top right corner.

2. From their documentation site, using the icon located in the bottom right corner.

In addition to direct support, brainCloud offers a forum where you can raise questions or search for similar issues you might encounter. You can view their forums here and you can also view all updates from brainCloud here.

Automated Monitoring

One feature of brainCloud that we truly appreciate is their automated monitoring and alerts. Despite our best knowledge and experience with the platform, mistakes or suboptimal configurations can occur.

If brainCloud detects an issue, such as a poorly performing custom database query, they will email you with details about the code and query involved, along with support and suggestions for improvement. This is a free service and is invaluable to developers, as queries that seem efficient during development may slow down your backend as your player base grows or as usage patterns change unexpectedly.

Who Is brainCloud For?

Having explored the diverse features and technical components of the brainCloud platform, let’s examine the types of individuals and roles within game development that might find brainCloud particularly useful. We’ll also highlight which aspects of the platform are most important for them and how brainCloud addresses their specific needs.

Indies

SuperNimbus frequently collaborates with indie developers, and we consistently recommend platforms like brainCloud to them. The “Pay For What You Use” pricing model and absence of development costs make brainCloud an obvious choice for indies. Its wide range of features allows developers to focus less on backend development as their game’s needs evolve.

With quick-to-integrate SDKs, numerous out-of-the-box client APIs, and readily configurable cross-platform play, brainCloud simplifies the development process. Our advice to indie developers remains consistent: focus on making your game enjoyable, and brainCloud will provide the necessary features when the time comes.

Studios

For larger or more experienced teams and projects, developer concerns shift towards more technical issues beyond cost, features, or time and focusing instead on backups, deployment, and user access to backend configuration, code, and the Portal.

Checkpoints facilitate backups of your backend configuration, and when it’s time for deployment, several options are available. You can deploy between apps, enabling developers to establish a deployment pipeline across development, staging, and production environments.

Studios employ more than just programmers. Product management and Support (CSR) resources need additional features such as analytics, pricing controls, user troubleshooting and appropriate access to the title.

brainCloud addresses these concerns by enabling developers to create accounts on the platform. Administrators can organize these accounts into “Teams” and assign granular access and permissions for brainCloud features to team members. Developers can belong to multiple teams, allowing varying levels of access control across different apps, with an additional layer of protection using MFA.

Publishers

As we shift focus from the backend and day-to-day development activities to consider Directors and Publishers, we see their concerns often revolve around the broader picture and the long-term operational lifespan of the game’s backend. These individuals may oversee multiple titles. On this topic, we’ve already discussed how brainCloud can streamline onboarding by enabling code-sharing between games, offering forums, and providing extensive documentation on its features and services.

brainCloud can help save costs by allowing development on free instances, reducing the need for dedicated DevOps staff and tools, and providing complimentary support.

If you plan to work on multiple apps using brainCloud or desire dedicated infrastructure for your company or title, brainCloud offers private deployments.

Opting for a private deployment allows you to distribute costs across all titles operating on your private backend. Private deployments offer lower costing across a library of titles and provide publishers with direct access to the underlying MongoDB data of the instance.

Furthermore, while negotiating a private deployment, your team still has access to the public service, enabling them to begin work on your title for free and seamlessly transition to your private setup once the details are finalized.

One of the aspects we appreciate about brainCloud is its continuous process of upgrading and optimizing the platform. They are not only focused on the infrastructure, portal, APIs, etc, but also regularly roll out entirely new features. This approach benefits those using brainCloud across multiple titles or long development cycles, as it allows them to plan upcoming updates or integrate new features into future titles.

At the time of writing brainCloud has recently released version 5.5 which included a long list of improvements. Checking their release announcement posts reveals just how active the developers are in enhancing their platform.

Migrating To brainCloud

Occasionally, SuperNimbus assists customers looking to migrate from their current backends. This is often driven by the need to reduce costs, particularly for games with long lifecycles, where transitioning to a “Pay For What You Use” platform can be cost-effective during the mid or late stages of the game.

Although migrations can be complex, brainCloud offers Server-to-Server (S2S) APIs, which we’ve successfully used for ETL migrations. Additionally, their JS SDK facilitates bulk file uploads from external CDNs to brainCloud’s CDN for player file migration.

Summary

As the trend towards live-service and multiplayer games grows, developers face the choice between building custom backends or adopting off-the-shelf solutions like brainCloud. 

brainCloud stands out with its support for both mobile and console games, extensive configurability and extensibility, easy integration of third-party services and diverse array of multiplayer, store, item, and API features. Tailored to meet indie developers’ needs due to its cost-effective, “Pay For What You Use” pricing model, brainCloud is also appealing to larger studios due to its flexibility with custom scripts and private deployments. It simplifies development while ensuring scalable, secure, and efficient backend operations.

Jump to section