Recurly Review: Subscription Billing and Churn Management Engines

Subscription Billing Orchestration and Multi-Gateway Core

Scaling a B2B or B2C subscription SaaS platform requires a robust billing engine that can manage multiple pricing models (such as flat-rate, tiered, usage-based, and seat-based pricing). As a subscription-focused platform, Recurly sits between your core application databases and your payment gateways. Rather than coupling your application logic directly to a single provider like Stripe, Recurly acts as an abstraction layer, allowing product teams to route payments across multiple gateways globally based on customer location and currency.

This multi-gateway architecture minimizes transaction decline rates by routing international cards to their native banks. For instance, a European buyer's credit card can be processed via Adyen, while a North American user's transaction goes to Chase Paymentech, optimizing transaction success metrics across the entire portfolio. By routing transactions to gateways with the highest probability of authorization, platforms reduce friction and boost subscriber retention. By diversifying processing lanes, businesses insulate themselves from single-point-of-failure vulnerabilities, maintaining transactional continuity even during peak seasonal volumes.

Technical Implementation: JSON Schema for Subscription Configuration

Recurly relies on structured configuration files to define billing cycles, plan add-ons, and grace periods. Instead of writing custom database models to handle renewal schedules, product teams create subscription templates in Recurly's dashboard or define them programmatically. Below is an example JSON plan configuration representing a standard professional seat-based plan with a 14-day trial period:

{
  "plan_code": "saas-pro-plan",
  "name": "Professional Subscription Tier",
  "interval_unit": "months",
  "interval_length": 1,
  "trial_unit": "days",
  "trial_length": 14,
  "currencies": [
    {
      "currency": "USD",
      "unit_amount": 49.00,
      "setup_fee": 0.00
    },
    {
      "currency": "EUR",
      "unit_amount": 45.00,
      "setup_fee": 0.00
    }
  ],
  "auto_renew": true,
  "pricing_model": "per_unit",
  "accounting_code": "rev-pro-100"
}

Using this plan configuration, developers can invoke Recurly's SDK to create a user subscription, and the platform automatically manages the billing cycles, generates PDF invoices, and tracks payment statuses without additional database cron jobs. It also handles proration logic automatically when users upgrade or downgrade mid-cycle, removing calculation complexity from application code. This automation saves hundreds of hours of manual engineering effort for SaaS platforms.

Dunning Algorithms and Smart Churn Management Telemetry

Involuntary churn—where subscriptions fail due to expired credit cards, transient bank network errors, or temporary card limit blocks—accounts for up to 30% of total SaaS churn. To combat this, Recurly utilizes machine learning-driven dunning retry systems. The system schedules card retries based on historical success logs rather than relying on static retry intervals (e.g., retrying every 24 hours).

Recurly's retry system claims to reduce involuntary card decline churn by an average of 22%. The retry engine schedules card checks based on optimal day-of-week and time-of-day metrics, while sending automated, white-labeled dunning email notifications to users. Product teams can customize these dunning cycles (e.g., 21-day cycles with 4 retry attempts) to match customer demographics and optimize retention rates. Detailed telemetry reports track every decline reason code (e.g., insufficient funds vs. expired card) to refine retries dynamically.

Database Schema for Subscription Tracking and Churn Analytics

To analyze dunning success rates and calculate Customer Lifetime Value (LTV), developers sync Recurly webhook events to local data warehouses. Tracking billing states locally enables growth leads to build dashboards that identify which subscription plans are prone to payment failures. Below is a relational SQL schema for storing subscription billing events:

CREATE TABLE recurly_subscriptions (
    subscription_id VARCHAR(64) PRIMARY KEY,
    account_code VARCHAR(128) NOT NULL,
    plan_code VARCHAR(64) NOT NULL,
    status VARCHAR(32) NOT NULL,
    current_period_start TIMESTAMP NOT NULL,
    current_period_end TIMESTAMP NOT NULL,
    dunning_attempts INT DEFAULT 0,
    trial_started_at TIMESTAMP NULL,
    trial_ended_at TIMESTAMP NULL,
    last_payment_status VARCHAR(32) NOT NULL,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Querying this database helps product teams identify trial-to-paid conversion bottlenecks and run targeted outreach campaigns for users currently stuck in active dunning states. This local dashboard is also used to calculate MRR (Monthly Recurring Revenue) growth trends, active subscriber counts, and average cohort retention rates across quarters.

RBI e-Mandate Regulations and Compliance in India

Deploying recurring billing subscriptions in the Indian market requires adhering to local regulatory guidelines. The Reserve Bank of India (RBI) e-mandate rules dictate that payment gateways cannot charge cards automatically without prior registration. Merchants must implement an Additional Factor of Authentication (AFA) during the initial signup flow to register the recurring mandate.

For recurring payments exceeding ₹15,000, platforms must send a pre-debit notification to the customer at least 24 hours before the actual charge occurs, and obtain the user's explicit consent for that specific transaction. Additionally, platforms must provide a portal for users to modify or withdraw their e-mandates at any time. Recurly integrates with local payments aggregators to support these compliant workflows, ensuring international SaaS brands can accept recurring payments from India without violating local guidelines. This prevents merchant accounts from being flagged or fined by local auditing bodies.