Capgo Live Updates

Capgo Live Updates

By Martin DonadieuTechnology
Download on the App Store

Capgo Live Updates episodes

  • Build And Deploy Ios Apps With Gitea Actions
    Building iOS apps with self‑hosted Gitea Actions forces teams to confront Apple’s Xcode‑only requirement. The episode explains why a physical Mac mini quickly becomes a bottleneck—disk bloat, fragile keychains, security risks, and single‑job queues—when you run Fastlane and signing tools directly on the host. It then introduces CapGo’s cloud build service as a hybrid alternative that lets Linux runners handle the web layer while offloading Xcode compilation to managed Macs, keeping source code behind the firewall.
    Listeners learn how to configure Gitea secrets without the prohibited GITEA/ GitHub prefixes, use tag‑based releases, and avoid OpenSSL 3 cipher errors by adding the legacy flag. The discussion also covers the live‑update script that skips native builds when only web assets change, dramatically speeding up deployments.
    Topics:
    - Why a dedicated Mac runner is fragile and costly for iOS CI
    - Using CapGo Cloud to compile with Xcode from a Linux Gitea runner
    - Correctly naming Gitea secret variables and handling Apple credentials
    - Live‑update logic that bypasses unnecessary native builds
    Full article
    https://capgo.app/blog/build-and-deploy-ios-apps-with-gitea-actions/
    24 min
  • Build And Deploy Ios Apps With Bitbucket Pipelines
    Bitbucket Pipelines runs Linux Docker containers, which can’t compile iOS apps because Xcode, code‑signing tools and the iOS SDK only exist on macOS hardware. The guide explains why self‑hosting a Mac mini as a runner creates hidden costs: ongoing maintenance, storage bloat from derived data, single‑build bottlenecks and fragile keychain state that can break CI jobs.
    A hybrid solution uses the Linux runner for dependency installation and web asset compilation, then hands off the prepared iOS project to CapGo’s managed Cloud Macs via a single CLI call. The Cloud Mac builds, signs, and uploads the .ipa, while Bitbucket streams logs back to the pipeline. Conditional logic detects pure web changes and pushes them as live updates, avoiding native builds and App Store review for minor fixes.
    Topics:
    - Why standard Bitbucket Pipelines can’t build iOS apps on Linux
    - Drawbacks of self‑hosted Mac mini runners such as maintenance overhead and storage issues
    - Hybrid workflow that offloads Xcode builds to CapGo Cloud Macs
    - Using CapGo live updates for web‑only changes to skip native compilation
    - Conditional pipeline logic that routes builds to either live update or full Cloud Mac build
    Full article
    https://capgo.app/blog/build-and-deploy-ios-apps-with-bitbucket-pipelines/
    25 min
  • Best Tools For Mobile App Developers And Teams Building Web Based Apps With
    Capacitor apps can bypass App Store review for UI and logic changes by delivering over‑the‑air (OTA) updates of the web bundle. The episode explains how the native shell hosts a WebView that serves local HTML, CSS and JavaScript, while any native plugin changes still require a traditional store submission. Listeners learn how to keep OTA updates compliant, why sticky rollouts based on device IDs preserve session continuity, and how differential (delta) bundles shrink download sizes for users on slow networks.
    The discussion also covers integrating Capco’s CLI into CI/CD pipelines to automate channel promotion, using PR templates and automated diffs to prevent accidental native changes, and configuring Observe’s auto‑rollback thresholds that trigger only on real boot failures, not low traffic. Finally, the hosts note pricing options for small teams and the broader impact of owning the mobile release cycle.
    Topics:
    - Using sticky rollout cohorts to avoid session breakage
    - Automating OTA deployments with Capco CLI and CI/CD
    - Applying delta updates to reduce bundle download size
    - Enforcing native‑code boundaries via PR checks and CI diffs
    - Configuring real‑time failure monitoring and auto‑rollback
    Full article
    https://capgo.app/blog/best-tools-for-mobile-app-developers-and-teams-building-web-based-apps-with/
    20 min
  • Best Tools And Services For Launching A Capacitor App
    Capacitor apps let you update HTML, CSS, and JavaScript instantly via over‑the‑air (OTA) bundles, bypassing the App Store review for cosmetic or logic changes. The episode explains how OTA updates replace only the web bundle while native code stays unchanged, and why the operating system blocks any OTA attempt to add new permissions or native plugins. Listeners learn the security model that uses signed bundles and how CapGo’s Observe service detects mismatches between web code and installed native plugins before delivery.
    The discussion also covers building a repeatable CI/CD pipeline that automates asset copying, signing, and deployment, and how to run staged rollouts with sticky cohorts to keep telemetry clean. Real‑device testing, rollback rehearsals, and post‑release monitoring are highlighted as essential practices to avoid hidden bugs and to react instantly if a release misbehaves.
    Topics:
    - Defining the web‑only vs native boundary for OTA updates
    - Using signed bundles and CapGo Observe to prevent security and compatibility issues
    - Automating the build and deployment flow with CI tools like GitHub Actions
    - Implementing sticky cohort rollouts and auto‑pause thresholds
    - Practicing rollbacks and monitoring metrics in real time
    Full article
    https://capgo.app/blog/best-tools-and-services-for-launching-a-capacitor-app/
    23 min
  • Best Real Time App Update Analytics
    Over‑the‑air (OTA) updates for Capacitor apps let developers push fixes instantly, bypassing App Store review cycles for most web‑layer changes. The episode explains how OTA works in a two‑layer architecture—native wrapper plus web bundle—and why differential updates are essential to keep payloads small and avoid draining users' data plans. Listeners learn how to monitor real‑time telemetry to answer four critical questions: did the bundle reach users, install correctly, cause crashes, and can the release be halted instantly.
    The discussion then dives into practical rollout strategies: separating download, install and crash metrics; tracking core business events instead of generic crash‑free scores; using staged, percentage‑based rollouts with beta channels; and pre‑defining automatic rollback rules based on your own recent performance baselines. These techniques turn a risky deployment into a controlled experiment, ensuring quick recovery and minimal revenue loss.
    Topics:
    - Differential OTA patches versus full bundle pushes
    - Curated telemetry dashboards that trigger binary roll‑out decisions
    - Staged rollouts with percentage exposure and automatic rollback rules
    - Separating download, install, and crash metrics for accurate health signals
    - Monitoring core business events to detect logical failures
    Full article
    https://capgo.app/blog/best-real-time-app-update-analytics/
    22 min
  • Apple Intelligence Capacitor App
    Apple's new Foundation Models framework in iOS 26 lets third‑party apps run a 3‑billion‑parameter on‑device model via the CapGo Capacitor LLM plugin. This eliminates cloud API costs, keeps data on the device, and requires only iPhone 15 Pro/16 or newer, iPad M1 or newer, iOS 26, and about seven gigabytes of free storage for the model weights. The episode walks through initializing the plugin, checking readiness states, handling unsupported devices, and gracefully managing the large background download.
    Listeners learn how to work within the 4,096‑token context window by creating task‑specific chats, chunking large inputs, and streaming responses for a smooth UI. The discussion also covers using CapGo Live updates to tweak JavaScript prompts without App Store review, handling built‑in guardrails and refusal errors, and falling back to cloud APIs when on‑device support isn’t available.
    Topics:
    - initializing the CapGo LLM plugin and checking hardware readiness
    - managing the 7 GB model download and graceful UI fallback
    - working within the 4,096 token limit with chat segmentation and input chunking
    - streaming AI output to improve perceived performance
    - using live JavaScript updates to iterate prompts without App Store delays
    Full article
    https://capgo.app/blog/apple-intelligence-capacitor-app/
    12 min
  • App State Management
    The episode explains why mobile apps lose user input when the device rotates or is suspended, highlighting the aggressive lifecycle of iOS and Android that tears down and rebuilds activities. It shows how treating state as an afterthought leads to data loss, and why a single global store like Redux creates bottlenecks and inefficient re‑renders across unrelated components.
    Listeners learn a four‑owner model—server, UI, form, and URL state—and how to store each safely using localized component state, lightweight dedicated stores, or an event bus. The discussion also covers offline‑first syncing with SQLite or IndexedDB queues, optimistic UI with honest status indicators, conflict resolution strategies, and incremental migration tactics using tools like Capco for over‑the‑air updates.
    Topics:
    - four distinct state owners to avoid global store bottlenecks
    - local component state versus lightweight centralized stores
    - offline‑first queueing in SQLite/IndexedDB and optimistic UI feedback
    - conflict resolution as a product decision, not just a technical fix
    - incremental migration and over‑the‑air deployment with Capco
    Full article
    https://capgo.app/blog/app-state-management/
    23 min
  • Best Channel Based App Rollout Tool
    Channel-based rollouts let Ionic and Capacitor apps push web‑asset updates to specific user cohorts without waiting for App Store review. The episode explains how a lightweight SDK checks a device’s assigned channel at launch, fetches the appropriate bundle, and lets teams test fixes on development, QA, beta, and production streams. Listeners learn how to configure channel owners, avoid the panic of a big‑bang release, and keep native code changes separate from over‑the‑air (OTA) updates.
    The discussion covers practical steps such as using Capgo’s CLI to upload a bundle, setting auto‑pause thresholds on failure rates, performing one‑click rollbacks for web assets, and rehearsing recovery drills on low‑risk beta releases. It also clarifies the difference between channels and feature flags and shows how to secure deployment tokens in CI pipelines.
    Topics:
    - Configuring channel owners and audience scopes
    - Using Capgo CLI for OTA bundle uploads
    - Monitoring real‑time health metrics and auto‑pause
    - Executing one‑click web rollbacks versus native rebuilds
    - Running recovery drills to validate rollback procedures
    Full article
    https://capgo.app/blog/best-channel-based-app-rollout-tool/
    12 min
  • Apple Remote Code Execution Capgo Live Updates
    Apple’s Guideline 2.5.2 bans native code that can be downloaded and executed, but the App Developer Program License Agreement (section 3.3.1b) carves out an exception for interpreted code such as JavaScript running in a WebView. The episode explains why over‑the‑air updates with Capgo are legal when they only modify the web layer of a Capacitor app, and how Apple’s reviewers look for native functions like dlopen rather than JavaScript bundles.
    Listeners learn how to stay within Apple’s rules: keep the native shell unchanged, avoid adding new features or a storefront via OTA updates, and document the update process in App Store review notes. The hosts also cover the extra compliance needed for “super‑app” scenarios under Guideline 4.7, and show how Capgo’s encrypted delivery and staged rollouts let teams ship bug fixes and UI tweaks safely and quickly.
    Topics:
    - Distinguishing native code bans from allowed interpreted JavaScript updates
    - Applying ADPLA 3.3.1b criteria to OTA releases and avoiding primary‑purpose changes
    - Compliance steps for mini‑app platforms under Guideline 4.7
    - Using Capgo’s encryption, staged rollouts, and rollback features for rapid bug fixes
    Full article
    https://capgo.app/blog/apple-remote-code-execution-capgo-live-updates/
    22 min
  • App Store Rejection
    App Store rejections are reframed as predictable incident reports rather than personal verdicts. Listeners learn why Apple’s reviewers act like an automated QA test, the typical 24.8% rejection rate, and how to classify rejections into hard blocks, metadata fixes, clarification requests, or appeal candidates. The episode walks through diagnosing the exact path a reviewer took, freezing the rejected build as a crime‑scene, and crafting a concise four‑part, evidence‑first appeal that avoids emotional essays.
    The discussion also shows how Capacitor developers can use Capco’s live‑update system to push web‑layer fixes without resubmitting a binary, and how to embed compliance checks into CI pipelines—such as enforcing Xcode version, detecting privacy‑manifest drift, and capturing telemetry—to stop most rejections before they reach Apple.
    Topics:
    - Classifying and diagnosing the specific type of App Store rejection
    - Creating a four‑step, evidence‑first appeal to the reviewer
    - Using Capco live updates for web‑layer bug fixes without new binary submissions
    - Embedding compliance and manifest‑drift checks into CI pipelines
    Full article
    https://capgo.app/blog/app-store-rejection/
    22 min

About Capgo Live Updates

From the publisher's feed

Capgo Live Updates is a podcast for developers building mobile apps with Capacitor and Ionic. Each episode explores an article from the Capgo blog, covering over-the-air updates, native integrations,…