Migrating from Capgo to Capawesome Cloud¶

If you're currently using Capgo for live updates and considering a switch to a more reliable, feature-rich platform, Capawesome Cloud offers a seamless migration path. With superior uptime, faster response times, and more competitive pricing, Capawesome Cloud provides everything you need for robust Over-the-Air updates.

Why Migrate from Capgo?¶

While Capgo has served as a live update solution for Capacitor apps, there are several compelling reasons to consider migrating to Capawesome Cloud. The platform offers significantly better reliability with 99.99% uptime compared to Capgo's 99.65%, translating to just 10 minutes of downtime versus 7 hours over the past 90 days. Response times are notably faster at 267ms versus 441ms, ensuring your users receive updates more quickly.

Beyond performance metrics, Capawesome Cloud provides a more stable platform with fewer bug reports and patch releases, indicating a more mature and tested codebase. The pricing structure is more accessible, starting at $9/month with a free tier available, compared to Capgo's $14/month minimum. You also gain access to unique features like EU hosting options, Git integration, and unlimited updates that aren't available with Capgo.

The Capawesome team brings deep expertise in Capacitor plugin development, with official Ionic Developer Experts on staff who understand the intricacies of the Capacitor ecosystem. This expertise translates into better support and more thoughtful feature development that aligns with Capacitor best practices.

Prerequisites¶

Before starting your migration from Capgo to Capawesome Cloud, make sure you have these requirements in place:

A Capacitor app currently using Capgo for live updates
Node.js version 18 or higher installed on your development machine
Access to your current Capgo configuration and deployment settings
Your app's bundle IDs and channel configurations from Capgo

Take a moment to document your current Capgo setup, including any custom update strategies or configurations you've implemented. This will help ensure a smooth transition to Capawesome Cloud.

Migration Overview¶

The migration process from Capgo to Capawesome Cloud follows a structured approach designed to minimize disruption to your existing users. You'll begin by setting up your Capawesome Cloud account and configuring your app. Then you'll install the Capawesome Live Update SDK, replacing the Capgo plugin in your project. After updating your code to use Capawesome's API methods, you'll configure your desired update strategies. Finally, you'll build and deploy your first update through Capawesome Cloud.

Throughout this process, you can maintain your existing update cadence and user experience patterns. The APIs are designed to be familiar, making the code migration straightforward while giving you access to enhanced capabilities.

Step 1: Setting Up Capawesome Cloud¶

Create Your Account¶

Start by visiting the Capawesome Cloud Console to create your account. The registration process is quick and gives you immediate access to the platform. Unlike Capgo, Capawesome Cloud offers a generous free tier that lets you test all features before committing to a paid plan.

Once logged in, you'll find an intuitive dashboard where you can manage your applications, monitor update deployments, and access detailed analytics about your user base and update performance. The interface is designed to be familiar to anyone who has used live update platforms before, while offering enhanced visibility into your deployment pipeline.

Create Your App¶

In the Capawesome Cloud Console, navigate to the Apps section and click "Create App" to set up your first application. Enter a descriptive name for your app that will help you identify it easily in your dashboard. The system will generate a unique App ID that serves as the primary identifier for your application in all API calls and configurations.

You'll want to configure channels that match your existing Capgo setup. If you're using channels like "production", "staging", or "development" in Capgo, you can create equivalent channels in Capawesome Cloud. This ensures a smooth transition without disrupting your existing deployment workflows.

Step 2: Installing the Capawesome Live Update SDK¶

Remove the Capgo plugin from your project and install the Capawesome Live Update plugin:

npm uninstall @capgo/capacitor-updater
npm install @capawesome/capacitor-live-update
npx cap sync

The Capawesome Live Update plugin is built from the ground up for Capacitor, ensuring optimal performance and compatibility. It's fully open-source under the MIT license, giving you transparency into how your updates are handled and the freedom to contribute improvements if needed.

Step 3: Configuring Your App¶

Replace your Capgo configuration with the Capawesome Cloud settings in your Capacitor configuration file:

TypeScriptJSON

capacitor.config.ts

import { CapacitorConfig } from "@capacitor/cli";

const config: CapacitorConfig = {
  plugins: {
    LiveUpdate: {
      appId: "00000000-0000-0000-0000-000000000000", // Your Capawesome App ID
      defaultChannel: "production", // Optional: Your default channel
      autoDeleteBundles: true // Optional: Automatically clean up old bundles
    }
  }
};

export default config;

capacitor.config.json

{
  "plugins": {
    "LiveUpdate": {
      "appId": "00000000-0000-0000-0000-000000000000",
      "defaultChannel": "production",
      "autoDeleteBundles": true
    }
  }
}

The configuration is intentionally streamlined compared to Capgo, focusing on essential settings while handling advanced behaviors through code. This gives you more flexibility in implementing custom update logic specific to your app's needs.

Step 4: Replacing the Capgo SDK¶

API¶

The migration from Capgo's API to Capawesome Cloud's API involves updating your method calls and adjusting some patterns. Here's how to translate the most common operations:

Get Latest¶

In Capgo, you might check for the latest available bundle using the getLatest method. Capawesome Cloud provides this functionality through the fetchLatestBundle(...) method:

Capgo:

import { CapacitorUpdater } from '@capgo/capacitor-updater';

const checkForUpdate = async () => {
  const latest = await CapacitorUpdater.getLatest();
  if (latest.url) {
    console.log('Update available:', latest.version);
  }
};

Capawesome Cloud:

import { LiveUpdate } from '@capawesome/capacitor-live-update';

const checkForUpdate = async () => {
  const result = await LiveUpdate.fetchLatestBundle();
  if (result.downloadUrl) {
    console.log('Update available:', result.bundleId);
  }
};

Download¶

Downloading the update bundle is done using the download method in Capgo, while Capawesome Cloud uses the downloadBundle(...) method:

Capgo:

import { CapacitorUpdater } from '@capgo/capacitor-updater';

const downloadUpdate = async () => {
  const latest = await CapacitorUpdater.getLatest();
  if (latest.url) {
    const bundle = await CapacitorUpdater.download({
      url: latest.url,
      version: latest.version
    });
    console.log('Bundle downloaded');
  }
};

Capawesome Cloud:

import { LiveUpdate } from '@capawesome/capacitor-live-update';

const downloadUpdate = async () => {
  const result = await LiveUpdate.fetchLatestBundle();
  if (result.downloadUrl) {
    await LiveUpdate.downloadBundle({
      bundleId: result.bundleId,
      url: result.downloadUrl
    });
    console.log('Bundle downloaded');
  }
};

Next¶

To set a specific bundle as the next one to be loaded, you have to use the setNextBundle(...) method in Capawesome Cloud.

Capgo:

import { CapacitorUpdater } from '@capgo/capacitor-updater';

const setNextBundle = async () => {
  await CapacitorUpdater.next({ id: 'bundle-id-123' });
};

Capawesome Cloud:

import { LiveUpdate } from '@capawesome/capacitor-live-update';

const setNextBundle = async () => {
  await LiveUpdate.setNextBundle({ bundleId: 'bundle-id-123' });
};

Reload¶

Finally, if you want to apply the downloaded update directly, you have to use the reload functionality which works the same way in both platforms.

Capgo:

import { CapacitorUpdater } from '@capgo/capacitor-updater';

const applyUpdate = async () => {
  await CapacitorUpdater.reload();
};

Capawesome Cloud:

import { LiveUpdate } from '@capawesome/capacitor-live-update';

const applyUpdate = async () => {
  await LiveUpdate.reload();
};

Live Update Strategies¶

Capawesome Cloud supports flexible update strategies that can replicate and enhance your existing Capgo update behaviors:

Background¶

The background strategy silently downloads updates while your app runs, applying them seamlessly on the next launch:

import { LiveUpdate } from '@capawesome/capacitor-live-update';

// Check for updates on app launch
const initializeApp = async () => {
  await LiveUpdate.sync();
  // Your app initialization code
};

initializeApp(); // Call once at app startup

This approach mirrors Capgo's default behavior and offers additional flexibility in managing updates.

Always Latest¶

This approach is our recommended strategy for ensuring users always have the latest version of your app in a timely manner:

import { App } from '@capacitor/app';
import { LiveUpdate } from '@capawesome/capacitor-live-update';

App.addListener('resume', async () => {
  const result = await LiveUpdate.sync();
  if (result.nextBundleId) {
    const shouldReload = confirm('A new update is available. Would you like to install it now?');
    if (shouldReload) {
      await LiveUpdate.reload();
    }
  }
});

This strategy balances keeping your app updated with respecting user choice, allowing them to defer updates if they're in the middle of something important.

Force Update¶

The force update strategy ensures users have the latest version before they can use the app. This is useful for critical updates:

import { SplashScreen } from '@capacitor/splash-screen';
import { LiveUpdate } from '@capawesome/capacitor-live-update';

const initializeApp = async () => {
  const result = await LiveUpdate.sync();
  if (result.nextBundleId) {
    await LiveUpdate.reload(); // Apply the update
  } else {
    await SplashScreen.hide(); // Hide the splash screen
  }
};

initializeApp(); // Call once at app startup

While this ensures all users are on the latest version, use this strategy judiciously as it can impact the user experience if updates are frequent or large.

Step 5: Building and Distributing Updates¶

Build Your App¶

Generate your web assets using your standard build process:

npm run build

Ensure your build output directory (typically www or dist) contains all necessary assets. Capawesome Cloud uses intelligent diffing to create delta updates, so even if your initial bundle is large, subsequent updates will be minimal.

Install Capawesome CLI¶

Install the Capawesome CLI tool to manage your deployments:

npm install -g @capawesome/cli@latest

The CLI provides powerful commands for bundle management, including creation, upload, and rollback capabilities. It's designed to integrate seamlessly with CI/CD pipelines, supporting both interactive and automated workflows.

Deploy a Live Update¶

Create and deploy your first bundle to Capawesome Cloud:

npx @capawesome/cli apps:bundles:create --appId YOUR_APP_ID --channel production --path www

This command packages your web assets into a bundle and uploads it to Capawesome Cloud. The bundle becomes immediately available to your users through the channel you specified. You can automate this process in your CI/CD pipeline just as you did with Capgo.

Migration Timeline¶

A well-planned migration ensures minimal disruption to your users while maintaining continuous update capability throughout the transition. Here's a recommended timeline that balances thoroughness with efficiency:

Begin with a pilot phase where you set up Capawesome Cloud and test the integration with a development build of your app. This typically takes 1-2 days and allows you to familiarize yourself with the platform's features and validate that all your update scenarios work correctly.

Next, implement the SDK replacement in a feature branch, thoroughly testing each update strategy your app uses. Allocate 3-5 days for this phase, including comprehensive QA testing. Pay special attention to edge cases like network interruptions during updates or app backgrounding during the update process.

Roll out the Capawesome-enabled version to a small group of beta users or internal testers. Monitor this group for 5-7 days, tracking metrics like update success rates, download times, and any user-reported issues. This controlled rollout helps identify any unexpected behaviors before full deployment.

Finally, release the updated app to all users through your standard app store deployment process. Continue monitoring for the first week after release to ensure stability. Once confirmed, you can safely sunset your Capgo subscription while maintaining full update capabilities through Capawesome Cloud.

Conclusion¶

Migrating from Capgo to Capawesome Cloud brings immediate benefits in reliability, performance, and cost-effectiveness. The platform's superior uptime, faster response times, and robust feature set ensure your live update infrastructure is built on a solid foundation. With delta updates reducing bandwidth usage and transparent pricing that scales with your app's growth, Capawesome Cloud represents a significant upgrade for your Over-the-Air update strategy.

The migration process, while requiring some code changes, is designed to be straightforward and can typically be completed in less than a day of development time. The familiar API patterns and comprehensive documentation make the transition smooth, while the enhanced capabilities provide room for future growth and optimization.

For assistance during your migration, the Capawesome team offers dedicated support to ensure your transition is successful. Visit the Capawesome Cloud documentation for detailed technical guides, explore the Live Update plugin reference for API details, or contact the support team for personalized migration assistance.

Take control of your app's update infrastructure today with Capawesome Cloud and join the growing community of developers who've made the switch to a more reliable, feature-rich live update platform.