A mobile app and a web app can rely on the same APIs and share several technologies. However, the release processes for mobile apps and web apps are very different. Mobile apps can only be officially downloaded from app stores, which impose guidelines, requirements, and strict procedures. Conversely, a web app can be released easily, effortlessly, and in no time at all.
So, it should not surprise you that companies like Airbnb and Lyft have adopted the server-driven user interface (SDUI) technique to try and bring that same flexibility to their mobile app development. An SDUI-based mobile application is just a container that renders the UI of each view based on data retrieved from the server. With SDUI, updating the UI of a mobile app only requires changing the response provided by the server, which makes making a UI change on the mobile app as flexible as releasing a web application.
In this article, you’ll learn the differences between mobile app and web app release processes, why the web app release process is better, how SDUI can make the mobile app release process quicker, and what SDUI could mean for the future of the mobile app development process.
If you want your mobile app to appear in the official Android and iOS app stores, you must follow specific guidelines. One of the biggest drawbacks with the process is that there are different guidelines for Android and iOS, and the requirements your app has to meet to get published on each app store may also be different. This forces you to implement different solutions in iOS and Android development. When Google and Apple change their guidelines over time, you also need to adapt your app to their new requirements.
In a typical mobile app release process, you first define a list of requirements for your app based on your business goals and what Google and Apple expect from you. You then need to design your app while also considering the official Android or iOS design guidelines.
Then, you can start building your app. When it’s ready, you should verify that your app is bug-free and crash-free, because if an Android or iOS reviewer manages to consistently replicate a bug or encounters a crash, your app submission will be rejected.
Finally, you have to submit your app to Google Play or Apple’s App Store along with a description and some screenshots. If your app passes the app store review process, you’ll be allowed to make it publicly available for users to download. At this point, the maintenance phase of the development process begins.
The standard mobile app release process is not that different from the traditional waterfall model. The waterfall model is a linear approach to software development that requires each phase to be completed before moving on to the next. The phases of the traditional waterfall model are requirement, identification, design, implementation, verification, and maintenance.
The mobile app release process being waterfall-like is not a compliment, especially considering that the waterfall model has well-known disadvantages, such as excessive rigidity that makes changes difficult, exclusion of users from the development process, and the introduction of testing too late in the process. Also, keep in mind that the app store review process can take anywhere from a few hours to several business days. This makes the app release process even slower. All of this makes the standard mobile app release process antiquated, cumbersome, and inflexible.
On the other hand, the web app release process follows a less strict and more dynamic approach. You only have to build your web app, run it, and deploy it to a web server, which can be reduced to a git push command to deployment platforms like Vercel or Heroku. You have full control over when your app is deployed, and can ensure that all of your users will be using the latest version.
SDUI stands for server-driven user interface and is a technique that leverages the server to build the user interface of a mobile app. An SDUI-based mobile app is just a generic container where the UI and data for each view are retrieved from a web server. The mobile app dynamically builds the UI of the entire view or of a single component based on information that’s generally stored in human-readable formats such as JSON or YAML.
You can think of the response from the server as a sort of special markup language that your mobile app can understand. The JSON response involves everything the app needs to structure the view, such as info about alignment, spacing, images, colors, and typography.
The following is an example of a JSON response defining the UI of a view:
.png)
Considering the ease with which new UI updates can be released and the flexibility of SDUI-based apps, the SDUI approach clearly offers some significant advantages compared to the traditional mobile app release process. However, some benefits are particularly relevant if you are considering adopting this method.
In general, the UI of a mobile app needs to be changed more frequently than its business logic. This is because users expect the UI to meet their needs and market trends, which are constantly evolving. Ignoring user feedback about the UI results in negative app reviews and churned users. You might also want to make changes that are time-sensitive, for example, advertising seasonal promotions or making contextual feedback requests. In fact, most of the changes you’ll want to make to your app involve UI, but quick iterations and experiments are almost impossible to make due to the appstore processes.
If you want to make updates to your app using SDUI, however, you'll only need to update the response on the server - no need to resubmit.
In an SDUI scenario, the data required to structure the UI is retrieved from the server. This means that the UI of your mobile app can change based on user login. Specifically, you can configure your server to return different UI JSON data based on a user’s role, subscriptions, or privileges. This gives you endless possibilities to offer each user a personalized and unique experience. For example, visitors with a free plan may be shown a UI designed to encourage conversion to premium plans. On the other hand, premium users can be shown an advanced user interface that makes all premium features easily available and ensures a high-quality user experience.
In the traditional mobile app development approach, determining the best UI design involves the development of a different app for each design, which you then subject to A/B tests. This process can take months. Conversely, you can use SDUI to simultaneously present different UIs to users on the same mobile app and determine which UI is better from analytics and their feedback.
Ultimately, SDUI can be seen as the natural evolution of the traditional approach to mobile app development. SDUI allows you to avoid the overhead inherent in the app store review process and brings the app release process more in line with the web release process.
With traditional mobile app development, each UI update can take weeks or even months to get to your users because of the waterfall-like release cycle. On the other hand, SDUI reduces the entire process to only one operation involving a server-side update of the UI markup responses. This way, you can update your app without writing a single line of code – theoretically, instantly. If you don’t need to add any new lines of code, you can also limit the introduction of additional QA or potential new bugss.
SDUI simplifies the mobile app release process while also making it more dynamic. SDUI helps you react faster and avoid delays when it comes to fixing UI problems, allowing you to perform multiple mobile app releases in a single day. This is particularly useful because it allows you to react faster and improve user engagement and conversion metrics as a result.
Greater adoption of SDUI could lead to greater flexibility in application release and reduced release time, due to its approach to UI rendering based on a markup response retrieved by the mobile app from the server. Note that the markup data containing the UI definition does not have to be written manually. In other words, you don’t have to define the markup language yourself or edit it manually whenever necessary.
Instead, you can use intuitive online visual tools such as Unflow to structure the UI of your mobile application with minimal effort. Tools like Unflow act as visual design platforms, require no code, and offer a drag-and-drop interface that allows you to build the UI of your dreams for your mobile application.
Adopting such a platform will make it possible for anyone to structure advanced UIs, regardless of their technical skills. This would never have been possible without SDUI, which makes app development and testing easier and more affordable for everyone. For example, Unfollow supports A/B testing natively. Therefore, you can set up live A/B testing directly from the Unfollow platform. You do not need to be an engineer to start A/B testing your application with Unflow!
Mobile apps are made available through app stores from Google and Apple, which restrict the rapid release of apps to ensure security and reliability. This makes mobile app development a step backwards because it is a slow, static, waterfall-like process. This regression is particularly evident when comparing mobile app development to web app development, which is fast, dynamic, and easily automated.
SDUI allows you to move the UI definition to the server and expose it to the mobile application via API. This means that the mobile application only needs to know how to render the UI data retrieved from the server. As a result, you can avoid the need to update new versions and circumvent the waiting time resulting from app store review processes. If you want to update the application UI, you only need to modify the UI data provided by the server.
With the SDUI approach in mind, advanced low-code platforms like Unflow offer a visual editor that marketers and designers can use to create cross-platform mobile content and experiences quickly and easily. To learn more about how Unflow works, check out the documentation.
