Taking Your App Live
Building an application is only part of the journey. Once your project is complete and functioning the way you want, the next step is deploying it so real users can access it. CloudXLR simplifies this process by providing a built-in cloud compiler that can generate production-ready application files directly from your browser.
Instead of setting up complicated development environments or manually configuring build tools, the platform handles the heavy technical work for you. With only a few steps, your application can be compiled and prepared for deployment across multiple platforms.
CloudXLR supports publishing for the web, Android devices, and iOS devices. Each platform has its own requirements, but the system guides you through the process so that deployment remains straightforward and manageable.
Web Deployment
Publishing your application as a website is the fastest way to make it accessible to users. Before deploying to the web, you must first connect a custom domain using the Domain Manager.
The Domain Manager allows you to link your application to a domain name so users can access it through a clean and professional web address. Once your domain is connected and verified, your application can be published directly to the internet.
To launch the site, open the Publish modal within the CloudXLR interface and choose the option to publish to the web. The platform will automatically compile your project, prepare the required assets, and deploy the application to your connected domain.
Within moments your application will be live and accessible to anyone who visits your website. This instant deployment capability allows founders and developers to launch prototypes, test ideas, and release updates rapidly.
Android Publishing (APK and AAB)
If you want your application to run on Android devices, CloudXLR can compile it into the formats required by the Android ecosystem.
Before building your Android application, you must generate an Android Signing Key in the App Settings section. This signing key acts as a digital identity for your application and is required by Android to verify that updates come from the same developer.
Once the signing key is created, you can choose between two different build types depending on your goal.
A Debug APK is intended for testing purposes. This version can be installed directly onto your personal Android device or shared with testers so they can evaluate the application before release.
A Release AAB is designed for official distribution through the Google Play Store. The Android App Bundle format is the standard package used when submitting applications to Google Play because it allows the store to optimize the app for different devices and configurations.
By generating these builds through CloudXLR, you avoid the complexity of configuring Android development tools manually.
iOS Publishing (IPA)
Publishing an application for iOS requires additional steps because Apple maintains a strict security and certification system for apps running on iPhones and iPads.
To compile an iOS application, you must first have an active Apple Developer account. This account allows you to generate the certificates and profiles required to sign and distribute your app.
Within CloudXLR, you will first generate a Certificate Signing Request, commonly called a CSR. This file is uploaded to Apple’s developer portal, where Apple will issue a certificate file known as a CER file.
After receiving the certificate, you will also need to provide a Provisioning Profile from your Apple Developer account. This profile defines which devices or distribution channels your application is allowed to run on.
Once these items are configured in CloudXLR, the platform can compile your project into an IPA file. The IPA format is the standard package used for installing iOS applications.
This file can then be uploaded to Apple’s TestFlight service for testing or submitted directly to the App Store for public release.
With these deployment tools, CloudXLR allows you to move from idea to a fully published application without needing to manage complicated build systems or platform-specific development environments.