Nearly 60% of the global internet traffic is generated by mobile devices. Over 4 billion phones or tablets are regularly connected to the internet and used by around 90% of the people who use the World Wide Web.
As impressive as these stats are, you don’t need them to figure out how much a mobile application could help you grow your business. If you’ve used a smartphone, you know an app can give you a sleek, interactive experience that a website simply can’t provide.
As a business owner, you can take advantage of this user experience to boost brand awareness, expand your reach, and improve conversion and customer retention rates.
However, you first need to make sure you have an app that not only looks good but is functional as well. To make it so, you’ll need a well-designed backend and a solid hosting infrastructure to support it. This is what we’ll be focusing on in today’s article.
What Is a Mobile App Backend, and How Do You Host It?
The frontend is the part of an application that the user sees and interacts with. Through it, people view the app’s content and access the buttons, toggle switches, links, and fields to interact with overlapping features.
Every time a user taps on an app element, they generate a request sent over the internet to the backend, which is responsible for completing a task. The task could involve authentication, saving new profile information, delivering content, processing payments, etc. The same backend is also responsible for pushing updates and notifications and attracting the user’s attention whenever needed.
To do that, the backend relies on three main components:
To complete incoming tasks, the backend needs memory, processing power, and storage. These are all provided by a physical or virtual machine – the app’s backend server. A backend server could also consist of a cluster of machines working together to provide high availability and blistering performance.
When a user creates an account, they generate some data. The same happens when they sign in, place an order, post a comment, etc. All that information must be stored in the app database. Once there, the backend can access and modify it.
API stands for Application Programming Interface. It sits between the frontend and backend, facilitating the communication between the two. Without it, the application would be completely unusable.
Every mobile application requires a different approach to the backend’s design and hosting solution. As you’re building an app used on phones and tablets, you must remember that mobile devices work in different environments with varying networks and operating systems.
While there is no definitive step-by-step guide you can use to create a reliable backend server, you can still follow a few simple rules and best practices that should help you out.
Types of Mobile App Backends and Steps for Building a Reliable Infrastructure
There are two types of mobile app backends
A traditional backend is built from scratch. Your first job is to pick a programming language and implement all the functions you want to see in your application. You’ll likely use a combination of custom code and off-the-shelf libraries.
Building a traditional backend yourself isn’t something you can do in a few hours. It involves writing code and requires a deep understanding of how the individual backend components must work to provide you with the functionality and reliability you’re after.
A traditional backend is self-hosted, meaning you still need to find a suitable web hosting server to develop and deploy on.
Backend as a Service (BaaS)
If you don’t have the skills or time to build everything yourself, you can easily find off-the-shelf backend solutions with most of the functionality required by traditional mobile applications. With some of the platforms (like Firebase), you can enable other, less common features with the help of plugins.
Some of these BaaS solutions are offered under a true as-a-service model, i.e., they are hosted by the provider. So, if you use AWS Amplify, for example, your app’s entire backend infrastructure will be hosted by Amazon.
Naturally, there are self-hosted BaaS platforms. To use such, you would also need to utilize a reliable web server for deployment.
Pros & cons
A traditional backend gives you more freedom to design the app’s supporting infrastructure exactly how you want it. You can configure every component to your exact specifications and implement the features you want according to your needs.
This extra flexibility comes at a price, of course. Building a solid mobile app backend from scratch is a complex process that takes a lot of time and requires some technical skills. You have to factor in this when planning your launch schedule, and if you don’t have the experience to build everything yourself, you’ll need to hire a developer, which will affect your budget.
BaaS solutions aren’t exactly novice-friendly, but they’re less complicated and easier to get used to. Most of them are accompanied by detailed documentation, so more often than not, you can find a quick way out if you get stuck.
There is no right or wrong when picking the approach for building your mobile app backend. You just have to choose based on the nature of your project and its requirements. No two apps are the same, so there’s no pattern you can follow when building the backend. That said, the process should always involve a few key stages:
This stage starts with a deep analysis of the backend and the entire project. You need to determine what the app does, how it works, and who uses it. All this information will show you what sort of requests your backend needs to deal with and what features it must provide.
It’s also a good idea to make projections about the app’s growth. This will help you either embed the required scaling options into your custom backend or pick a BaaS solution that offers them out of the box.
This is the stage where it should all start coming together. Using wireframing tools, you can build a rough outline that serves as a blueprint for the finished app. For the first time, you’ll get a sense of what the application will feel and look like.
The overall layout becomes much clearer, and at this point, you need to decide which features stay in and which will be left out. It’s also at this stage when you start work on your backend. During the prototyping stage, you usually implement only the most basic features. However, you still need to ensure you can interact with the app and get a feel for the user experience.
Creating the backend
With all the information gathered during the previous two stages, you can start building the final version of your app’s backend.
Your first job is to consider the APIs and other components required to implement the desired functionality. You’ll have to determine which ones you can get off the shelf and which you have to develop from scratch. Finally, it’s the matter of putting everything together into a coherent backend system that works with the frontend.
You always have to ensure everything is working properly, which means exhaustively testing every component of your app’s backend. The more issues you fix at this stage, the more refined the user experience (UX) will be when you launch the app. And the better the user experience – the more likely people are to spend time using your application.
UX isn’t the only aspect you should consider during the testing phase. A successful application generates a lot of data, and you must ensure it is well protected. This means identifying your app’s information processing mechanisms, analyzing their operation, and checking them to ensure they work to the highest security standards.
Try to think of every conceivable scenario. If you’re not convinced you can do it on your own, think about hiring an expert to help you out, especially if your app deals with things like payment details or personal information.
Your security tests should also concern your hosting infrastructure. A DDoS attack on your mobile app backend server can bring your entire application down, so it’s essential to ensure your web hosting provider has taken steps to protect you from a possible denial-of-service campaign.
Once you’ve ensured your backend is secure and bug-free, it’s time to deploy it. The steps you take depend on the type of hosting infrastructure you’ve picked during the initial stage of the planning phase.
After you deploy the server (or servers), you have to install all individual components and double-check to ensure they work as expected. Setting up monitoring tools that keep an eye on your server’s health and alert you to any anomalies is also a good idea.
Another thing you should remember is that you’re building an app for mobile devices. Phones and tablets typically have less processing power and memory than desktop computers. Battery usage is another limitation you’ll want to consider, and you have to bear in mind that mobile networks tend to have lower bandwidth and higher latency.
Let’s see how you can work your way around these obstacles.
API Design – The Basics
APIs are ubiquitous. Pretty much every software application you use is connected to a backend server somewhere in the world via an application programming interface.
So, how do you create a good one for your own app?
First, it’s a good idea to familiarize yourself with the different kinds of APIs. The lines aren’t always crystal clear, but in general, every API can be classified according to its audience, architecture, and protocol. Let’s examine the divisions:
Бeing public means that you allow everyone to use the API. You can still require users to create an account or set up a subscription, but you’re not restricting usage to specific devices. If you want to create an app that anyone can download and install freely, your primary API will likely be public.
А private API is reserved for a specific group of people. Only devices that have been granted permission can use it. The data and functionality are proprietary and only accessible to people within the organization that owns it.
Partner APIs sit somewhere in the middle between public and private APIs. They’re not fully open to the public, but they’re not restricted to internal use only, either. Often, they’re used to connect two services.
For example, Amazon has a partner API for businesses that sell on the ecommerce platform. Through it, they can manage orders, payments, inventory, etc., via their own applications.
APIs can also be categorized according to how they organize calls and manage responses. Here are the main types of API architectures:
A monolithic architecture implies a single coherent code base. Changes to one part of this code base automatically affect the rest. Monolithic APIs provide access to complex data sets, so the setup is often compared to a relational database.
The advantages of a monolithic API come down primarily to ease of use, ease of development, and better performance in certain situations. On the flip side, a monolithic architecture could get complex with time, scaling it could be a problem, and adapting it to new software solutions is not always straightforward.
The microservices architecture is a newer concept that revolves around breaking down a software application into multiple separate but interconnected components called microservices. Each microservice has its own logic and purpose.
The setup is very flexible, allowing developers to use a broad range of tools, technologies, and programming languages to set them up. Microservice components can also be scaled individually, making the architecture better equipped to handle large traffic surges. Their independence makes the model more reliable – if one of the components fails, the others remain unaffected, so large sections of your app remain fully functional.
The downside is that microservice APIs are trickier to build and maintain. Things like logging, caching, and performance monitoring could be particularly challenging because of the multitude of components. And because many microservices work simultaneously, you also have more API calls.
A composite API tries to solve the problem posed by microservice APIs by bunching multiple requests into a single call. With this technique, the individual requests can be destined to different API endpoints, but the backend server always processes the queries with a single response.
This means quicker loading times and faster performance, especially for common operations like creating an account. The downside is that not all API protocols are supported, and if something goes wrong, troubleshooting the issue could be a challenge.
A unified API is like a dispatcher that manages the connection between multiple interfaces within the same application. It aggregates requests according to the required data type and sends them to the correct service providers.
Numerous providers can be queried at once, which means that, just like with composite APIs, we have a reduced number of API calls. You can have many different protocols and data models used and delivered at once, making this type of architecture particularly efficient when deployed in complex systems and data sets.
Now that you’ve learned about the structure of an API, it’s time to look at the different protocols application programming interfaces use.
Choosing an API Protocol
The protocol determines how the API connects users to the backend server and how the information is communicated between parties. It’s pivotal for the design of the API, and it will determine how easy or difficult it will be to maintain it in the future. That’s why it’s essential to choose wisely.
Here are the most popular protocols:
REST or RESTful stands for Representational State Transfer, and it’s the most widely known and used API protocol out there. Despite its popularity, it presents several restrictions. RESTful APIs define routes with a URL.
Compared to other protocols, the process is much simpler, but the downside is that REST transmits information only through HTTP. This means that the data it can deliver is limited to text.
There are ways around this limitation. For example, you can specify a content type in the header and deliver media files encoded in either XML or JSON. The protocol’s popularity is a testament to the fact that developers have made it work with different data types. However, you need to be aware of the challenges from the start.
You must also bear in mind that the format of the HTTP transmission is not clearly defined. On the one hand, this means the protocol can easily work on just about any platform. On the other, it requires the API owner and the consumer to agree upon a transmission format. In other words, there’s a bit more preparation to be done if you want to avoid unwanted errors.
With a RESTful API, the requests and calls are made independently of each other, and they work the same regardless of whether they interact with the server, a load balancer, or a proxy. The compatibility between RESTful APIs and popular caching solutions is usually pretty good, as well.
In addition to HTTP, SOAP (or Simple Object Access Protocol) APIs also support TCP and SMTP. They use standardized rules for transmitting data, so the exchanges are more predictable, and the protocol is more suitable for communicating complex data sets.
From that perspective, it looks like a much better, more reliable solution than REST. However, this is not strictly the case. SOAP only works with XML, and the request requirements are more rigid, so in many ways, it’s the more restrictive protocol of the two. SOAP code tends to be more complex and bandwidth-intensive than REST, as well, which isn’t great if you’re building a mobile application.
That’s why developers tend to use SOAP for complex applications, where the focus is on reliability rather than usability or performance.
RPC stands for Remote Procedure Call and is different from the protocols we’ve discussed so far. Instead of a document or a file, RPC APIs return either a confirmation that a function has been triggered or an error message.
Triggering functions on a remote server is not something everyone should be able to do, which is why RPC APIs are rarely public. Usually, they are used for internal purposes where a high level of security is established between the API owner and the consumer.
One of the key steps when choosing an API protocol is researching it carefully and finding out all about the technologies it supports. When examining every protocol, check whether it can be deployed on your operating system and technology stack. Find out which programming languages it supports, and, last but not least, make sure you know which data formats it works with.
But how important is the data format exactly?
Picking the Right Data Format
In an application, the users, database, and third-party services exchange information all the time. This information passes through the various APIs you’ve developed and deployed on your backend. The job of the data format is to ensure all the parties involved in this exchange can recognize and understand the information.
Even the most efficient, well-designed API won’t be useful if you don’t use the correct data format. What’s more, the choice of a proper format can affect your application’s performance and resource usage, so it could be the difference between a streamlined app with excellent user experience and one that drains your battery and takes ages to load.
In general, there are dozens of different data formats, but when it comes to mobile app development, two stand head and shoulders above the rest:
XML stands for Extended Markup Language, and, strictly speaking, it’s not a data format. It’s a markup language that can be used for data storage and transmission. The information is held in tags and encoded according to the XML standard.
The data is organized in a tree structure and is relatively easy to validate. That’s why XML is preferred by developers who need to handle large volumes of information and complex data structures.
The downside of XML is that it is quite complex and difficult to read. The same complexity makes it comparatively slow, and because the format is so old (work on it began in 1996), support for some of the popular development languages is limited.
Data is organized in a key-to-value map, which has its pros and cons. On the one hand, this limits validation options and makes JSON less suitable for large data structures. On the other hand, it improves the performance and lowers the bandwidth usage. JSON also works with pretty much all programming languages, so the chances of a conflict are significantly reduced.
JSON is considered the more suitable format for mobile backend APIs. However, this doesn’t necessarily mean you should pick it without thinking about other options. When you’re making your choice, remember to bear in mind things like the size of your data, the complexity of the application, and the compatibility of the available formats with the software you’re using.
Speeding Up a Mobile App With Caching
Caching is the technique of creating a copy of frequently requested data and storing it in a way that makes retrieval quicker and easier. It’s one of the first solutions people turn to when they want to improve their website loading speeds and works just as well for mobile applications.
In addition to making data retrieval quicker, caching also reduces the number of requests the server needs to process at any given moment, keeping a low load on the backend infrastructure. This means more stable performance even under increased traffic levels and fewer upgrades as your mobile app popularity grows.
Let’s now explore the concept of caching in more detail and see the best practices. We’ll start with the different types of caching.
Types of caching
Caching works because retrieving cached data is faster than waiting for the server to generate it again. You can store such data in several different places, which creates several types of caching:
- Memory caching
When a user requests a particular data entry, a copy of it can be saved in the server’s Random Access Memory (RAM). When another person needs the same information – it’s served straight from the RAM instead of being fetched from the database or the storage device. The performance boost comes from the fact that your operating memory delivers data much more quickly.
- Client-side caching
When a user accesses a file or a data entry from your app, their device can store a copy of it locally. When the user needs the same piece of data again, their smartphone doesn’t need to wait for the server to deliver it again but instead fetches it from the local storage. In addition to improving loading speeds, this type of caching also reduces bandwidth and data usage, so it’s great for mobile apps.
- Network caching
Network caching is another word for what a Content Delivery Network (CDN) does. You have multiple servers situated in data centers all around the world. Copies of your app data are stored on these servers and are served from the location closest to the user. This reduces latency and decreases the distance the files need to travel before they arrive on the user’s device.
All types of caching have their pros and cons. For example, with memory caching, the data still needs to travel between the server and the user’s device.
Data usage stays the same, and the loading times largely depend on the individual user connection. Client-side caching options are often limited, and CDNs only work with static data (i.e., images, media files, CSS stylesheets, etc.). That’s why any successful caching strategy will involve all three types of caching.
You want to serve as much data as possible from the cache. This will ensure that a vast portion of what users see on their screen appears pretty much instantaneously. It will also minimize the number of requests hitting your backend server.
The trouble is, when you make changes to the app (e.g., you update some of the information on one of the pages or a user uploads a new profile picture), you make them on the server. If everything is fetched from the cache, and the requests don’t reach the backend – people won’t see your updates.
The only way to solve this is to replace the old cached data with the new one. The process is known as cache invalidation, and there are several different approaches to it:
- Time-based cache invalidation – you effectively put an expiration date on the cached data. Once it’s passed – the information is refreshed, and all the changes you’ve made between the initial caching and the expiration become available in the cache.
This invalidation method is relatively easy to implement, but to reap its benefits, you must get the expiration period right. If you make it too long, you risk serving old and irrelevant data to users. Make it too short, and you’ll force the backend to use resources to refresh the cache unnecessarily.
- Event-based invalidation – the data in the cache is automatically updated as soon as changes are made to it in the backend. Usually, every record in the backend is associated with a key, which is copied, along with the data, to the cache.
Whenever the data is modified, the key changes, and the old one becomes invalid. This triggers the caching mechanism to refresh the cache.
Configure it correctly, and you’ll eliminate the chances of your mobile app serving outdated information. The downside is that this type of invalidation is trickier to implement and usually takes up more storage.
- Manual purging – the third option is to manually purge the cache whenever you see fit. Caching solutions often allow you to manage the data in your cache, so refreshing it every time you modify your site shouldn’t be a problem.
That being said, this particular method isn’t especially useful if your caching solution also stores data edited by users, and it’s really suitable if you keep static information only.
The caching mechanism you can use depends mainly on your web hosting platform, especially if you use a managed virtual private server, though some hosting providers even offer root access on their VPS machines, meaning you can pick a caching platform of your choice, install it, and configure it to your app’s requirements. While browsing the options, you may stumble upon innovative solutions that can make caching easier and more efficient.
There are, for example, predictive software systems that analyze user interaction with your app and determine which data records they’re most likely to access. They then copy them to the cache in order to have them ready to go as soon as the users request them. This means even faster delivery and efficient use of your cache storage.
Push Notifications and Real-Time Updates
The ability to send push notifications is one of the things that make mobile applications so much more interactive than websites. With them, you have more control over the flow of information between your application and its users.
Get it right, and you can send the correct data to the right people at the right time. Get it wrong, however, and they will likely delete it pretty much immediately.
Let’s look at how push notifications work, what you can use them for, and what you should bear in mind when setting up your real-time update system.
What can you use push notifications for?
Push notifications can be used for all sorts of purposes. How you implement them depends on your project and business plan. We can’t cover all possible scenarios here, but we’ll show you some of the most common ones.
- Abandoned cart reminders – recent studies suggest that, on average, around 7 in 10 people abandon purchases without completing the checkout process. It’s a huge problem for ecommerce businesses of all shapes and sizes, and historical stats show us that a solution is still proving elusive.
That said, if you have a mobile app, you can minimize the cart abandonment rate, at least to some extent, with the help of push notifications.
- Onboarding – getting new users familiar with your application will ensure they know what they’ve downloaded and how to use it. You can highlight key features and give users tips on making the most of your app. Don’t forget to send notifications when you implement new functionality, as well.
- Offers – want to inform people about your Black Friday sale? What better way than to make the phones in their pockets vibrate? In addition to efficiently getting the message across, you have the added flexibility of easily customizing your campaigns and modifying your offers for specific groups of customers.
- Rewards – loyalty points, virtual coins, rewards, and games – are all tricks designed to make people engage with applications for as long as possible. Some users may find them unnecessary, but there are plenty of examples proving that they do work. You do need to remind people to engage with them, though, and there’s no better way to do that than with the occasional push notification.
- Real-time updates – the main job of news outlets is to inform people about important events as soon as they happen. Livescore apps that follow the development of various sporting events across the world also want to update their users on what’s going on during a match.
- Tracking – when they order something online, buyers love to know how far it has come and how long they need to wait until they get it. Using push notifications, you can give them timely updates on what exactly is going on with their shipment. This improves the shopping experience and encourages users to return to your mobile app for their next purchase.
What are the main advantages of push notifications?
There are dozens of scenarios where push notifications can prove valuable. Then again, some of you may be saying that all the tasks mentioned above (as well as many others) can just as successfully be completed with an email or a text message. Indeed, this is true, but push notifications have a few key advantages over traditional mail and SMS alerts.
Let’s check out some of them:
- It’s easier to convince people to enable them – persuading a user to sign up for a newsletter is notoriously difficult. You have a much better chance of getting them to enable push notifications, and you’re more likely to get them to engage with your alerts.
- No fake subscriptions – theoretically, you can require a user to sign up for your newsletter in order to use a particular functionality, but there are a couple of problems with this. First, many people aren’t thrilled with this sort of practice, and you can easily annoy them. Second, nothing can stop them from using a throwaway email address.
By contrast, users are much happier to receive notifications on their phones, and they don’t really have a way of diverting them to another device where they won’t see them.
- They’re easier to see and read – users check their phones dozens of times a day. And every time they do it, they usually see multiple push notifications from various apps. At the very least, they skim through them before swiping them away.
In fairness, many users also open their email inboxes reasonably often. However, when they see many unread messages, they usually delete them without even opening them.
- Instant delivery – as soon as you send your push notification, it immediately appears on the user’s phone. There are no delays caused by the multiple agents transferring your message, and you don’t need to wait for the user to log in to their inbox and check for new emails.
This allows you to instill some urgency into your push notifications and see immediate effects from them. The difference in conversion rates should be obvious when a sale or a promo campaign is ending, and you send one final reminder to get people to check out your app.
- No costs – if you send SMS notifications, you’ll need to pay for them. If you use a newsletter service, you’ll probably be able to get started on a free plan, but once you get over a certain number of subscribers, you’ll have to upgrade to a premium subscription. If you send push notifications, these additional costs can be skipped.
How do push notifications work?
Now that we know what you can do with push notifications, it’s time to see how to set them up.
First, you’ll have to register your app with the different Operating System Push Notification Services (OSPNS) – the service responsible for displaying your alert on users’ devices. Each platform has its OSPNS.
For example, the Apple Push Notification Service (APNS) takes care of the iOS apps, Android applications are handled by Firebase Cloud Messaging (FCM), notifications to Kindle devices are served by Amazon Device Messaging (ADM), etc.
After registering your app, the OSPNS generates a unique token for every installation, which is sent back to your server or VPS. The idea is to build a pool of tokens that identify individual devices and contain certain user information. This is how you can customize your notifications and send alerts to specific people.
You can theoretically use OSPNSs to send push notifications straight to users’ phones. However, this would require you to create and process individual alerts for different platforms. The process could be lengthy, which is hardly ideal, especially if you want to send time-sensitive data.
That’s why you can use a push notification service placed between your backend server and the OSPNSs. Its purpose is to automate many tasks involved in sending a notification, including analyzing the device token and dispatching the notification requests to the correct OSPNS.
There are many services to choose from, each with its own features and integration procedures. Make sure you research them carefully and choose one that is both easy to implement and a good fit for your mobile app.
How do I make the most of my push notifications?
Even after you’ve set everything up, you’re not completely out of the woods. If you want to persuade your mobile app users that your notifications are helpful, you must be careful with them.
There are a few best practices you can stick to:
- Don’t bombard users with requests to enable notifications – far too many developers make the mistake of setting up their apps, so the first thing they display is a popup asking the user to enable push notifications. In some cases, an application’s functionality is tied to alerts, but even if that’s the case, let the user look around before you ask them for permission to ping their phone every now and again.
- Be upfront about what people will receive – notifications may not be quite as irritating as spam emails, but they can still be annoying, and users are becoming increasingly picky when it comes to allowing mobile apps to send alerts. If you want your mobile app on the Good List, you must convince people that your notifications will be useful. Make sure they know what they’ll see and how it will help them make the most of your app.
If your app’s functionality depends on push notifications, let users know what they’ll miss out on if they refuse to enable them. For example, you can set up a welcome tour that explains what the application does and what sort of alerts they can expect.
- Give users an easy opt-out option – it’s all about giving users as much control as possible over what they see. If they enable notifications initially but later decide they want to turn them off – you have to give them the option to do it quickly and easily.
Make sure they can control the different types of alerts, as well. For example, if you run an ecommerce app, you’ll likely send out tracking and order status notifications as well as information about new sales and promos. Give users the ability to disable the promotional alerts while still tracking their purchases and orders.
- Send your notifications at appropriate times of the day – nobody likes to be woken up in the middle of the night to learn about the new virtual coins they can get. Keep an eye on the analytics data, observe users’ time zones, and only send alerts during waking hours.
- Don’t send too many notifications at once – no matter how useful your notifications are, if there are too many of them, they will eventually get on people’s nerves. Make sure you keep users engaged but don’t overdo it. Set a schedule and keep your alerts evenly spread out.
- Keep your notifications relevant to the user – if a user has been browsing your online store several times and only looked at sports shoes, they’re likely interested in buying trainers. Keep a close eye on the analytics data, and tailor your notifications to the specific user. This will ensure better engagement and more sales.
Your app backend server is tasked with ensuring the people on the other side of the screen are who they say they are. It’s not a simple process, and the stakes are quite high because the authentication mechanism is responsible for granting access to end users, app admins, and developers.
Of course, security should be central in all this. The authentication protocols and their implementation could mean the difference between a safe and secure app and one that puts user data at risk.
However, don’t forget that the signup and login forms are among the first things to be displayed. They must be secure but also easy to use.
You have to find a fine balance where your backend delivers maximum security while also sparing users any additional steps or frustrating rules.
Let’s start by peeking under the hood of most authentication systems and checking out how they work.
Types of Authentication
Authenticating a user isn’t as simple as verifying the provided login credentials and granting them access. A lot goes on behind the scenes, and there are several distinct approaches, each with its advantages and disadvantages.
Let’s take a look at the two most popular types of authentication:
- Stateful, or session-based authentication, is renowned for its simple implementation and secure handling of user data. The process starts with the user providing their login credentials. After validating them, the backend server sets up a session and generates a random session ID, which is relayed back to the client.
From now on, every request sent from the client contains the session ID, and when the server receives it, it checks whether it’s valid. If it is – the request is processed.
- Stateless authentication – stateless authentication is also known as token-based authentication. After validating the login data, the backend server generates and cryptographically signs an access token that is sent back to the client. The same token is transferred to the server with every subsequent request and is used for validation.
Several standards are available, but the most commonly used access token format is called JSON Web Token (JWT).
A JWT consists of three parts – header, payload, and signature. The header contains information related to the encryption algorithm used for this session, the payload holds the actual session information, and the signature is the critical component determining whether the token is valid.
JWT is encrypted, and its actual value can only be decrypted by a key stored on the backend server. If the decryption is successful, the authentication system can confirm the token is authentic, and the request goes through.
Pros & Cons
Stateful authentication looks like, by far, the more straightforward option of the two, but it works with a database of active session IDs, so whenever a request comes in, the backend server must run it against the database and see if there’s a match.
On the one hand, this means stateful authentication requires more storage space, and on the other, the additional requests put more load on the server.
It’s also significantly slower. A typical server can decrypt and validate a signature in a stateless token in as little as a millisecond. A database query confirming the authenticity of a session ID takes a lot more.
Stateful authentication doesn’t scale horizontally very well, either. If your entire backend hosting infrastructure consists of a single server, you should have no problems, but if you want to use multiple machines, all of them must be able to access the up-to-date session IDs in the database. Token-based authentication works better in a multi-node environment because it doesn’t require any session data to be replicated across multiple servers.
Session-based authentication has another advantage. With it, you can control the database with the active session IDs. If you notice anything suspicious about one of the users interacting with your app, you can terminate their session prematurely.
That being said, stateless authentication systems are not without their drawbacks. A stateless token holds all the session data, including the user ID and other potentially sensitive information. The exact consequences depend on how the authentication system is built, but it’s safe to say that the threat shouldn’t be discounted.
In a stateless authentication system, every token has its own expiration. Once it’s issued, there’s little you can do to revoke its access to the resources its owner is entitled to use.
Whatever approach you choose, it’s probably not a wise idea to build it yourself. Many proven libraries and solutions can securely handle your app’s authentication system. They can save you time, but more importantly, they will automatically answer many of the tricky questions surrounding the handling and storage of user data.
Password Requirements and Policies
Every time a user signs up, they need to create a password. In theory, it’s their job to pick one that will keep their data secure. If they use something like “123456“, it won’t be your fault when a hacker guesses it and compromises their account.
However, a successful attack on your user won’t do you any good either. Any leaks, regardless of who’s responsible, will damage your app’s reputation, so you want to do everything you can to limit the possibility of a break-in.
You also want to guarantee users will engage with your app without worrying about getting hacked. To do that, you need to encourage users to use strong passwords.
You can theoretically force everyone to pick passwords over 20 characters long with multiple uppercase letters, numbers, and symbols. Protection levels will be improved, but you won’t have much to protect.
Overly strict password requirements can frustrate people and seriously hamper your app’s progress. You need to impose some sort of restrictions, but you have to tread a fine line.
The restrictions you implement should be coordinated with the nature of your service. If you’re running a news app where people register just to be able to comment under articles, the user accounts won’t be full of personal information, so the restrictions you impose don’t need to be too harsh.
On the other hand, if you run an ecommerce business where people can save their credit card data, you need to ensure people take their account security seriously. This means requiring them to create high-entropy passwords to adequately protect their data.
IMPORTANT: There are random password generators and password management tools that can help users create (and keep) their complex passkeys for easy retrieval.
As its name suggests, two-factor authentication (2FA) requires two separate pieces of information before authorizing access to the user account. The first consists of the login credentials picked when signing up, and the second is a temporary code or password either sent to the user via SMS or generated by a special app. Without that code, access is denied.
The idea is that even if hackers steal or guess your password, they won’t be able to sign in to the account because they don’t have physical access to the victim’s phone.
Plenty of online banking apps and services make 2FA mandatory. This is one way to get people to use it, but it’s not always the best. Ideally, you’ll show users the security benefits and let them enable it themselves.
Managed VPS Hosting for Mobile Backends
Your search for a suitable hosting environment for your app’s backend should start at the very beginning of the planning phase.
There are four main factors you need to consider:
- Price – no matter what business you operate, you need to keep a close eye on the margins. In the early stages, they’re usually quite narrow, so try to keep the expenses on a leash. Even after you gain some momentum, you still want to keep the profits at decent levels. What this means is that overspending is highly undesirable.
- Performance – you don’t want to spend weeks and months designing and optimizing your mobile app backend only for its speed to be ruined by a web hosting service that isn’t powerful enough. That’s why, when browsing through the different server setups, you need to shortlist only the ones that will give you sufficient resources to get consistent loading speeds and excellent performance.
- Ease of use – maintaining a mobile app is hard enough on its own, so it’s a good idea to look for a provider that won’t leave you to deal with the complexities of running a hosting server. Ideally, your host’s support team will be responsible for deploying the server, configuring its internals, and maintaining them in perfect working order. Meanwhile, you should have access to a control panel with an intuitive interface for your everyday tasks.
- Adaptability – ideally, the number of people actively using your app will be on a constant upward trajectory. If this happens, you will inevitably exceed the capacity of the hosting service you start with initially.
It’s essential to think ahead and be prepared for this moment. If an upgrade requires migrating to an entirely new hosting service, you could be in unnecessary downtimes and service interruptions. That’s why you’ll ideally look for a service that is flexible enough to handle the extra traffic without requiring you to move tons of data from one server to another.
Keep these factors in mind when browsing the different options, and you’ll be hard-pressed to find a better hosting setup than a managed VPS. Let’s check out the alternatives and see why.
Shared hosting isn’t really suitable for hosting a mobile app backend. They can’t provide you with the performance you’re after and are optimized for website hosting only. As a result, you don’t have the freedom to customize the environment to fit the requirements of a mobile app backend.
With shared hosting out of the way, your options come down to a virtual private server or a dedicated server. The latter used to be the most powerful form of hosting, and it was pretty much the only alternative for a more complex online project.
This type of web hosting gives you access to a powerful physical server that, provided it’s specced correctly, can guarantee excellent speed. Because you have the entire machine to yourself, you can configure it to your app’s exact specifications. You are the only user on the server, so no need to worry about any other clients interfering with its performance or security.
It’s not all good news, though. Dedicated hosting has always been quite expensive. Even the cheapest solutions still go into the 100s of dollars monthly, and although they may offer the speed you’re looking for right now, this will not be the case forever. As your app becomes more complex and popular, you’ll need to upgrade to a more powerful machine, and this is when you’ll face the setup’s true Achilles heel.
When your dedicated machine no longer meets your mobile app demands, you need to swap it for a more powerful one. This means migrating the entire backend from one server to another – a complex process that takes time and could easily go wrong.
So, a dedicated server can work as a hosting solution for your backend, but it’s a costly option that isn’t particularly easy to adapt to your app’s growing needs. What are you left with, then?
VPS hosting was designed as a solution to dedicated hosting’s shortcomings. Instead of a physical server, you get to use a virtual machine. Like a real-world server, it has its own dedicated IP address as well as a set of hardware resources available to you at all times.
As a result, you have consistent performance and better security. However, unlike a dedicated server, a VPS won’t break the bank. Virtualization allows providers to utilize their hardware more efficiently, so pound-for-pound, virtual private servers are much more cost-effective than dedicated ones.
Another key advantage is the easy scalability. Before deploying your VPS, you specify its hardware configuration. Virtualization and cloud computing technology let you decide how much processing power, memory, and storage your server has, so you can tailor it to your specific needs and avoid paying for resources you don’t use.
Crucially, you can tweak the configuration whenever you want. So, when you exceed the capacity of your current VPS plan, you can add more resources without having to move data from one machine to another.
Thanks to all these advantages, VPS plans are in high demand, but some people are still not sure if they can stay on top of the task of controlling an entire server on their own.
Luckily for them, there are managed VPS solutions that can answer most of their questions. With a managed plan, your host deploys the virtual server and takes care of all the complex administration tasks related to the configuration and operation of the server. Instead of worrying about things like updates, patches, firewall settings, etc., you can delegate them to your provider’s experts so you can focus on your app development.
With a managed VPS, you get a control panel and a graphic user interface for setting up and configuring various aspects of your server’s operation. There’s SSH access for running commands, and some providers even let you get root access.
Your mobile app backend is a complex array of systems and components, each with a critical role in ensuring your project delivers the performance and functionality users expect. Designing a properly configured, working backend is no small feat, so you need to take your time and think about the dozens of different aspects of its operation.
It will be challenging, but if you get it right, your app is guaranteed to impress even the most demanding user.
Q: How do I host a mobile backend?
A: Although some providers advertise specialized app hosting services, your mobile application backend has no specific requirements in terms of hardware. In basic terms, you need a server and an internet connection. Once you set that up, you can install and configure the software to deliver your app functionality.
Q: Where can I deploy my app backend?
A: You can deploy your backend on any physical or virtual machine. You can even use your home computer, but if you want to build a quick and responsive app, you’re better off hiring a server set up and deployed in a data center. If your app is very popular, you can also deploy its backend on a cluster of servers, giving you high availability and blistering performance.
Q: How much does it cost to host a mobile app?
A: The cheapest managed VPS solutions are not much more expensive than shared plans, and they should work unless you’re planning to build something extremely complex. Not surprisingly, the more popular your app gets and the more features it has – the more powerful your server needs to be.