Skip to content
AppDues
Log in
Contact salesSign up

Keeping paywalls and purchases working when infrastructure fails

A subscription purchase can fail at several points: the app store is unreachable, the paywall configuration cannot be fetched, or the billing backend is down.

This page explains the layered fallback model, what each layer does, and what to check before you rely on it in production.

The five-layer defense, layer by layer

The model assumes an outage can happen at any point and routes around it.

  1. SDK. The SDK caches paywall specs and product data locally. If the configured paywall cannot render, a built-in branded fallback paywall with a purchase CTA is shown. A durable queue and temporary entitlements keep access available, and telemetry records every fallback path.
  1. Edge and CDN. Multiple CDNs and global points of presence route traffic to reachable API servers when a region, route, or provider is degraded. Low-latency routing and alternate CDN coverage support constrained networks.
  1. Static fallback CDNs. If there is no local cache, static fallback CDNs can serve offerings, product data, and paywall assets from a separate path. This covers fresh installs and empty caches.
  1. Fortress. When the primary backend is unavailable, Fortress accepts the purchase event, grants a temporary entitlement, stores the transaction for reconciliation, and sends fallback entitlement webhooks.
  1. Core backend. After the outage clears, the core backend verifies receipts with the app stores, reconciles the temporary grants that the SDK and Fortress issued, removes duplicate replayed events, and restores the authoritative record.

What each layer protects — and what it does not

Use this map to set expectations for each failure mode.

  • App store unreachable, SDK has cache: cached paywall and product data render; purchase queue holds the event.
  • App store unreachable, no cache: static fallback CDN serves offerings and assets.
  • Primary backend down: Fortress accepts the purchase and grants a temporary entitlement until reconciliation.
  • After recovery: receipt validation and deduplication determine the final entitlement state.

A temporary entitlement is not the final state. It exists to keep access available while the core backend reconciles with the app stores.

Operations: monitoring, severity, and post-incident work

Synthetic checks run continuously across multiple regions and simulate real user flows. Incidents are classified by severity at detection; a SEV1 triggers immediate escalation with a dedicated incident commander and customer communication within minutes. Every incident ends with a post-mortem, and findings become tracked hardening work. New features are designed with failure modes, fallback behavior, and recovery paths before shipping. Data in transit and at rest is protected with industry-standard security protocols.

Checklist before you rely on fallbacks

Before shipping, confirm in a sandbox environment:

  • The cached paywall renders when the network is unavailable.
  • The branded fallback paywall appears when the configured paywall cannot load.
  • A purchase made during a simulated backend outage is queued and later reconciled.
  • Temporary entitlements are time-bounded and signed.
  • Replayed or revoked purchases are dropped during reconciliation.
  • Telemetry records each fallback path you exercise.

A sandbox environment and SDK helpers can simulate network failures, paywall fetch errors, and backend outages, so these flows can be tested end to end without touching production.

ConfigureTargetTest

Frequently asked questions

What happens if my paywall fails to load?

The SDK caches paywall specs and product data locally at initialization. If the configured paywall cannot render because servers are unreachable or the config is missing, the SDK automatically shows a built-in, branded fallback paywall. Users always see a purchase CTA rather than a blank screen.

Are purchases lost during an outage?

No. When the primary backend is unavailable, Fortress accepts and persists the transaction, and users keep their entitlements unlocked. Once the core backend recovers, every transaction is reconciled with the app stores, so no purchase is lost and no entitlement is granted incorrectly.

How do you prevent fraud with offline entitlements?

Offline access is signed and time-bounded. The SDK validates locally cached entitlements against a tamper-resistant signature, and the core backend independently re-verifies every receipt with the app stores once connectivity returns. Mismatched, replayed, or revoked purchases are dropped during reconciliation.

How do I test that my app handles outages correctly?

A sandbox environment and SDK helpers can simulate network failures, paywall fetch errors, and backend outages. You can verify the fallback paywall, cached entitlements, and reconciliation flow end to end before shipping without touching production.

What's your SLA and where can I see uptime history?

The platform targets 99.99% uptime, backed by a five-layer defense (SDK → Edge → Static CDN → Fortress → Core Backend). Real-time status and historical uptime are published on the public status page, with detailed post-incident reports for every SEV1 event.